#include "config.h"
#endif
-#include "tdm.h"
-#include "tdm_backend.h"
#include "tdm_private.h"
-#include "tdm_helper.h"
#define COUNT_MAX 10
tdm_private_display *private_display; \
tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER); \
+ TDM_RETURN_VAL_IF_FAIL(tdm_display_is_valid(dpy), TDM_ERROR_INVALID_PARAMETER); \
private_display = (tdm_private_display*)dpy;
#define DISPLAY_FUNC_ENTRY_ERROR() \
tdm_private_display *private_display; \
tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
+ TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(tdm_display_is_valid(dpy), TDM_ERROR_INVALID_PARAMETER, NULL); \
private_display = (tdm_private_display*)dpy;
+#define BACKEND_FUNC_ENTRY() \
+ tdm_private_module *private_module; \
+ tdm_private_display *private_display; \
+ tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
+ TDM_RETURN_VAL_IF_FAIL(module != NULL, TDM_ERROR_INVALID_PARAMETER); \
+ private_module = (tdm_private_module*)module; \
+ private_display = private_module->private_display;
+
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);
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);
+ TDM_DEPRECATED(NULL);
- *max_count = TDM_FRONT_VALUE(private_display->caps_display.max_layer_count);
+ *max_count = -1;
- _pthread_mutex_unlock(&private_display->lock);
-
- 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();
+
+ _pthread_mutex_lock(&private_display->lock);
+
+ if (error)
+ *error = 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) {
+ if (private_output->index == index) {
+ _pthread_mutex_unlock(&private_display->lock);
+ return private_output;
+ }
+ }
+ }
+
+ _pthread_mutex_unlock(&private_display->lock);
+
+ return NULL;
+}
+
+EXTERN tdm_output *
+tdm_display_find_output(tdm_display *dpy, const char *name, tdm_error *error)
+{
+ tdm_private_module *private_module = NULL;
tdm_private_output *private_output = NULL;
DISPLAY_FUNC_ENTRY_ERROR();
+ if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7)) {
+ return tdm_display_get_output(dpy, 0, error);
+ }
+
_pthread_mutex_lock(&private_display->lock);
if (error)
*error = TDM_ERROR_NONE;
- LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) {
- if (private_output->index == index) {
+ 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;
}
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);
+
+ /* 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;
+ 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;
+}
+
+EXTERN tdm_error
+tdm_module_get_info(tdm_module *module, const char **name,
+ const char **vendor, int *major, int *minor)
+{
+ tdm_backend_module *module_data;
+
+ BACKEND_FUNC_ENTRY();
+
_pthread_mutex_lock(&private_display->lock);
- module_data = private_display->module_data;
+ module_data = private_module->module_data;
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);
projects / platform / core / uifw / libtdm.git / blobdiff