* 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
#define CAPTURE_FUNC_ENTRY() \
tdm_func_capture *func_capture; \
tdm_private_display *private_display; \
+ tdm_private_module *private_module; \
tdm_private_capture *private_capture; \
tdm_error ret = TDM_ERROR_NONE; \
TDM_RETURN_VAL_IF_FAIL(capture != NULL, TDM_ERROR_INVALID_PARAMETER); \
private_capture = (tdm_private_capture*)capture; \
private_display = private_capture->private_display; \
- func_capture = &private_display->func_capture
+ private_module = private_capture->private_module; \
+ func_capture = &private_module->func_capture
static void
_tdm_capture_print_list(struct list_head *list)
TDM_RETURN_IF_FAIL(list != NULL);
+ str[0] = '\0';
p = str;
LIST_FOR_EACH_ENTRY(b, list, link) {
if (len > 0) {
- int l = snprintf(p, len, " (%p)", b->buffer);
+ tbm_bo bo = tbm_surface_internal_get_bo(b->buffer, 0);
+ int flags = tbm_bo_get_flags(bo);
+ int l = snprintf(p, len, " (%p[bo_flags:%x])", b->buffer, flags);
p += l;
len -= l;
} else
first_entry = container_of((&private_capture->buffer_list)->next, capture_buffer, link);
if (first_entry->buffer != buffer)
TDM_ERR("buffer(%p) is skipped", first_entry->buffer);
- } else {
- TDM_NEVER_GET_HERE();
}
if ((capture_buffer = _tdm_capture_find_tbm_buffer(&private_capture->buffer_list, buffer))) {
}
static void
-_tdm_capture_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer, void *user_data)
+_tdm_capture_cb_done(tdm_capture *capture_module, tbm_surface_h buffer, void *user_data)
{
tdm_private_capture *private_capture = user_data;
tdm_thread_cb_capture_done capture_done;
capture_done.base.sync = 0;
capture_done.buffer = buffer;
- ret = tdm_thread_cb_call(private_capture, &capture_done.base);
+ ret = tdm_thread_cb_call(private_capture, &capture_done.base, 1);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
}
static void *
_tdm_capture_find_object(tdm_private_display *private_display, double stamp)
{
+ tdm_private_module *private_module = NULL;
tdm_private_capture *private_capture = NULL;
TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
- LIST_FOR_EACH_ENTRY(private_capture, &private_display->capture_list, display_link) {
- if (private_capture->stamp == stamp)
- return private_capture;
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ LIST_FOR_EACH_ENTRY(private_capture, &private_module->capture_list, display_link) {
+ if (private_capture->stamp == stamp)
+ return private_capture;
+ }
}
return NULL;
tdm_error *error)
{
tdm_private_display *private_display = private_output->private_display;
- tdm_func_output *func_output = &private_display->func_output;
- tdm_func_capture *func_capture = &private_display->func_capture;
+ tdm_private_module *private_module = private_output->private_module;
+ tdm_func_output *func_output = &private_module->func_output;
+ tdm_func_capture *func_capture = &private_module->func_capture;
tdm_private_capture *private_capture = NULL;
- tdm_capture *capture_backend = NULL;
+ tdm_capture *capture_module = NULL;
tdm_error ret = TDM_ERROR_NONE;
TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
- if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
+ if (!(private_module->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
/* LCOV_EXCL_START */
- TDM_ERR("no capture capability");
+ TDM_ERR("backend(%s) no capture capability", private_module->module_data->name);
if (error)
*error = TDM_ERROR_NO_CAPABILITY;
return NULL;
/* LCOV_EXCL_STOP */
}
- if (!(private_display->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT)) {
+ if (!(private_module->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT)) {
/* LCOV_EXCL_START */
- TDM_ERR("no output capture capability");
+ TDM_ERR("backend(%s) no output capture capability", private_module->module_data->name);
if (error)
*error = TDM_ERROR_NO_CAPABILITY;
return NULL;
/* LCOV_EXCL_STOP */
}
- capture_backend = func_output->output_create_capture(
+ capture_module = func_output->output_create_capture(
private_output->output_backend, &ret);
if (ret != TDM_ERROR_NONE) {
/* LCOV_EXCL_START */
if (!private_capture) {
/* LCOV_EXCL_START */
TDM_ERR("failed: alloc memory");
- func_capture->capture_destroy(capture_backend);
+ func_capture->capture_destroy(capture_module);
if (error)
*error = TDM_ERROR_OUT_OF_MEMORY;
return NULL;
ret = tdm_thread_cb_add(private_capture, TDM_THREAD_CB_CAPTURE_DONE, NULL, _tdm_capture_thread_cb_done, NULL);
if (ret != TDM_ERROR_NONE) {
TDM_ERR("capture tdm_thread_cb_add failed");
- func_capture->capture_destroy(capture_backend);
+ func_capture->capture_destroy(capture_module);
free(private_capture);
if (error)
*error = ret;
return NULL;
}
- ret = func_capture->capture_set_done_handler(capture_backend, _tdm_capture_cb_done, private_capture);
+ ret = func_capture->capture_set_done_handler(capture_module, _tdm_capture_cb_done, private_capture);
if (ret != TDM_ERROR_NONE) {
/* LCOV_EXCL_START */
TDM_ERR("capture(%p) set capture_done_handler failed", private_capture);
- func_capture->capture_destroy(capture_backend);
+ func_capture->capture_destroy(capture_module);
free(private_capture);
if (error)
*error = ret;
private_capture->stamp++;
LIST_ADD(&private_capture->link, &private_output->capture_list);
- LIST_ADD(&private_capture->display_link, &private_display->capture_list);
+ LIST_ADD(&private_capture->display_link, &private_module->capture_list);
+
+ private_capture->private_module = private_module;
private_capture->target = TDM_CAPTURE_TARGET_OUTPUT;
private_capture->private_display = private_display;
private_capture->private_output = private_output;
private_capture->private_layer = NULL;
- private_capture->capture_backend = capture_backend;
+ private_capture->capture_module = capture_module;
private_capture->owner_tid = syscall(SYS_gettid);
LIST_INITHEAD(&private_capture->pending_buffer_list);
tdm_error *error)
{
tdm_private_output *private_output = private_layer->private_output;
+ tdm_private_module *private_module = private_layer->private_module;
tdm_private_display *private_display = private_output->private_display;
- tdm_func_layer *func_layer = &private_display->func_layer;
- tdm_func_capture *func_capture = &private_display->func_capture;
+ tdm_func_layer *func_layer = &private_module->func_layer;
+ tdm_func_capture *func_capture = &private_module->func_capture;
tdm_private_capture *private_capture = NULL;
- tdm_capture *capture_backend = NULL;
+ tdm_capture *capture_module = NULL;
tdm_error ret = TDM_ERROR_NONE;
TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
- if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
- TDM_ERR("no capture capability");
+ if (!(private_module->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
+ TDM_ERR("backend(%s) no capture capability", private_module->module_data->name);
if (error)
*error = TDM_ERROR_NO_CAPABILITY;
return NULL;
}
- if (!(private_display->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_LAYER)) {
- TDM_ERR("no layer capture capability");
+ if (!(private_module->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_LAYER)) {
+ TDM_ERR("backend(%s) no layer capture capability", private_module->module_data->name);
if (error)
*error = TDM_ERROR_NO_CAPABILITY;
return NULL;
}
- capture_backend = func_layer->layer_create_capture(private_layer->layer_backend,
+ capture_module = func_layer->layer_create_capture(private_layer->layer_backend,
&ret);
if (ret != TDM_ERROR_NONE)
return NULL;
private_capture = calloc(1, sizeof(tdm_private_capture));
if (!private_capture) {
TDM_ERR("failed: alloc memory");
- func_capture->capture_destroy(capture_backend);
+ func_capture->capture_destroy(capture_module);
if (error)
*error = TDM_ERROR_OUT_OF_MEMORY;
return NULL;
private_capture->stamp++;
LIST_ADD(&private_capture->link, &private_layer->capture_list);
- LIST_ADD(&private_capture->display_link, &private_display->capture_list);
+ LIST_ADD(&private_capture->display_link, &private_module->capture_list);
+
+ private_capture->private_module = private_module;
private_capture->target = TDM_CAPTURE_TARGET_LAYER;
private_capture->private_display = private_display;
private_capture->private_output = private_output;
private_capture->private_layer = private_layer;
- private_capture->capture_backend = capture_backend;
+ private_capture->capture_module = capture_module;
private_capture->owner_tid = syscall(SYS_gettid);
LIST_INITHEAD(&private_capture->pending_buffer_list);
tdm_capture_destroy_internal(tdm_private_capture *private_capture)
{
tdm_private_display *private_display;
+ tdm_private_module *private_module;
tdm_func_capture *func_capture;
tdm_capture_private_buffer *b = NULL, *bb = NULL;
struct list_head clone_list;
LIST_DEL(&private_capture->link);
LIST_DEL(&private_capture->display_link);
- func_capture = &private_capture->private_display->func_capture;
- func_capture->capture_destroy(private_capture->capture_backend);
+ private_module = private_capture->private_module;
+ func_capture = &private_module->func_capture;
+ func_capture->capture_destroy(private_capture->capture_module);
if (!LIST_IS_EMPTY(&private_capture->pending_buffer_list)) {
TDM_WRN("capture(%p) not finished:", private_capture);
FOURCC_STR(info->dst_config.format),
info->transform, info->type, info->frequency, info->flags);
- ret = func_capture->capture_set_info(private_capture->capture_backend, info);
+ ret = func_capture->capture_set_info(private_capture->capture_module, info);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
private_capture->info = *info;
/* LCOV_EXCL_STOP */
}
- if (tdm_display_check_module_abi(private_display, 1, 2) &&
- private_display->caps_capture.max_attach_count > 0) {
+ if (tdm_module_check_abi(private_module, 1, 2) &&
+ private_module->caps_capture.max_attach_count > 0) {
/* LCOV_EXCL_START */
int length = LIST_LENGTH(&private_capture->pending_buffer_list) +
LIST_LENGTH(&private_capture->buffer_list);
- if (length >= private_display->caps_capture.max_attach_count) {
+ if (length >= private_module->caps_capture.max_attach_count) {
_pthread_mutex_unlock(&private_display->lock);
- TDM_DBG("failed: too many attached!! max_attach_count(%d)",
- private_display->caps_capture.max_attach_count);
+ TDM_DBG("failed: backend(%s) too many attached!! max_attach_count(%d)",
+ private_module->module_data->name, private_module->caps_capture.max_attach_count);
return TDM_ERROR_BAD_REQUEST;
}
/* LCOV_EXCL_STOP */
/* LCOV_EXCL_STOP */
}
- ret = func_capture->capture_attach(private_capture->capture_backend, buffer);
+ ret = func_capture->capture_attach(private_capture->capture_module, buffer);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
if (ret != TDM_ERROR_NONE) {
if (tdm_debug_module & TDM_DEBUG_BUFFER) {
TDM_INFO("capture(%p) attached:", private_capture);
+ _tdm_capture_print_list(&private_capture->pending_buffer_list);
_tdm_capture_print_list(&private_capture->buffer_list);
}
LIST_ADDTAIL(&b->commit_link, &commit_buffer_list);
}
- ret = func_capture->capture_commit(private_capture->capture_backend);
+ if (tdm_debug_module & TDM_DEBUG_BUFFER) {
+ TDM_INFO("capture(%p) committed:", private_capture);
+ _tdm_capture_print_list(&private_capture->pending_buffer_list);
+ _tdm_capture_print_list(&private_capture->buffer_list);
+ }
+
+ ret = func_capture->capture_commit(private_capture->capture_module);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
LIST_FOR_EACH_ENTRY_SAFE(b, bb, &commit_buffer_list, commit_link) {
if (ret != TDM_ERROR_NONE) {
/* LCOV_EXCL_START */
- /* Not to call the user release handler when failed.
- * Do we have to call this function here really?
- * User better use set_done_handler to know when pp is done. Using
- * buffer_release_handler is not good.
- */
- tdm_buffer_remove_release_handler_internal(b->buffer);
_pthread_mutex_unlock(&private_display->lock);
tdm_buffer_unref_backend(b->buffer);
projects / platform / core / uifw / libtdm.git / blobdiff