* Taeheon Kim <th908.kim@samsung.com>,
* YoungJun Cho <yj44.cho@samsung.com>,
* SooChan Lim <sc1.lim@samsung.com>,
- * Boram Park <sc1.lim@samsung.com>
+ * Boram Park <boram1288.park@samsung.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
#include "config.h"
#endif
-#include "tdm.h"
-#include "tdm_backend.h"
#include "tdm_private.h"
-#include "tdm_helper.h"
#define COUNT_MAX 10
TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
private_display = (tdm_private_display*)dpy;
-#define OUTPUT_FUNC_ENTRY() \
+#define BACKEND_FUNC_ENTRY() \
+ tdm_private_module *private_module; \
tdm_private_display *private_display; \
- tdm_private_output *private_output; \
tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
- TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER); \
- private_output = (tdm_private_output*)output; \
- private_display = private_output->private_display
+ TDM_RETURN_VAL_IF_FAIL(module != NULL, TDM_ERROR_INVALID_PARAMETER); \
+ private_module = (tdm_private_module*)module; \
+ private_display = private_module->private_display;
-#define OUTPUT_FUNC_ENTRY_ERROR() \
- tdm_private_display *private_display; \
- tdm_private_output *private_output; \
- tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
- TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(output != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
- private_output = (tdm_private_output*)output; \
- private_display = private_output->private_display
+/* LCOV_EXCL_START */
+INTERN tdm_error
+tdm_display_enable_debug_module(const char*modules)
+{
+ char temp[TDM_PATH_LEN];
+ char *arg;
+ char *end;
-#define LAYER_FUNC_ENTRY() \
- tdm_private_display *private_display; \
- tdm_private_output *private_output; \
- tdm_private_layer *private_layer; \
- tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
- TDM_RETURN_VAL_IF_FAIL(layer != NULL, TDM_ERROR_INVALID_PARAMETER); \
- private_layer = (tdm_private_layer*)layer; \
- private_output = private_layer->private_output; \
- private_display = private_output->private_display
+ snprintf(temp, TDM_PATH_LEN, "%s", modules);
-#define LAYER_FUNC_ENTRY_ERROR() \
- tdm_private_display *private_display; \
- tdm_private_output *private_output; \
- tdm_private_layer *private_layer; \
- tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
- TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(layer != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
- private_layer = (tdm_private_layer*)layer; \
- private_output = private_layer->private_output; \
- private_display = private_output->private_display
+ tdm_debug_module = 0;
-#define LAYER_FUNC_ENTRY_VOID_RETURN() \
- tdm_private_display *private_display; \
- tdm_private_output *private_output; \
- tdm_private_layer *private_layer; \
- tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
- TDM_RETURN_IF_FAIL(layer != NULL); \
- private_layer = (tdm_private_layer*)layer; \
- private_output = private_layer->private_output; \
- private_display = private_output->private_display
+ arg = strtok_r(temp, TDM_CONFIG_DELIM, &end);
+ while (arg) {
+ if (!strncmp(arg, "none", 4)) {
+ tdm_debug_module = 0;
+ return TDM_ERROR_NONE;
+ }
+ if (!strncmp(arg, "all", 3)) {
+ tdm_debug_module = 0xFFFFFFFF;
+ return TDM_ERROR_NONE;
+ }
+ if (!strncmp(arg, "buffer", 6))
+ tdm_debug_module |= TDM_DEBUG_BUFFER;
+ else if (!strncmp(arg, "event", 5))
+ tdm_debug_module |= TDM_DEBUG_EVENT;
+ else if (!strncmp(arg, "thread", 6))
+ tdm_debug_module |= TDM_DEBUG_THREAD;
+ else if (!strncmp(arg, "mutex", 5))
+ tdm_debug_module |= TDM_DEBUG_MUTEX;
+ else if (!strncmp(arg, "vblank", 6))
+ tdm_debug_module |= TDM_DEBUG_VBLANK;
+ else if (!strncmp(arg, "commit", 6))
+ tdm_debug_module |= TDM_DEBUG_COMMIT;
+
+ arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end);
+ }
+
+ TDM_INFO("module debugging... '%s'", modules);
+
+ return TDM_ERROR_NONE;
+}
+
+INTERN tdm_error
+tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_str, char *reply, int *len)
+{
+ char temp[TDM_PATH_LEN] = {0,}, temp2[TDM_PATH_LEN] = {0,};
+ char *path = NULL, *path2;
+ char *arg;
+ char *end;
+
+ snprintf(temp2, TDM_PATH_LEN, "%s", dump_str);
+ path2 = strtostr(temp, TDM_PATH_LEN, temp2, "@");
+ if (!path2 || path2[0] == '\0')
+ path2 = TDM_DUMP_DIR;
+ else
+ path2++;
+
+ tdm_debug_dump = 0;
+
+ snprintf(temp, sizeof(temp), "%s", dump_str);
+ arg = strtok_r(temp, ",", &end);
+ TDM_GOTO_IF_FAIL(arg != NULL, done);
+
+ if (!strncmp(arg, "none", 4)) {
+ tdm_debug_dump = 0;
+ TDM_SNPRINTF(reply, len, "path: %s\n", (tdm_debug_dump_dir) ? : "unknown");
+ if (tdm_debug_dump_dir) {
+ free(tdm_debug_dump_dir);
+ tdm_debug_dump_dir = NULL;
+ }
+ goto done;
+ }
+
+ path = tdm_helper_dump_make_directory(path2, reply, len);
+ TDM_GOTO_IF_FAIL(path != NULL, done);
+
+ if (!strncmp(arg, "current", 7)) {
+ tdm_private_module *b = NULL;
+ tdm_private_output *o = NULL;
+
+ if (!private_display) {
+ TDM_WRN("no private_display");
+ goto done;
+ }
+
+ LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) {
+ LIST_FOR_EACH_ENTRY(o, &b->output_list, link) {
+ tdm_private_layer *l = NULL;
+ LIST_FOR_EACH_ENTRY(l, &o->layer_list, link) {
+ char str[TDM_PATH_LEN];
+ if (l->usable || l->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)
+ continue;
+ if (!l->showing_buffer)
+ continue;
+ snprintf(str, TDM_PATH_LEN, "layer_%d_%d", o->index, l->index);
+ tdm_helper_dump_buffer_str(l->showing_buffer->buffer, path, str);
+ }
+ }
+ }
+
+ TDM_SNPRINTF(reply, len, "path: %s\n", path);
+ goto done;
+ }
+
+ TDM_SNPRINTF(reply, len, "dump: %s\n", arg);
+
+ while (arg) {
+ if (!strncmp(arg, "all", 3)) {
+ tdm_debug_dump = 0xFFFFFFFF;
+ goto done;
+ } else if (!strncmp(arg, "layer", 5)) {
+ tdm_debug_dump |= TDM_DUMP_FLAG_LAYER;
+ } else if (!strncmp(arg, "pp", 2)) {
+ tdm_debug_dump |= TDM_DUMP_FLAG_PP;
+ } else if (!strncmp(arg, "capture", 7)) {
+ tdm_debug_dump |= TDM_DUMP_FLAG_CAPTURE;
+ } else if (!strncmp(arg, "window", 6)) {
+ tdm_debug_dump |= TDM_DUMP_FLAG_WINDOW;
+ } else
+ goto done;
+
+ arg = strtok_r(NULL, ",", &end);
+ }
+
+ if (tdm_debug_dump_dir)
+ free(tdm_debug_dump_dir);
+
+ tdm_debug_dump_dir = strndup(path, TDM_PATH_LEN);
+
+ TDM_INFO("dump... '%s'", dump_str);
+
+done:
+ if (path)
+ free(path);
+
+ return TDM_ERROR_NONE;
+}
+
+static void
+_tdm_display_ttrace_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
+ unsigned int tv_sec, unsigned int tv_usec, void *user_data)
+{
+ tdm_error ret = TDM_ERROR_NONE;
+
+ TDM_TRACE_MARK("VSYNC");
+
+ ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
+ TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
+}
+
+INTERN tdm_error
+tdm_display_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable)
+{
+ tdm_private_display *private_display = dpy;
+ tdm_private_module *private_module = NULL;
+ tdm_private_output *private_output = NULL;
+ const tdm_output_mode *mode = NULL;
+ tdm_vblank *vblank = NULL;
+ tdm_error ret = TDM_ERROR_NONE;
+
+ if (!enable) {
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ if (private_output->ttrace_vblank)
+ tdm_vblank_destroy(private_output->ttrace_vblank);
+ private_output->ttrace_vblank = NULL;
+ }
+ }
+ return TDM_ERROR_NONE;
+ }
+
+ private_output = output;
+ TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+ if (private_output->ttrace_vblank)
+ return TDM_ERROR_NONE;
+
+ vblank = tdm_vblank_create(private_display, output, &ret);
+ TDM_RETURN_VAL_IF_FAIL(vblank != NULL, ret);
+
+ ret = tdm_output_get_mode(output, &mode);
+ TDM_GOTO_IF_FAIL(mode != NULL, enable_fail);
+
+ ret = tdm_vblank_set_fps(vblank, mode->vrefresh);
+ TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
+
+ ret = tdm_vblank_set_enable_fake(vblank, 1);
+ TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
+
+ ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
+ TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
+
+ private_output->ttrace_vblank = vblank;
+
+ return TDM_ERROR_NONE;
+
+enable_fail:
+ if (vblank)
+ tdm_vblank_destroy(vblank);
+
+ return ret;
+}
+
+INTERN tdm_error
+tdm_display_enable_ttrace(tdm_private_display *private_display, const char *ttrace, int output_id, char *reply, int *len)
+{
+ char temp[TDM_PATH_LEN];
+ char *arg;
+ char *end;
+ tdm_output *output;
+ tdm_error ret;
+ tdm_output_type type;
+
+ snprintf(temp, TDM_PATH_LEN, "%s", ttrace);
+
+ tdm_ttrace_output = output_id;
+ tdm_ttrace_module = 0;
+
+ output = tdm_display_get_output(private_display, output_id, &ret);
+ if (!output) {
+ TDM_SNPRINTF(reply, len, "can't find the output_id(%d)\n", output_id);
+ return ret;
+ }
+
+ ret = tdm_output_get_output_type(output, &type);
+ if (ret != TDM_ERROR_NONE) {
+ TDM_SNPRINTF(reply, len, "can't find the type of output_id(%d)\n", output_id);
+ return ret;
+ }
+
+ arg = strtok_r(temp, TDM_CONFIG_DELIM, &end);
+ while (arg) {
+ if (!strncmp(arg, "none", 4))
+ tdm_ttrace_module = 0;
+ else if (!strncmp(arg, "all", 3))
+ tdm_ttrace_module = 0xFFFFFFFF;
+ else if (!strncmp(arg, "vsync", 5))
+ tdm_ttrace_module |= TDM_TTRACE_VSYNC;
+ else if (!strncmp(arg, "client_vblank", 13))
+ tdm_ttrace_module |= TDM_TTRACE_CLIENT_VBLANK;
+ else if (!strncmp(arg, "server_vblank", 13))
+ tdm_ttrace_module |= TDM_TTRACE_SERVER_VBLANK;
+ else if (!strncmp(arg, "vblank", 6))
+ tdm_ttrace_module |= TDM_TTRACE_VBLANK;
+ else if (!strncmp(arg, "layer", 5))
+ tdm_ttrace_module |= TDM_TTRACE_LAYER;
+ else if (!strncmp(arg, "pp", 2))
+ tdm_ttrace_module |= TDM_TTRACE_PP;
+ else if (!strncmp(arg, "capture", 7))
+ tdm_ttrace_module |= TDM_TTRACE_CAPTURE;
+ else {
+ tdm_ttrace_module = 0;
+ tdm_display_enable_ttrace_vblank(private_display, NULL, 0);
+ tdm_server_enable_ttrace_client_vblank(private_display, NULL, 0);
+ TDM_SNPRINTF(reply, len, "unknown option: '%s'\n", arg);
+ return TDM_ERROR_NONE;
+ }
+
+ arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end);
+ }
+
+ TDM_SNPRINTF(reply, len, "ttrace debugging... '%s' %x\n", ttrace, tdm_ttrace_module);
+
+ if (tdm_ttrace_module & TDM_TTRACE_VSYNC)
+ tdm_display_enable_ttrace_vblank(private_display, output, 1);
+ else
+ tdm_display_enable_ttrace_vblank(private_display, NULL, 0);
+
+ if (tdm_ttrace_module & TDM_TTRACE_CLIENT_VBLANK)
+ tdm_server_enable_ttrace_client_vblank(private_display, output, 1);
+ else
+ tdm_server_enable_ttrace_client_vblank(private_display, NULL, 0);
+
+ return TDM_ERROR_NONE;
+}
+
+INTERN tdm_error
+tdm_display_enable_fps(tdm_private_display *private_display, int enable)
+{
+ private_display->print_fps = enable;
+
+ TDM_INFO("print fps: %s", (enable) ? "enable" : "disable");
+
+ return TDM_ERROR_NONE;
+}
+/* LCOV_EXCL_STOP */
+
+INTERN tdm_error
+tdm_display_call_thread_cb_output_create(tdm_private_display *private_display, tdm_output *output)
+{
+ tdm_thread_cb_display_output_create output_create;
+ tdm_error ret;
+
+ if (LIST_IS_EMPTY(&private_display->output_create_handler_list)) return TDM_ERROR_NONE;
+
+ memset(&output_create, 0, sizeof output_create);
+ output_create.base.type = TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE;
+ output_create.base.length = sizeof output_create;
+ output_create.base.object_stamp = tdm_helper_get_time();
+ output_create.base.data = NULL;
+ output_create.base.sync = 1;
+ output_create.output = output;
+
+ ret = tdm_thread_cb_call(private_display, &output_create.base, 1);
+ TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+
+ return TDM_ERROR_NONE;
+}
+
+INTERN void
+tdm_display_thread_cb_output_create(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
+{
+ tdm_thread_cb_display_output_create *output_create = (tdm_thread_cb_display_output_create*)cb_base;
+ tdm_private_output_create_handler *create_handler = user_data;
+ TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
+
+ assert(create_handler->owner_tid == syscall(SYS_gettid));
+
+ _pthread_mutex_unlock(&private_display->lock);
+ create_handler->func(private_display, output_create->output, create_handler->user_data);
+ _pthread_mutex_lock(&private_display->lock);
+}
+
+EXTERN tdm_error
+tdm_display_add_output_create_handler(tdm_display *dpy,
+ tdm_output_create_handler func,
+ void *user_data)
+{
+ tdm_private_output_create_handler *create_handler = NULL;
+
+ DISPLAY_FUNC_ENTRY();
+
+ TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+ _pthread_mutex_lock(&private_display->lock);
+
+ LIST_FOR_EACH_ENTRY(create_handler, &private_display->output_create_handler_list, link) {
+ if (create_handler->func == func && create_handler->user_data == user_data) {
+ TDM_ERR("can't add twice");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_BAD_REQUEST;
+ }
+ }
+
+ create_handler = calloc(1, sizeof(tdm_private_output_create_handler));
+ if (!create_handler) {
+ TDM_ERR("failed: alloc memory");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_OUT_OF_MEMORY;
+ }
+
+ ret = tdm_thread_cb_add(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
+ tdm_display_thread_cb_output_create, create_handler);
+ if (ret != TDM_ERROR_NONE) {
+ TDM_ERR("tdm_thread_cb_add failed");
+ free(create_handler);
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_OPERATION_FAILED;
+ }
+
+ create_handler->private_display = private_display;
+ create_handler->func = func;
+ create_handler->user_data = user_data;
+ create_handler->owner_tid = syscall(SYS_gettid);
+
+ LIST_ADDTAIL(&create_handler->link, &private_display->output_create_handler_list);
+
+ _pthread_mutex_unlock(&private_display->lock);
+
+ return ret;
+}
+
+EXTERN void
+tdm_display_remove_output_create_handler(tdm_display *dpy,
+ tdm_output_create_handler func,
+ void *user_data)
+{
+ tdm_private_display *private_display;
+ tdm_private_output_create_handler *create_handler = NULL, *hh = NULL;
+
+ TDM_RETURN_IF_FAIL(dpy != NULL);
+ TDM_RETURN_IF_FAIL(func != NULL);
+
+ private_display = (tdm_private_display*)dpy;
+
+ _pthread_mutex_lock(&private_display->lock);
+
+ LIST_FOR_EACH_ENTRY_SAFE(create_handler, hh, &private_display->output_create_handler_list, link) {
+ if (create_handler->func != func || create_handler->user_data != user_data)
+ continue;
+
+ tdm_thread_cb_remove(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
+ tdm_display_thread_cb_output_create, create_handler);
+
+ LIST_DEL(&create_handler->link);
+ free(create_handler);
+
+ _pthread_mutex_unlock(&private_display->lock);
+
+ return;
+ }
+
+ _pthread_mutex_unlock(&private_display->lock);
+}
EXTERN tdm_error
tdm_display_get_capabilities(tdm_display *dpy,
tdm_display_capability *capabilities)
{
+ tdm_private_module *private_module = NULL;
+
DISPLAY_FUNC_ENTRY();
TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
_pthread_mutex_lock(&private_display->lock);
- *capabilities = private_display->capabilities;
+ *capabilities = 0;
+
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ *capabilities |= private_module->capabilities;
+ }
_pthread_mutex_unlock(&private_display->lock);
tdm_display_get_pp_capabilities(tdm_display *dpy,
tdm_pp_capability *capabilities)
{
+ tdm_private_module *pp_module;
+
DISPLAY_FUNC_ENTRY();
TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
_pthread_mutex_lock(&private_display->lock);
- if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
+ if (!private_display->pp_module) {
+ /* LCOV_EXCL_START */
TDM_ERR("no pp capability");
_pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NO_CAPABILITY;
+ /* LCOV_EXCL_STOP */
}
- *capabilities = private_display->caps_pp.capabilities;
+ pp_module = private_display->pp_module;
+
+ *capabilities = pp_module->caps_pp.capabilities;
_pthread_mutex_unlock(&private_display->lock);
tdm_display_get_pp_available_formats(tdm_display *dpy,
const tbm_format **formats, int *count)
{
+ tdm_private_module *pp_module;
+
DISPLAY_FUNC_ENTRY();
TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
_pthread_mutex_lock(&private_display->lock);
- if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
+ if (!private_display->pp_module) {
+ /* LCOV_EXCL_START */
TDM_ERR("no pp capability");
_pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NO_CAPABILITY;
+ /* LCOV_EXCL_STOP */
}
- *formats = (const tbm_format *)private_display->caps_pp.formats;
- *count = private_display->caps_pp.format_count;
+ pp_module = private_display->pp_module;
+
+ *formats = (const tbm_format *)pp_module->caps_pp.formats;
+ *count = pp_module->caps_pp.format_count;
_pthread_mutex_unlock(&private_display->lock);
tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h,
int *max_w, int *max_h, int *preferred_align)
{
+ tdm_private_module *pp_module;
+
DISPLAY_FUNC_ENTRY();
_pthread_mutex_lock(&private_display->lock);
- if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
+ if (!private_display->pp_module) {
+ /* LCOV_EXCL_START */
TDM_ERR("no pp capability");
_pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NO_CAPABILITY;
+ /* LCOV_EXCL_STOP */
}
+ pp_module = private_display->pp_module;
+
if (min_w)
- *min_w = TDM_FRONT_VALUE(private_display->caps_pp.min_w);
+ *min_w = TDM_FRONT_VALUE(pp_module->caps_pp.min_w);
if (min_h)
- *min_h = TDM_FRONT_VALUE(private_display->caps_pp.min_h);
+ *min_h = TDM_FRONT_VALUE(pp_module->caps_pp.min_h);
if (max_w)
- *max_w = TDM_FRONT_VALUE(private_display->caps_pp.max_w);
+ *max_w = TDM_FRONT_VALUE(pp_module->caps_pp.max_w);
if (max_h)
- *max_h = TDM_FRONT_VALUE(private_display->caps_pp.max_h);
+ *max_h = TDM_FRONT_VALUE(pp_module->caps_pp.max_h);
if (preferred_align)
- *preferred_align = TDM_FRONT_VALUE(private_display->caps_pp.preferred_align);
+ *preferred_align = TDM_FRONT_VALUE(pp_module->caps_pp.preferred_align);
+
+ _pthread_mutex_unlock(&private_display->lock);
+
+ return ret;
+}
+
+EXTERN tdm_error
+tdm_display_get_pp_preferred_align_vertical(tdm_display *dpy, int *preferred_align_vertical)
+{
+ tdm_private_module *pp_module;
+
+ DISPLAY_FUNC_ENTRY();
+
+ _pthread_mutex_lock(&private_display->lock);
+
+ if (!private_display->pp_module) {
+ /* LCOV_EXCL_START */
+ TDM_ERR("no pp capability");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_NO_CAPABILITY;
+ /* LCOV_EXCL_STOP */
+ }
+
+ pp_module = private_display->pp_module;
+
+ if (preferred_align_vertical)
+ *preferred_align_vertical = TDM_FRONT_VALUE(pp_module->caps_pp.preferred_align_vertical);
_pthread_mutex_unlock(&private_display->lock);
tdm_display_get_capture_capabilities(tdm_display *dpy,
tdm_capture_capability *capabilities)
{
+ tdm_private_module *capture_module;
+
DISPLAY_FUNC_ENTRY();
TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
_pthread_mutex_lock(&private_display->lock);
- if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
+ if (!private_display->capture_module) {
+ /* LCOV_EXCL_START */
TDM_ERR("no capture capability");
_pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NO_CAPABILITY;
+ /* LCOV_EXCL_STOP */
}
- *capabilities = private_display->caps_capture.capabilities;
+ capture_module = private_display->capture_module;
+
+ *capabilities = capture_module->caps_capture.capabilities;
_pthread_mutex_unlock(&private_display->lock);
}
EXTERN tdm_error
-tdm_display_get_catpure_available_formats(tdm_display *dpy,
+tdm_display_get_capture_available_formats(tdm_display *dpy,
const tbm_format **formats, int *count)
{
+ tdm_private_module *capture_module;
+
DISPLAY_FUNC_ENTRY();
TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
_pthread_mutex_lock(&private_display->lock);
- if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
+ if (!private_display->capture_module) {
+ /* LCOV_EXCL_START */
TDM_ERR("no capture capability");
_pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NO_CAPABILITY;
+ /* LCOV_EXCL_STOP */
}
- *formats = (const tbm_format *)private_display->caps_capture.formats;
- *count = private_display->caps_capture.format_count;
+ capture_module = private_display->capture_module;
+
+ *formats = (const tbm_format *)capture_module->caps_capture.formats;
+ *count = capture_module->caps_capture.format_count;
_pthread_mutex_unlock(&private_display->lock);
tdm_display_get_capture_available_size(tdm_display *dpy, int *min_w, int *min_h,
int *max_w, int *max_h, int *preferred_align)
{
+ tdm_private_module *capture_module;
+
DISPLAY_FUNC_ENTRY();
_pthread_mutex_lock(&private_display->lock);
- if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
+ if (!private_display->capture_module) {
+ /* LCOV_EXCL_START */
TDM_ERR("no capture capability");
_pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NO_CAPABILITY;
+ /* LCOV_EXCL_STOP */
}
+ capture_module = private_display->capture_module;
+
if (min_w)
- *min_w = TDM_FRONT_VALUE(private_display->caps_capture.min_w);
+ *min_w = TDM_FRONT_VALUE(capture_module->caps_capture.min_w);
if (min_h)
- *min_h = TDM_FRONT_VALUE(private_display->caps_capture.min_h);
+ *min_h = TDM_FRONT_VALUE(capture_module->caps_capture.min_h);
if (max_w)
- *max_w = TDM_FRONT_VALUE(private_display->caps_capture.max_w);
+ *max_w = TDM_FRONT_VALUE(capture_module->caps_capture.max_w);
if (max_h)
- *max_h = TDM_FRONT_VALUE(private_display->caps_capture.max_h);
+ *max_h = TDM_FRONT_VALUE(capture_module->caps_capture.max_h);
if (preferred_align)
- *preferred_align = TDM_FRONT_VALUE(private_display->caps_capture.preferred_align);
+ *preferred_align = TDM_FRONT_VALUE(capture_module->caps_capture.preferred_align);
_pthread_mutex_unlock(&private_display->lock);
EXTERN tdm_error
tdm_display_get_max_layer_count(tdm_display *dpy, int *max_count)
{
- DISPLAY_FUNC_ENTRY();
-
+ TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER);
TDM_RETURN_VAL_IF_FAIL(max_count != NULL, TDM_ERROR_INVALID_PARAMETER);
- _pthread_mutex_lock(&private_display->lock);
-
- *max_count = TDM_FRONT_VALUE(private_display->caps_display.max_layer_count);
+ TDM_DEPRECATED(NULL);
- _pthread_mutex_unlock(&private_display->lock);
+ *max_count = -1;
- return ret;
+ return TDM_ERROR_NONE;
}
EXTERN tdm_error
tdm_display_get_output_count(tdm_display *dpy, int *count)
{
+ tdm_private_module *private_module = NULL;
tdm_private_output *private_output = NULL;
DISPLAY_FUNC_ENTRY();
_pthread_mutex_lock(&private_display->lock);
*count = 0;
- LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
- (*count)++;
-
- if (*count == 0) {
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ (*count)++;
+ }
}
_pthread_mutex_unlock(&private_display->lock);
EXTERN tdm_output *
tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
{
+ tdm_private_module *private_module = NULL;
tdm_private_output *private_output = NULL;
DISPLAY_FUNC_ENTRY_ERROR();
if (error)
*error = TDM_ERROR_NONE;
- LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) {
- if (private_output->index == index) {
- _pthread_mutex_unlock(&private_display->lock);
- return private_output;
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ if (private_output->index == index) {
+ _pthread_mutex_unlock(&private_display->lock);
+ return private_output;
+ }
}
}
return NULL;
}
-EXTERN tdm_error
-tdm_display_get_fd(tdm_display *dpy, int *fd)
+EXTERN tdm_output *
+tdm_display_find_output(tdm_display *dpy, const char *name, tdm_error *error)
{
- DISPLAY_FUNC_ENTRY();
+ tdm_private_module *private_module = NULL;
+ tdm_private_output *private_output = NULL;
+ tdm_private_output *mode_setted_output = NULL;
+ tdm_private_output *connected_output = NULL;
+ unsigned int find_primary = 0;
- TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
+ DISPLAY_FUNC_ENTRY_ERROR();
+
+ if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7))
+ find_primary = 1;
_pthread_mutex_lock(&private_display->lock);
- if (tdm_thread_is_running())
- *fd = tdm_thread_get_fd(private_display->private_loop);
- else
- *fd = tdm_event_loop_get_fd(private_display);
+ if (error)
+ *error = TDM_ERROR_NONE;
- _pthread_mutex_unlock(&private_display->lock);
+ if (find_primary) {
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_CONNECTED && !connected_output)
+ connected_output = private_output;
+ else if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED && !mode_setted_output)
+ mode_setted_output = private_output;
+ }
+ }
- return ret;
-}
+ if (mode_setted_output) {
+ _pthread_mutex_unlock(&private_display->lock);
+ return mode_setted_output;
+ }
-EXTERN tdm_error
-tdm_display_handle_events(tdm_display *dpy)
-{
- struct pollfd fds;
- int fd = -1;
+ if (connected_output) {
+ _pthread_mutex_unlock(&private_display->lock);
+ return connected_output;
+ }
- DISPLAY_FUNC_ENTRY();
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ if (private_output->index == 0) {
+ _pthread_mutex_unlock(&private_display->lock);
+ return private_output;
+ }
+ }
+ }
+ }
+
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ if (strncmp(private_output->caps.model, name, TDM_NAME_LEN))
+ continue;
+ _pthread_mutex_unlock(&private_display->lock);
+ return private_output;
+ }
+ }
+
+ if (private_display->virtual_module) {
+ private_module = private_display->virtual_module;
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ if (strncmp(private_output->name, name, TDM_NAME_LEN))
+ continue;
+ _pthread_mutex_unlock(&private_display->lock);
+ return private_output;
+ }
+ }
+ _pthread_mutex_unlock(&private_display->lock);
+
+ return NULL;
+}
+
+EXTERN tdm_error
+tdm_display_get_fd(tdm_display *dpy, int *fd)
+{
+ DISPLAY_FUNC_ENTRY();
+
+ TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+ _pthread_mutex_lock(&private_display->lock);
+
+ if (tdm_thread_is_running())
+ *fd = tdm_thread_get_fd(private_display->private_loop);
+ else
+ *fd = tdm_event_loop_get_fd(private_display);
+
+ _pthread_mutex_unlock(&private_display->lock);
+
+ return ret;
+}
+
+EXTERN tdm_error
+tdm_display_handle_events(tdm_display *dpy)
+{
+ struct pollfd fds;
+ int fd = -1;
+
+ DISPLAY_FUNC_ENTRY();
ret = tdm_display_get_fd(dpy, &fd);
TDM_RETURN_VAL_IF_FAIL(fd >= 0, ret);
fds.fd = fd;
fds.revents = 0;
- if (tdm_debug_module & TDM_DEBUG_THREAD)
+ if (tdm_debug_module & TDM_DEBUG_EVENT)
TDM_INFO("fd(%d) polling in", fd);
while (poll(&fds, 1, -1) < 0) {
+ /* LCOV_EXCL_START */
if (errno == EINTR || errno == EAGAIN) /* normal case */
continue;
else {
TDM_ERR("poll failed: %m");
return TDM_ERROR_OPERATION_FAILED;
}
+ /* LCOV_EXCL_STOP */
}
- if (tdm_debug_module & TDM_DEBUG_THREAD)
+ if (tdm_debug_module & TDM_DEBUG_EVENT)
TDM_INFO("fd(%d) polling out", fd);
- if (tdm_thread_is_running())
+ if (tdm_thread_is_running()) {
+ _pthread_mutex_lock(&private_display->lock);
ret = tdm_thread_handle_cb(private_display->private_loop);
- else
+ _pthread_mutex_unlock(&private_display->lock);
+ } else {
ret = tdm_event_loop_dispatch(private_display);
+ }
return ret;
}
+EXTERN void
+tdm_display_flush(tdm_display *dpy)
+{
+ tdm_private_display *private_display;
+
+ TDM_RETURN_IF_FAIL(dpy != NULL);
+ private_display = (tdm_private_display*)dpy;
+
+ if (tdm_thread_is_running())
+ return;
+
+ tdm_event_loop_flush(private_display);
+}
+
EXTERN tdm_error
tdm_display_get_backend_info(tdm_display *dpy, const char **name,
const char **vendor, int *major, int *minor)
{
- tdm_backend_module *module_data;
+ tdm_private_module *private_module = NULL;
+ tdm_backend_module *module_data = NULL;
DISPLAY_FUNC_ENTRY();
+ TDM_DEPRECATED("Use tdm_module_get_info");
+
_pthread_mutex_lock(&private_display->lock);
- module_data = private_display->module_data;
+ /* use first backend */
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ module_data = private_module->module_data;
+ break;
+ }
+
+ assert(module_data != NULL);
if (name)
*name = module_data->name;
_pthread_mutex_lock(&private_display->lock);
- pp = (tdm_pp *)tdm_pp_create_internal(private_display, error);
+ pp = (tdm_pp *)tdm_pp_create_internal(private_display->pp_module, error);
_pthread_mutex_unlock(&private_display->lock);
}
EXTERN tdm_error
-tdm_output_get_model_info(tdm_output *output, const char **maker,
- const char **model, const char **name)
-{
- OUTPUT_FUNC_ENTRY();
-
- _pthread_mutex_lock(&private_display->lock);
-
- if (maker)
- *maker = private_output->caps.maker;
- if (model)
- *model = private_output->caps.model;
- if (name)
- *name = private_output->caps.name;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_capabilities(tdm_output *output, tdm_output_capability *capabilities)
+tdm_module_get_info(tdm_module *module, const char **name,
+ const char **vendor, int *major, int *minor)
{
- OUTPUT_FUNC_ENTRY();
+ tdm_backend_module *module_data;
- TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
+ BACKEND_FUNC_ENTRY();
_pthread_mutex_lock(&private_display->lock);
- *capabilities = private_output->caps.capabilities;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status)
-{
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
+ module_data = private_module->module_data;
- *status = private_output->caps.status;
+ if (name)
+ *name = module_data->name;
+ if (vendor)
+ *vendor = module_data->vendor;
+ if (major)
+ *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
+ if (minor)
+ *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
_pthread_mutex_unlock(&private_display->lock);
return ret;
}
-static void
-_tdm_output_update(tdm_output *output_backend, void *user_data)
-{
- tdm_private_display *private_display;
- tdm_private_output *private_output = user_data;
- tdm_error ret;
-
- TDM_RETURN_IF_FAIL(private_output);
-
- private_display = private_output->private_display;
-
- ret = tdm_display_update_output(private_display, output_backend, private_output->pipe);
- TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
-}
-
-INTERN void
-tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status,
- void *user_data)
-{
- tdm_private_display *private_display;
- tdm_private_output *private_output = user_data;
- tdm_value value;
-
- TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
- TDM_RETURN_IF_FAIL(private_output);
-
- private_display = private_output->private_display;
-
- if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
- tdm_thread_cb_output_status output_status;
- tdm_error ret;
-
- _tdm_output_update(output_backend, user_data);
-
- output_status.base.type = TDM_THREAD_CB_OUTPUT_STATUS;
- output_status.base.length = sizeof output_status;
- output_status.output_stamp = private_output->stamp;
- output_status.status = status;
- output_status.user_data = user_data;
-
- value.u32 = status;
- tdm_output_call_change_handler_internal(private_output,
- &private_output->change_handler_list_sub,
- TDM_OUTPUT_CHANGE_CONNECTION,
- value, 0);
-
- ret = tdm_thread_send_cb(private_display->private_loop, &output_status.base);
- TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
- return;
- }
-
- if (!tdm_thread_is_running())
- _tdm_output_update(output_backend, user_data);
-
- value.u32 = status;
- tdm_output_call_change_handler_internal(private_output,
- &private_output->change_handler_list_main,
- TDM_OUTPUT_CHANGE_CONNECTION,
- value, 0);
-}
-
-EXTERN tdm_error
-tdm_output_add_change_handler(tdm_output *output,
- tdm_output_change_handler func,
- void *user_data)
+INTERN int
+tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin)
{
- tdm_private_change_handler *change_handler;
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
-
- change_handler = calloc(1, sizeof(tdm_private_change_handler));
- if (!change_handler) {
- TDM_ERR("failed: alloc memory");
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_OUT_OF_MEMORY;
- }
+ tdm_backend_module *module = private_module->module_data;
- change_handler->private_output = private_output;
- change_handler->func = func;
- change_handler->user_data = user_data;
- change_handler->owner_tid = syscall(SYS_gettid);
+ if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) > abimaj)
+ return 1;
- if (!tdm_thread_in_display_thread(change_handler->owner_tid))
- LIST_ADD(&change_handler->link, &private_output->change_handler_list_sub);
- else
- LIST_ADD(&change_handler->link, &private_output->change_handler_list_main);
+ if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj)
+ return 0;
- _pthread_mutex_unlock(&private_display->lock);
+ if (TDM_BACKEND_GET_ABI_MINOR(module->abi_version) < abimin)
+ return 0;
- return ret;
+ return 1;
}
-EXTERN void
-tdm_output_remove_change_handler(tdm_output *output,
- tdm_output_change_handler func,
- void *user_data)
+INTERN tdm_voutput *
+tdm_display_voutput_create(tdm_display *dpy, const char *name, tdm_error *error)
{
+ tdm_private_module *private_module = NULL;
+ tdm_private_module *current_module = NULL;
+ tdm_private_voutput *private_voutput = NULL;
+ tdm_private_output *private_output = NULL;
+ tdm_func_display *func_display = NULL;
+ tdm_func_voutput *func_voutput = NULL;
+ tdm_voutput *voutput_backend = NULL;
+ tdm_output *output_backend = NULL;
+ int output_find = 0;
tdm_private_display *private_display;
- tdm_private_output *private_output;
- tdm_private_change_handler *h = NULL, *hh = NULL;
-
- TDM_RETURN_IF_FAIL(output != NULL);
- TDM_RETURN_IF_FAIL(func != NULL);
+ tdm_error ret = TDM_ERROR_NONE;
- private_output = (tdm_private_output*)output;
- private_display = private_output->private_display;
+ TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL);
+ private_display = (tdm_private_display*)dpy;
+ private_module = private_display->virtual_module;
+ TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_module != NULL, TDM_ERROR_BAD_MODULE, NULL);
_pthread_mutex_lock(&private_display->lock);
- LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_main, link) {
- if (h->func != func || h->user_data != user_data)
- continue;
-
- LIST_DEL(&h->link);
- free(h);
+ if (error) *error = TDM_ERROR_NONE;
+ private_voutput = calloc(1, sizeof(tdm_private_voutput));
+ if (!private_voutput) {
+ if (error) *error = TDM_ERROR_OUT_OF_MEMORY;
_pthread_mutex_unlock(&private_display->lock);
-
- return;
+ return NULL;
}
- LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_sub, link) {
- if (h->func != func || h->user_data != user_data)
- continue;
+ func_display = &private_module->func_display;
+ func_voutput = &private_module->func_voutput;
+ current_module = private_display->current_module;
+ private_display->current_module = private_module;
- LIST_DEL(&h->link);
- free(h);
+ voutput_backend = func_display->display_voutput_create(private_module->bdata, name, &ret);
+ if (voutput_backend == NULL || ret != TDM_ERROR_NONE) {
+ TDM_ERR("display_voutput_create fail");
+ free(private_voutput);
+ if (error) *error = ret;
+ private_display->current_module = current_module;
_pthread_mutex_unlock(&private_display->lock);
-
- return;
+ return NULL;
}
-
- _pthread_mutex_unlock(&private_display->lock);
-}
-
-EXTERN tdm_error
-tdm_output_get_output_type(tdm_output *output, tdm_output_type *type)
-{
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(type != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- *type = private_output->caps.type;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_layer_count(tdm_output *output, int *count)
-{
- tdm_private_layer *private_layer = NULL;
-
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- *count = 0;
- LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
- (*count)++;
- if (*count == 0) {
+ private_voutput->voutput_backend = voutput_backend;
+ private_voutput->private_display = private_display;
+ private_voutput->private_module = private_module;
+ LIST_INITHEAD(&private_voutput->voutput_commit_handler_list);
+
+ output_backend = func_voutput->voutput_get_output(voutput_backend, &ret);
+ if (output_backend == NULL || ret != TDM_ERROR_NONE) {
+ TDM_ERR("voutput_get_output fail");
+ free(private_voutput);
+ if (error) *error = ret;
+ if (func_voutput->voutput_destroy)
+ func_voutput->voutput_destroy(voutput_backend);
+ else
+ TDM_ERR("no destroy function");
+ private_display->current_module = current_module;
_pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
+ return NULL;
}
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-
-EXTERN tdm_layer *
-tdm_output_get_layer(tdm_output *output, int index, tdm_error *error)
-{
- tdm_private_layer *private_layer = NULL;
-
- OUTPUT_FUNC_ENTRY_ERROR();
-
- _pthread_mutex_lock(&private_display->lock);
-
- if (error)
- *error = TDM_ERROR_NONE;
+ ret = tdm_display_update_output(private_display->current_module, output_backend);
+ if (ret != TDM_ERROR_NONE) {
+ TDM_ERR("tdm_display_update_output fail");
+ free(private_voutput);
+ if (func_voutput->voutput_destroy)
+ func_voutput->voutput_destroy(voutput_backend);
+ else
+ TDM_ERR("no destroy function");
+ if (error) *error = ret;
+ private_display->current_module = current_module;
+ _pthread_mutex_unlock(&private_display->lock);
+ return NULL;
+ }
- LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
- if (private_layer->index == index) {
- _pthread_mutex_unlock(&private_display->lock);
- return private_layer;
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ if (private_output->output_backend == output_backend) {
+ output_find = 1;
+ break;
}
}
- _pthread_mutex_unlock(&private_display->lock);
-
- return NULL;
-}
-
-EXTERN tdm_error
-tdm_output_get_available_properties(tdm_output *output, const tdm_prop **props,
- int *count)
-{
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
- TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- *props = (const tdm_prop *)private_output->caps.props;
- *count = private_output->caps.prop_count;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_available_modes(tdm_output *output,
- const tdm_output_mode **modes, int *count)
-{
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(modes != NULL, TDM_ERROR_INVALID_PARAMETER);
- TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- *modes = (const tdm_output_mode *)private_output->caps.modes;
- *count = private_output->caps.mode_count;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_available_size(tdm_output *output, int *min_w, int *min_h,
- int *max_w, int *max_h, int *preferred_align)
-{
- OUTPUT_FUNC_ENTRY();
-
- _pthread_mutex_lock(&private_display->lock);
-
- if (min_w)
- *min_w = TDM_FRONT_VALUE(private_output->caps.min_w);
- if (min_h)
- *min_h = TDM_FRONT_VALUE(private_output->caps.min_h);
- if (max_w)
- *max_w = TDM_FRONT_VALUE(private_output->caps.max_w);
- if (max_h)
- *max_h = TDM_FRONT_VALUE(private_output->caps.max_h);
- if (preferred_align)
- *preferred_align = TDM_FRONT_VALUE(private_output->caps.preferred_align);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_cursor_available_size(tdm_output *output, int *min_w, int *min_h,
- int *max_w, int *max_h, int *preferred_align)
-{
- OUTPUT_FUNC_ENTRY();
-
- _pthread_mutex_lock(&private_display->lock);
-
- if (!tdm_display_check_module_abi(private_display, 1, 5)) {
+ if (output_find != 1) {
+ private_output = NULL;
+ free(private_voutput);
+ if (func_voutput->voutput_destroy)
+ func_voutput->voutput_destroy(voutput_backend);
+ else
+ TDM_ERR("no destroy function");
+ private_voutput = NULL;
+ } else {
+ strncpy(private_voutput->name, name, TDM_NAME_LEN - 1);
+ private_voutput->name[TDM_NAME_LEN - 1] = '\0';
+ strncpy(private_output->name, name, TDM_NAME_LEN - 1);
+ private_output->name[TDM_NAME_LEN - 1] = '\0';
- if (min_w)
- *min_w = -1;
- if (min_h)
- *min_h = -1;
- if (max_w)
- *max_w = -1;
- if (max_h)
- *max_h = -1;
- if (preferred_align)
- *preferred_align = -1;
+ private_voutput->private_output = private_output;
+ private_output->private_voutput = private_voutput;
- _pthread_mutex_unlock(&private_display->lock);
+ /* do not use vblank */
+ tdm_output_choose_commit_per_vblank_mode(private_output, 0);
- return TDM_ERROR_BAD_MODULE;
+ LIST_ADDTAIL(&private_voutput->link, &private_module->voutput_list);
}
- if (min_w)
- *min_w = TDM_FRONT_VALUE(private_output->caps.cursor_min_w);
- if (min_h)
- *min_h = TDM_FRONT_VALUE(private_output->caps.cursor_min_h);
- if (max_w)
- *max_w = TDM_FRONT_VALUE(private_output->caps.cursor_max_w);
- if (max_h)
- *max_h = TDM_FRONT_VALUE(private_output->caps.cursor_max_h);
- if (preferred_align)
- *preferred_align = TDM_FRONT_VALUE(private_output->caps.cursor_preferred_align);
+ private_display->current_module = current_module;
_pthread_mutex_unlock(&private_display->lock);
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_physical_size(tdm_output *output, unsigned int *mmWidth,
- unsigned int *mmHeight)
-{
- OUTPUT_FUNC_ENTRY();
-
- _pthread_mutex_lock(&private_display->lock);
-
- if (mmWidth)
- *mmWidth = private_output->caps.mmWidth;
- if (mmHeight)
- *mmHeight = private_output->caps.mmHeight;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_subpixel(tdm_output *output, unsigned int *subpixel)
-{
- OUTPUT_FUNC_ENTRY();
- TDM_RETURN_VAL_IF_FAIL(subpixel != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- *subpixel = private_output->caps.subpixel;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_pipe(tdm_output *output, unsigned int *pipe)
-{
- OUTPUT_FUNC_ENTRY();
- TDM_RETURN_VAL_IF_FAIL(pipe != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- *pipe = private_output->pipe;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_primary_index(tdm_output *output, int *index)
-{
- tdm_private_layer *private_layer = NULL;
-
- OUTPUT_FUNC_ENTRY();
- TDM_RETURN_VAL_IF_FAIL(index != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
- if (private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_PRIMARY) {
- *index = private_layer->index;
- break;
- }
- }
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
-{
- tdm_func_output *func_output;
- OUTPUT_FUNC_ENTRY();
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_output = &private_display->func_output;
-
- if (!func_output->output_set_property) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_output->output_set_property(private_output->output_backend, id,
- value);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
-{
- tdm_func_output *func_output;
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_output = &private_display->func_output;
-
- if (!func_output->output_get_property) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_output->output_get_property(private_output->output_backend, id,
- value);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-INTERN void
-tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
- unsigned int tv_sec, unsigned int tv_usec, void *user_data)
-{
- tdm_private_vblank_handler *vblank_handler = user_data;
- tdm_private_display *private_display;
-
- TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
- TDM_RETURN_IF_FAIL(vblank_handler);
-
- private_display = vblank_handler->private_output->private_display;
-
- if (vblank_handler->owner_tid != syscall(SYS_gettid)) {
- tdm_thread_cb_output_vblank output_vblank;
- tdm_error ret;
-
- output_vblank.base.type = TDM_THREAD_CB_OUTPUT_VBLANK;
- output_vblank.base.length = sizeof output_vblank;
- output_vblank.output_stamp = vblank_handler->private_output->stamp;
- output_vblank.sequence = sequence;
- output_vblank.tv_sec = tv_sec;
- output_vblank.tv_usec = tv_usec;
- output_vblank.user_data = user_data;
-
- ret = tdm_thread_send_cb(private_display->private_loop, &output_vblank.base);
- TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
- return;
- }
-
- if (vblank_handler->owner_tid != syscall(SYS_gettid))
- TDM_NEVER_GET_HERE();
-
- if (vblank_handler->func) {
- _pthread_mutex_unlock(&private_display->lock);
- vblank_handler->func(vblank_handler->private_output, sequence,
- tv_sec, tv_usec, vblank_handler->user_data);
- _pthread_mutex_lock(&private_display->lock);
- }
-
- LIST_DEL(&vblank_handler->link);
- free(vblank_handler);
-}
-
-INTERN void
-tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
- unsigned int tv_sec, unsigned int tv_usec, void *user_data)
-{
- tdm_private_commit_handler *commit_handler = user_data;
- tdm_private_display *private_display;
- tdm_private_output *private_output;
- tdm_private_layer *private_layer = NULL;
-
- TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
- TDM_RETURN_IF_FAIL(commit_handler);
-
- private_output = commit_handler->private_output;
- private_display = private_output->private_display;
-
- if (commit_handler->owner_tid != syscall(SYS_gettid)) {
- tdm_thread_cb_output_commit output_commit;
- tdm_error ret;
-
- output_commit.base.type = TDM_THREAD_CB_OUTPUT_COMMIT;
- output_commit.base.length = sizeof output_commit;
- output_commit.output_stamp = private_output->stamp;
- output_commit.sequence = sequence;
- output_commit.tv_sec = tv_sec;
- output_commit.tv_usec = tv_usec;
- output_commit.user_data = user_data;
-
- ret = tdm_thread_send_cb(private_display->private_loop, &output_commit.base);
- TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
- return;
- }
-
- LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
- if (!private_layer->waiting_buffer)
- continue;
-
- if (private_layer->showing_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- tdm_buffer_unref_backend(private_layer->showing_buffer);
- _pthread_mutex_lock(&private_display->lock);
-
- if (private_layer->buffer_queue) {
- _pthread_mutex_unlock(&private_display->lock);
- tbm_surface_queue_release(private_layer->buffer_queue,
- private_layer->showing_buffer);
- _pthread_mutex_lock(&private_display->lock);
- }
- }
-
- private_layer->showing_buffer = private_layer->waiting_buffer;
- private_layer->waiting_buffer = NULL;
-
- if (tdm_debug_module & TDM_DEBUG_BUFFER)
- TDM_INFO("layer(%p) waiting_buffer(%p) showing_buffer(%p)",
- private_layer, private_layer->waiting_buffer,
- private_layer->showing_buffer);
- }
-
- if (commit_handler->func) {
- _pthread_mutex_unlock(&private_display->lock);
- commit_handler->func(private_output, sequence,
- tv_sec, tv_usec, commit_handler->user_data);
- _pthread_mutex_lock(&private_display->lock);
- }
-
- LIST_DEL(&commit_handler->link);
- free(commit_handler);
-}
-
-EXTERN tdm_error
-tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
- tdm_output_vblank_handler func, void *user_data)
-{
- tdm_func_output *func_output;
- tdm_private_vblank_handler *vblank_handler;
- OUTPUT_FUNC_ENTRY();
-
- _pthread_mutex_lock(&private_display->lock);
-
- if (private_output->current_dpms_value > TDM_OUTPUT_DPMS_ON) {
- TDM_WRN("output(%d) dpms: %s", private_output->pipe,
- tdm_dpms_str(private_output->current_dpms_value));
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_DPMS_OFF;
- }
-
- func_output = &private_display->func_output;
-
- if (!func_output->output_wait_vblank) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler));
- if (!vblank_handler) {
- TDM_ERR("failed: alloc memory");
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_OUT_OF_MEMORY;
- }
-
- LIST_ADD(&vblank_handler->link, &private_output->vblank_handler_list);
- vblank_handler->private_output = private_output;
- vblank_handler->func = func;
- vblank_handler->user_data = user_data;
- vblank_handler->owner_tid = syscall(SYS_gettid);
-
- ret = func_output->output_wait_vblank(private_output->output_backend, interval,
- sync, vblank_handler);
- if (ret != TDM_ERROR_NONE) {
- _pthread_mutex_unlock(&private_display->lock);
- return ret;
- }
-
- if (!private_output->regist_vblank_cb) {
- private_output->regist_vblank_cb = 1;
- ret = func_output->output_set_vblank_handler(private_output->output_backend,
- tdm_output_cb_vblank);
- }
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-static tdm_error
-_tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
- void *user_data)
-{
- tdm_func_output *func_output;
- tdm_private_commit_handler *commit_handler;
- OUTPUT_FUNC_ENTRY();
-
- func_output = &private_display->func_output;
-
- if (!func_output->output_commit) {
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- commit_handler = calloc(1, sizeof(tdm_private_commit_handler));
- if (!commit_handler) {
- TDM_ERR("failed: alloc memory");
- return TDM_ERROR_OUT_OF_MEMORY;
- }
-
- LIST_ADD(&commit_handler->link, &private_output->commit_handler_list);
- commit_handler->private_output = private_output;
- commit_handler->func = func;
- commit_handler->user_data = user_data;
- commit_handler->owner_tid = syscall(SYS_gettid);
-
- if (!private_output->regist_commit_cb) {
- private_output->regist_commit_cb = 1;
- ret = func_output->output_set_commit_handler(private_output->output_backend,
- tdm_output_cb_commit);
- }
-
- ret = func_output->output_commit(private_output->output_backend, sync,
- commit_handler);
- TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
- void *user_data)
-{
- OUTPUT_FUNC_ENTRY();
-
- _pthread_mutex_lock(&private_display->lock);
-
- if (private_output->current_dpms_value > TDM_OUTPUT_DPMS_ON) {
- TDM_ERR("output(%d) dpms: %s", private_output->pipe,
- tdm_dpms_str(private_output->current_dpms_value));
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_DPMS_OFF;
- }
-
- ret = _tdm_output_commit(output, sync, func, user_data);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
-{
- tdm_func_output *func_output;
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_output = &private_display->func_output;
-
- if (!func_output->output_set_mode) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_output->output_set_mode(private_output->output_backend, mode);
- if (ret == TDM_ERROR_NONE)
- private_output->current_mode = mode;
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
-{
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- *mode = private_output->current_mode;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-static tdm_error
-_tdm_output_dpms_changed_timeout(void *user_data)
-{
- tdm_private_output *private_output = user_data;
- tdm_value value;
-
- value.u32 = private_output->current_dpms_value;
- tdm_output_call_change_handler_internal(private_output,
- &private_output->change_handler_list_sub,
- TDM_OUTPUT_CHANGE_DPMS,
- value, 0);
-
- return TDM_ERROR_NONE;
-}
-
-INTERN void
-tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_data)
-{
- tdm_private_display *private_display;
- tdm_private_output *private_output = user_data;
- tdm_value value;
-
- TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
- TDM_RETURN_IF_FAIL(private_output);
-
- private_display = private_output->private_display;
-
- if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
- tdm_thread_cb_output_dpms output_dpms;
- tdm_error ret;
-
- _tdm_output_update(output_backend, user_data);
-
- output_dpms.base.type = TDM_THREAD_CB_OUTPUT_DPMS;
- output_dpms.base.length = sizeof output_dpms;
- output_dpms.output_stamp = private_output->stamp;
- output_dpms.dpms = dpms;
- output_dpms.user_data = user_data;
-
- value.u32 = dpms;
- tdm_output_call_change_handler_internal(private_output,
- &private_output->change_handler_list_sub,
- TDM_OUTPUT_CHANGE_DPMS,
- value, 0);
-
- ret = tdm_thread_send_cb(private_display->private_loop, &output_dpms.base);
- TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
- return;
- }
-
- private_output->current_dpms_value = dpms;
-
- value.u32 = dpms;
- tdm_output_call_change_handler_internal(private_output,
- &private_output->change_handler_list_main,
- TDM_OUTPUT_CHANGE_DPMS,
- value, 0);
-}
-
-EXTERN tdm_error
-tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
-{
- tdm_func_output *func_output;
- OUTPUT_FUNC_ENTRY();
-
- if (dpms_value > TDM_OUTPUT_DPMS_OFF)
- dpms_value = TDM_OUTPUT_DPMS_OFF;
-
- _pthread_mutex_lock(&private_display->lock);
-
- if (private_output->current_dpms_value == dpms_value) {
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
-
- /** Use timer to call the output change callback of the sub-thread.
- * The output change callback of tdm_server and tdm_vblank was called
- * in the main thread. And it made the multi thread issue. If we use
- * the timer, we can call the sub-thread's output change callback in
- * sub-thread.
- */
- if (!private_output->dpms_changed_timer) {
- private_output->dpms_changed_timer =
- tdm_event_loop_add_timer_handler(private_output->private_display,
- _tdm_output_dpms_changed_timeout, private_output, NULL);
- if (!private_output->dpms_changed_timer) {
- TDM_ERR("can't create dpms timer!!");
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_OUT_OF_MEMORY;
- }
- }
-
- func_output = &private_display->func_output;
-
- if (!func_output->output_set_dpms) {
- _pthread_mutex_unlock(&private_display->lock);
- private_output->current_dpms_value = dpms_value;
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NONE;
- }
-
- if (func_output->output_set_dpms_handler) {
- if (!private_output->regist_dpms_cb) {
- private_output->regist_dpms_cb = 1;
- ret = func_output->output_set_dpms_handler(private_output->output_backend,
- tdm_output_cb_dpms, private_output);
- }
- }
-
- ret = func_output->output_set_dpms(private_output->output_backend, dpms_value);
-
- if (ret == TDM_ERROR_NONE && !func_output->output_set_dpms_handler) {
- tdm_value value;
-
- private_output->current_dpms_value = dpms_value;
-
- value.u32 = dpms_value;
- tdm_output_call_change_handler_internal(private_output,
- &private_output->change_handler_list_main,
- TDM_OUTPUT_CHANGE_DPMS,
- value, 0);
-
- if (!LIST_IS_EMPTY(&private_output->change_handler_list_sub)) {
- ret = tdm_event_loop_source_timer_update(private_output->dpms_changed_timer, 1);
- if (ret != TDM_ERROR_NONE)
- TDM_NEVER_GET_HERE();
- }
- }
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
-{
- tdm_func_output *func_output;
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(dpms_value != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_output = &private_display->func_output;
-
- if (!func_output->output_get_dpms) {
- *dpms_value = private_output->current_dpms_value;
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NONE;
- }
-
- ret = func_output->output_get_dpms(private_output->output_backend, dpms_value);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_capture *
-tdm_output_create_capture(tdm_output *output, tdm_error *error)
-{
- tdm_capture *capture = NULL;
-
- OUTPUT_FUNC_ENTRY_ERROR();
-
- _pthread_mutex_lock(&private_display->lock);
-
- capture = (tdm_capture *)tdm_capture_create_output_internal(private_output, error);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return capture;
-}
-
-INTERN void
-tdm_output_call_change_handler_internal(tdm_private_output *private_output,
- struct list_head *change_handler_list,
- tdm_output_change_type type,
- tdm_value value,
- int no_check_thread_id)
-{
- tdm_private_display *private_display;
- tdm_private_change_handler *change_handler = NULL;
-
- TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
- TDM_RETURN_IF_FAIL(private_output);
-
- private_display = private_output->private_display;
- if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
- if (type & TDM_OUTPUT_CHANGE_CONNECTION)
- TDM_INFO("output(%d) changed: %s (%d)",
- private_output->pipe, tdm_status_str(value.u32), value.u32);
- if (type & TDM_OUTPUT_CHANGE_DPMS)
- TDM_INFO("output(%d) changed: dpms %s (%d)",
- private_output->pipe, tdm_dpms_str(value.u32), value.u32);
- }
-
- if (LIST_IS_EMPTY(change_handler_list))
- return;
-
- LIST_FOR_EACH_ENTRY(change_handler, change_handler_list, link) {
- if (!no_check_thread_id && change_handler->owner_tid != syscall(SYS_gettid))
- TDM_NEVER_GET_HERE();
-
- _pthread_mutex_unlock(&private_display->lock);
- change_handler->func(private_output, type,
- value, change_handler->user_data);
- _pthread_mutex_lock(&private_display->lock);
- }
-}
-
-EXTERN tdm_error
-tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
-{
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- *capabilities = private_layer->caps.capabilities;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_get_available_formats(tdm_layer *layer, const tbm_format **formats, int *count)
-{
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
- TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- *formats = (const tbm_format *)private_layer->caps.formats;
- *count = private_layer->caps.format_count;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props, int *count)
-{
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
- TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- *props = (const tdm_prop *)private_layer->caps.props;
- *count = private_layer->caps.prop_count;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_get_zpos(tdm_layer *layer, int *zpos)
-{
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(zpos != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- *zpos = private_layer->caps.zpos;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
-{
- tdm_func_layer *func_layer;
- LAYER_FUNC_ENTRY();
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_layer = &private_display->func_layer;
-
- if (private_layer->usable)
- TDM_INFO("layer(%p) not usable", private_layer);
-
- private_layer->usable = 0;
-
- if (!func_layer->layer_set_property) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_layer->layer_set_property(private_layer->layer_backend, id, value);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
-{
- tdm_func_layer *func_layer;
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_layer = &private_display->func_layer;
-
- if (!func_layer->layer_get_property) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_layer->layer_get_property(private_layer->layer_backend, id, value);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
-{
- tdm_func_layer *func_layer;
- char fmtstr[128];
-
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_layer = &private_display->func_layer;
-
- if (private_layer->usable)
- TDM_INFO("layer(%p) not usable", private_layer);
-
- private_layer->usable = 0;
-
- if (!func_layer->layer_set_info) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- if (info->src_config.format)
- snprintf(fmtstr, 128, "%c%c%c%c", FOURCC_STR(info->src_config.format));
- else
- snprintf(fmtstr, 128, "NONE");
-
- TDM_INFO("layer(%p) info: src(%dx%d %d,%d %dx%d %s) dst(%d,%d %dx%d) trans(%d)",
- private_layer, info->src_config.size.h, info->src_config.size.v,
- info->src_config.pos.x, info->src_config.pos.y,
- info->src_config.pos.w, info->src_config.pos.h,
- fmtstr,
- info->dst_pos.x, info->dst_pos.y,
- info->dst_pos.w, info->dst_pos.h,
- info->transform);
-
- ret = func_layer->layer_set_info(private_layer->layer_backend, info);
- TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
-{
- tdm_func_layer *func_layer;
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_layer = &private_display->func_layer;
-
- if (!func_layer->layer_get_info) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_layer->layer_get_info(private_layer->layer_backend, info);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-static void
-_tdm_layer_dump_buffer(tdm_layer *layer, tbm_surface_h buffer)
-{
- tdm_private_layer *private_layer = (tdm_private_layer*)layer;
- tdm_private_output *private_output = private_layer->private_output;
- unsigned int pipe;
- int zpos;
- char fname[PATH_MAX];
-
- pipe = private_output->pipe;
- zpos = private_layer->caps.zpos;
-
- snprintf(fname, sizeof(fname), "tdm_%d_lyr_%d", pipe, zpos);
-
- tbm_surface_internal_dump_buffer(buffer, fname);
- TDM_DBG("%s dump excute", fname);
-
- return;
-}
-
-EXTERN tdm_error
-tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
-{
- tdm_func_layer *func_layer;
-
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- if (tdm_debug_dump & TDM_DUMP_FLAG_LAYER &&
- !(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) {
- char str[TDM_PATH_LEN];
- static int i;
- snprintf(str, TDM_PATH_LEN, "layer_%d_%d_%03d",
- private_output->index, private_layer->index, i++);
- tdm_helper_dump_buffer_str(buffer, tdm_debug_dump_dir, str);
- }
-
- func_layer = &private_display->func_layer;
-
- if (private_layer->usable)
- TDM_INFO("layer(%p) not usable", private_layer);
-
- private_layer->usable = 0;
-
- if (!func_layer->layer_set_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_layer->layer_set_buffer(private_layer->layer_backend, buffer);
- TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
- /* dump buffer */
- if (tdm_dump_enable && !(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO))
- _tdm_layer_dump_buffer(layer, buffer);
-
- if (ret == TDM_ERROR_NONE) {
- /* FIXME: should save to pending_buffer first. And after committing
- * successfully, need to move to waiting_buffer.
- */
- if (private_layer->waiting_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- tdm_buffer_unref_backend(private_layer->waiting_buffer);
- _pthread_mutex_lock(&private_display->lock);
- }
-
- private_layer->waiting_buffer = tdm_buffer_ref_backend(buffer);
- if (tdm_debug_module & TDM_DEBUG_BUFFER)
- TDM_INFO("layer(%p) waiting_buffer(%p)",
- private_layer, private_layer->waiting_buffer);
- }
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_unset_buffer(tdm_layer *layer)
-{
- tdm_func_layer *func_layer;
- LAYER_FUNC_ENTRY();
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_layer = &private_display->func_layer;
-
- if (private_layer->waiting_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- tdm_buffer_unref_backend(private_layer->waiting_buffer);
- _pthread_mutex_lock(&private_display->lock);
- private_layer->waiting_buffer = NULL;
-
- if (tdm_debug_module & TDM_DEBUG_BUFFER)
- TDM_INFO("layer(%p) waiting_buffer(%p)",
- private_layer, private_layer->waiting_buffer);
- }
-
- if (private_layer->showing_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- tdm_buffer_unref_backend(private_layer->showing_buffer);
- _pthread_mutex_lock(&private_display->lock);
- private_layer->showing_buffer = NULL;
-
- if (tdm_debug_module & TDM_DEBUG_BUFFER)
- TDM_INFO("layer(%p) showing_buffer(%p)",
- private_layer, private_layer->showing_buffer);
- }
-
- private_layer->usable = 1;
-
- if (private_layer->usable)
- TDM_INFO("layer(%p) now usable", private_layer);
-
- if (!func_layer->layer_unset_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
- TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tbm_surface_h
-tdm_layer_get_displaying_buffer(tdm_layer *layer, tdm_error *error)
-{
- tbm_surface_h buffer;
- LAYER_FUNC_ENTRY_ERROR();
-
- _pthread_mutex_lock(&private_display->lock);
-
- if (error)
- *error = TDM_ERROR_NONE;
-
- if (private_layer->showing_buffer) {
- buffer = private_layer->showing_buffer;
- } else {
- if (error)
- *error = TDM_ERROR_OPERATION_FAILED;
- _pthread_mutex_unlock(&private_display->lock);
- TDM_DBG("layer(%p) showing_buffer is null", private_layer);
- return NULL;
- }
- _pthread_mutex_unlock(&private_display->lock);
-
- return buffer;
-}
-
-static void
-_tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
-{
- TDM_RETURN_IF_FAIL(data != NULL);
- tdm_layer *layer = data;
- tdm_func_layer *func_layer;
- tbm_surface_h surface = NULL;
- LAYER_FUNC_ENTRY_VOID_RETURN();
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_layer = &private_display->func_layer;
- if (!func_layer->layer_set_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- return;
- }
-
- if (TBM_SURFACE_QUEUE_ERROR_NONE != tbm_surface_queue_acquire(private_layer->buffer_queue, &surface) ||
- surface == NULL) {
- TDM_ERR("layer(%p) tbm_surface_queue_acquire() failed surface:%p",
- private_layer, surface);
- _pthread_mutex_unlock(&private_display->lock);
- return;
- }
-
- ret = func_layer->layer_set_buffer(private_layer->layer_backend, surface);
- TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
- if (ret == TDM_ERROR_NONE) {
- if (private_layer->waiting_buffer) {
- TDM_DBG("layer(%p) drop waiting_buffer(%p)", private_layer, private_layer->waiting_buffer);
- _pthread_mutex_unlock(&private_display->lock);
- tdm_buffer_unref_backend(private_layer->waiting_buffer);
- tbm_surface_queue_release(private_layer->buffer_queue,
- private_layer->waiting_buffer);
- _pthread_mutex_lock(&private_display->lock);
- }
-
- private_layer->waiting_buffer = tdm_buffer_ref_backend(surface);
-
- if (tdm_debug_module & TDM_DEBUG_BUFFER)
- TDM_INFO("layer(%p) waiting_buffer(%p)",
- private_layer, private_layer->waiting_buffer);
-
- ret = _tdm_output_commit(private_layer->private_output, 0, NULL, NULL);
- if (ret != TDM_ERROR_NONE)
- TDM_ERR("layer(%p) _tdm_output_commit() is fail", private_layer);
- }
-
- _pthread_mutex_unlock(&private_display->lock);
-}
-
-static void
-_tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data)
-{
- TDM_RETURN_IF_FAIL(data != NULL);
- tdm_layer *layer = data;
- LAYER_FUNC_ENTRY_VOID_RETURN();
- TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
-
- _pthread_mutex_lock(&private_display->lock);
-
- if (private_layer->waiting_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- tdm_buffer_unref_backend(private_layer->waiting_buffer);
- tbm_surface_queue_release(private_layer->buffer_queue,
- private_layer->waiting_buffer);
- _pthread_mutex_lock(&private_display->lock);
- }
-
- private_layer->buffer_queue = NULL;
-
- _pthread_mutex_unlock(&private_display->lock);
-}
-
-EXTERN tdm_error
-tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
-{
- tdm_func_layer *func_layer;
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(buffer_queue != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_layer = &private_display->func_layer;
-
- if (private_layer->usable)
- TDM_INFO("layer(%p) not usable", private_layer);
-
- private_layer->usable = 0;
-
- if (!func_layer->layer_set_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- if (buffer_queue == private_layer->buffer_queue) {
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
-
- if (private_layer->waiting_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- tdm_buffer_unref_backend(private_layer->waiting_buffer);
- tbm_surface_queue_release(private_layer->buffer_queue,
- private_layer->waiting_buffer);
- private_layer->waiting_buffer = NULL;
- _pthread_mutex_lock(&private_display->lock);
-
- if (tdm_debug_module & TDM_DEBUG_BUFFER)
- TDM_INFO("layer(%p) waiting_buffer(%p)",
- private_layer, private_layer->waiting_buffer);
- }
-
- private_layer->buffer_queue = buffer_queue;
- tbm_surface_queue_add_acquirable_cb(private_layer->buffer_queue,
- _tbm_layer_queue_acquirable_cb,
- layer);
- tbm_surface_queue_add_destroy_cb(private_layer->buffer_queue,
- _tbm_layer_queue_destroy_cb,
- layer);
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_unset_buffer_queue(tdm_layer *layer)
-{
- tdm_func_layer *func_layer;
- LAYER_FUNC_ENTRY();
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_layer = &private_display->func_layer;
-
- if (private_layer->waiting_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- tdm_buffer_unref_backend(private_layer->waiting_buffer);
- tbm_surface_queue_release(private_layer->buffer_queue,
- private_layer->waiting_buffer);
- private_layer->waiting_buffer = NULL;
- _pthread_mutex_lock(&private_display->lock);
-
- if (tdm_debug_module & TDM_DEBUG_BUFFER)
- TDM_INFO("layer(%p) waiting_buffer(%p)",
- private_layer, private_layer->waiting_buffer);
- }
-
- if (private_layer->showing_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- tdm_buffer_unref_backend(private_layer->showing_buffer);
- tbm_surface_queue_release(private_layer->buffer_queue,
- private_layer->showing_buffer);
- _pthread_mutex_lock(&private_display->lock);
- private_layer->showing_buffer = NULL;
-
- if (tdm_debug_module & TDM_DEBUG_BUFFER)
- TDM_INFO("layer(%p) showing_buffer(%p)",
- private_layer, private_layer->showing_buffer);
- }
-
- tbm_surface_queue_remove_acquirable_cb(private_layer->buffer_queue, _tbm_layer_queue_acquirable_cb, layer);
- tbm_surface_queue_remove_destroy_cb(private_layer->buffer_queue, _tbm_layer_queue_destroy_cb, layer);
- private_layer->buffer_queue = NULL;
- private_layer->usable = 1;
-
- if (private_layer->usable)
- TDM_INFO("layer(%p) now usable", private_layer);
-
- if (!func_layer->layer_unset_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
-{
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(usable != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- _pthread_mutex_lock(&private_display->lock);
-
- *usable = private_layer->usable;
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
-{
- tdm_func_layer *func_layer;
- LAYER_FUNC_ENTRY();
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_layer = &private_display->func_layer;
-
- if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) {
- TDM_ERR("layer(%p) is not video layer", private_layer);
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_INVALID_PARAMETER;
- }
-
- if (!func_layer->layer_set_video_pos) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_layer->layer_set_video_pos(private_layer->layer_backend, zpos);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_capture *
-tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
-{
- tdm_capture *capture = NULL;
-
- LAYER_FUNC_ENTRY_ERROR();
-
- _pthread_mutex_lock(&private_display->lock);
-
- capture = (tdm_capture *)tdm_capture_create_layer_internal(private_layer, error);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return capture;
-}
-
-EXTERN tdm_error
-tdm_layer_get_buffer_flags(tdm_layer *layer, unsigned int *flags)
-{
- tdm_func_layer *func_layer;
- LAYER_FUNC_ENTRY();
-
- _pthread_mutex_lock(&private_display->lock);
-
- func_layer = &private_display->func_layer;
-
- if (!func_layer->layer_get_buffer_flags) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_layer->layer_get_buffer_flags(private_layer->layer_backend, flags);
-
- _pthread_mutex_unlock(&private_display->lock);
-
- return ret;
+ return private_voutput;
}
projects / platform / core / uifw / libtdm.git / blobdiff