X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftdm_display.c;h=ff605e27f4f753e8055bc7a54b5abfed39126c68;hb=a87e1609d7c2be6fafbfba39fd930adcc0d23491;hp=9cfd2901cdd47550aa6d953bffc3304cf1a65c8c;hpb=1c44c129755a129a45d4d59e54ac482a58d64f62;p=platform%2Fcore%2Fuifw%2Flibtdm.git diff --git a/src/tdm_display.c b/src/tdm_display.c index 9cfd290..ff605e2 100644 --- a/src/tdm_display.c +++ b/src/tdm_display.c @@ -37,10 +37,7 @@ #include "config.h" #endif -#include "tdm.h" -#include "tdm_backend.h" #include "tdm_private.h" -#include "tdm_helper.h" #define COUNT_MAX 10 @@ -48,71 +45,41 @@ 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 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 - -#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 - -#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 - -#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 - -#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 + 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); @@ -123,19 +90,25 @@ EXTERN tdm_error 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); @@ -146,6 +119,8 @@ EXTERN tdm_error 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); @@ -153,14 +128,18 @@ tdm_display_get_pp_available_formats(tdm_display *dpy, _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); @@ -171,26 +150,32 @@ EXTERN tdm_error 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); @@ -201,19 +186,25 @@ EXTERN tdm_error 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); @@ -221,9 +212,11 @@ tdm_display_get_capture_capabilities(tdm_display *dpy, } 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); @@ -231,14 +224,18 @@ tdm_display_get_catpure_available_formats(tdm_display *dpy, _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); @@ -249,26 +246,32 @@ EXTERN tdm_error 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); @@ -278,22 +281,20 @@ tdm_display_get_capture_available_size(tdm_display *dpy, int *min_w, int *min_h, 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(); @@ -303,12 +304,10 @@ tdm_display_get_output_count(tdm_display *dpy, int *count) _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); @@ -320,17 +319,51 @@ tdm_display_get_output_count(tdm_display *dpy, int *count) 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; } @@ -375,40 +408,68 @@ tdm_display_handle_events(tdm_display *dpy) 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; @@ -424,1606 +485,44 @@ tdm_display_get_backend_info(tdm_display *dpy, const char **name, return ret; } -EXTERN tdm_pp * -tdm_display_create_pp(tdm_display *dpy, tdm_error *error) -{ - tdm_pp *pp; - - DISPLAY_FUNC_ENTRY_ERROR(); - - _pthread_mutex_lock(&private_display->lock); - - pp = (tdm_pp *)tdm_pp_create_internal(private_display, error); - - _pthread_mutex_unlock(&private_display->lock); - - return pp; -} - -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) -{ - OUTPUT_FUNC_ENTRY(); - - TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER); - - _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); - - *status = private_output->caps.status; - - _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) -{ - 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; - } - - 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_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); - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -EXTERN void -tdm_output_remove_change_handler(tdm_output *output, - tdm_output_change_handler func, - void *user_data) -{ - 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); - - private_output = (tdm_private_output*)output; - private_display = private_output->private_display; - - _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); - - _pthread_mutex_unlock(&private_display->lock); - - return; - } - - LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_sub, link) { - if (h->func != func || h->user_data != user_data) - continue; - - LIST_DEL(&h->link); - free(h); - - _pthread_mutex_unlock(&private_display->lock); - - return; - } - - _pthread_mutex_unlock(&private_display->lock); -} - EXTERN tdm_error -tdm_output_get_output_type(tdm_output *output, tdm_output_type *type) +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(type != NULL, TDM_ERROR_INVALID_PARAMETER); + BACKEND_FUNC_ENTRY(); _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); + module_data = private_module->module_data; - *count = 0; - LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) - (*count)++; - if (*count == 0) { - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; - } + 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_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; - - 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; - } - } - - _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) +EXTERN tdm_pp * +tdm_display_create_pp(tdm_display *dpy, tdm_error *error) { - OUTPUT_FUNC_ENTRY(); + tdm_pp *pp; - TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER); - TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER); + DISPLAY_FUNC_ENTRY_ERROR(); _pthread_mutex_lock(&private_display->lock); - *props = (const tdm_prop *)private_output->caps.props; - *count = private_output->caps.prop_count; + pp = (tdm_pp *)tdm_pp_create_internal(private_display->pp_module, error); _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 (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; - - _pthread_mutex_unlock(&private_display->lock); - - return TDM_ERROR_BAD_MODULE; - } - - 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); - - _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 pp; }