X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=src%2Ftdm_output.c;h=d6e1cc35e22be34bcc69e82b44c736c1e5249b62;hb=d077eef0042ab7dbc6857ce8e2ec367b3fe90b2e;hp=8354d070382a679e62c916ad66e6fadaffc8f751;hpb=ee203debcbb7e7e595c6da2663759a1bb1f429ed;p=platform%2Fcore%2Fuifw%2Flibtdm.git

diff --git a/src/tdm_output.c b/src/tdm_output.c
index 8354d07..d6e1cc3 100644
--- a/src/tdm_output.c
+++ b/src/tdm_output.c
@@ -429,11 +429,11 @@ tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_
 	tdm_private_output *private_output = user_data;
 	tdm_error ret;
 
-	TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str(dpms));
+	TDM_INFO("output(%d) %s", private_output->pipe, tdm_dpms_str(dpms));
 
 	private_output->current_dpms_value = dpms;
 	private_output->waiting_dpms_change = 0;
-	TDM_INFO("output(%d) dpms async '%s' done", private_output->pipe, tdm_dpms_str(dpms));
+	TDM_INFO("output(%d) DPMS async '%s' done", private_output->pipe, tdm_dpms_str(dpms));
 
 	ret = _tdm_output_call_thread_cb_dpms(private_output, dpms);
 	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
@@ -1630,8 +1630,11 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl
 
 	if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(dpms_value)) {
 		TDM_WRN("dpms %s. Directly call commit handler instead of commit.", tdm_dpms_str(dpms_value));
-		if (func)
+		if (func) {
+			_pthread_mutex_unlock(&private_display->lock);
 			func(output, 0, 0, 0, user_data);
+			_pthread_mutex_lock(&private_display->lock);
+		}
 	}
 
 	return ret;
@@ -1775,14 +1778,14 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
 	private_module = private_output->private_module;
 	func_output = &private_module->func_output;
 
-	TDM_INFO("output(%d) dpms '%s'", private_output->pipe, tdm_dpms_str(dpms_value));
+	TDM_INFO("output(%d) DPMS '%s'", private_output->pipe, tdm_dpms_str(dpms_value));
 
 	if (func_output->output_set_dpms)
 		ret = func_output->output_set_dpms(private_output->output_backend, dpms_value);
 	else {
 		/* LCOV_EXCL_START */
 		ret = TDM_ERROR_NONE;
-		TDM_WRN("not implemented!!");
+		TDM_WRN("DPMS not implemented!!");
 		goto done;
 		/* LCOV_EXCL_STOP */
 	}
@@ -1793,14 +1796,14 @@ done:
 			private_output->current_dpms_value = dpms_value;
 			_tdm_output_call_thread_cb_dpms(private_output, dpms_value);
 		}
-		TDM_INFO("output(%d) dpms '%s' done", private_output->pipe, tdm_dpms_str(dpms_value));
+		TDM_INFO("output(%d) DPMS '%s' done", private_output->pipe, tdm_dpms_str(dpms_value));
 	} else {
 		tdm_output_dpms temp = TDM_OUTPUT_DPMS_OFF;
 
 		/* update current_dpms_value forcely */
 		tdm_output_get_dpms_internal(output, &temp);
 
-		TDM_ERR("output(%d) set_dpms failed: dpms '%s'", private_output->pipe, tdm_dpms_str(temp));
+		TDM_ERR("output(%d) set DPMS failed: dpms '%s'", private_output->pipe, tdm_dpms_str(temp));
 	}
 
 	_pthread_mutex_unlock(&private_display->lock);
@@ -1814,6 +1817,7 @@ tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value)
 {
 	tdm_private_module *private_module;
 	tdm_func_output *func_output;
+	int sync = 0;
 	OUTPUT_FUNC_ENTRY();
 
 	if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_ASYNC_DPMS)) {
@@ -1845,13 +1849,13 @@ tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value)
 	private_module = private_output->private_module;
 	func_output = &private_module->func_output;
 	if (!func_output->output_set_dpms_handler) {
-		TDM_WRN("not implemented: output_set_dpms_handler");
+		TDM_WRN("not implemented DPMS: output_set_dpms_handler");
 		_pthread_mutex_unlock(&private_display->lock);
 		return TDM_ERROR_NOT_IMPLEMENTED;
 	}
 
 	if (!func_output->output_set_dpms_async) {
-		TDM_WRN("not implemented: output_set_dpms_async");
+		TDM_WRN("not implemented DPMS: output_set_dpms_async");
 		_pthread_mutex_unlock(&private_display->lock);
 		return TDM_ERROR_NOT_IMPLEMENTED;
 	}
@@ -1862,25 +1866,32 @@ tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value)
 				tdm_output_cb_dpms, private_output);
 		if (ret != TDM_ERROR_NONE) {
 			_pthread_mutex_unlock(&private_display->lock);
-			TDM_ERR("Can't set the dpms handler!!");
+			TDM_ERR("Can't set the DPMS handler!!");
 			return ret;
 		}
 	}
 
-	TDM_INFO("output(%d) dpms async '%s'", private_output->pipe, tdm_dpms_str(dpms_value));
+	TDM_INFO("output(%d) DPMS async '%s'", private_output->pipe, tdm_dpms_str(dpms_value));
 
-	ret = func_output->output_set_dpms_async(private_output->output_backend, dpms_value);
+	ret = func_output->output_set_dpms_async(private_output->output_backend, dpms_value, &sync);
 
 	if (ret == TDM_ERROR_NONE) {
-		private_output->waiting_dpms_change = 1;
-		TDM_INFO("output(%d) dpms async '%s' waiting", private_output->pipe, tdm_dpms_str(dpms_value));
+		if (sync) {
+			tdm_output_dpms temp = TDM_OUTPUT_DPMS_OFF;
+
+			tdm_output_get_dpms_internal(output, &temp);
+			TDM_INFO("output(%d) DPMS async '%s'(%s) done", private_output->pipe, tdm_dpms_str(dpms_value), tdm_dpms_str(temp));
+		} else {
+			private_output->waiting_dpms_change = 1;
+			TDM_INFO("output(%d) DPMS async '%s' waiting", private_output->pipe, tdm_dpms_str(dpms_value));
+		}
 	} else {
 		tdm_output_dpms temp = TDM_OUTPUT_DPMS_OFF;
 
 		/* update current_dpms_value forcely */
 		tdm_output_get_dpms_internal(output, &temp);
 
-		TDM_ERR("output(%d) set_dpms_async failed: dpms '%s'", private_output->pipe, tdm_dpms_str(temp));
+		TDM_ERR("output(%d) set DPMS async failed: dpms '%s'", private_output->pipe, tdm_dpms_str(temp));
 	}
 
 	_pthread_mutex_unlock(&private_display->lock);
@@ -1917,7 +1928,7 @@ tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value)
 	if (!func_output->output_get_dpms) {
 		/* LCOV_EXCL_START */
 		*dpms_value = private_output->current_dpms_value;
-		TDM_WRN("not implemented!!");
+		TDM_WRN("DPMS get not implemented!!");
 		return TDM_ERROR_NONE;
 		/* LCOV_EXCL_STOP */
 	}
@@ -1925,14 +1936,14 @@ tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value)
 	ret = func_output->output_get_dpms(private_output->output_backend, dpms_value);
 	if (ret != TDM_ERROR_NONE) {
 		/* LCOV_EXCL_START */
-		TDM_ERR("output_get_dpms failed");
+		TDM_ERR("output get DPMS failed");
 		*dpms_value = TDM_OUTPUT_DPMS_OFF;
 		/* LCOV_EXCL_STOP */
 	}
 
 	/* checking with backend's value */
 	if (*dpms_value != private_output->current_dpms_value) {
-		TDM_ERR("output(%d) dpms changed suddenly: %s -> %s",
+		TDM_ERR("output(%d) DPMS changed suddenly: %s -> %s",
 				private_output->pipe, tdm_dpms_str(private_output->current_dpms_value),
 				tdm_dpms_str(*dpms_value));
 		private_output->current_dpms_value = *dpms_value;
@@ -2024,141 +2035,109 @@ tdm_output_get_hwc(tdm_output *output, tdm_error *error)
 	return private_hwc;
 }
 
-INTERN tdm_error
-tdm_output_choose_commit_per_vblank_mode(tdm_private_output *private_output, int mode)
+EXTERN tdm_error
+tdm_output_set_mirror(tdm_output *output, tdm_output *src_output, tdm_transform transform)
 {
-	if (!private_output)
-		return TDM_ERROR_INVALID_PARAMETER;
+	/* LCOV_EXCL_START */
+	tdm_private_module *private_module;
+	tdm_func_output *func_output;
+	tdm_private_output *private_src_output;
 
-	if (mode < 0 || mode > 2)
-		return TDM_ERROR_INVALID_PARAMETER;
+	OUTPUT_FUNC_ENTRY();
 
-	private_output->commit_per_vblank = mode;
+	TDM_RETURN_VAL_IF_FAIL(src_output != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-	if (private_output->commit_per_vblank == 0)
-		TDM_INFO("commit per vblank: disable");
-	else if (private_output->commit_per_vblank == 1)
-		TDM_INFO("commit per vblank: enable (1 layer)");
-	else if (private_output->commit_per_vblank == 2)
-		TDM_INFO("commit per vblank: enable (previous commit)");
+	_pthread_mutex_lock(&private_display->lock);
 
-	return TDM_ERROR_NONE;
+	private_module = private_output->private_module;
+	func_output = &private_module->func_output;
+	private_src_output = (tdm_private_output*)src_output;
+
+	if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_MIRROR)) {
+		TDM_INFO("output(%d) doesn't support the mirror.", private_output->pipe);
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_BAD_REQUEST;
+	}
+
+	if (!func_output->output_set_mirror) {
+		TDM_WRN("not implemented!!");
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_NOT_IMPLEMENTED;
+	}
+
+	ret = func_output->output_set_mirror(private_output->output_backend,
+										private_src_output->output_backend,
+										transform);
+	if (ret != TDM_ERROR_NONE) {
+		TDM_ERR("output(%p) fails to set MIRROR.", private_output);
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_BAD_REQUEST;
+	}
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return ret;
+	/* LCOV_EXCL_STOP */
 }
 
-INTERN tdm_voutput *
-tdm_voutput_create(tdm_display *dpy, const char *name, tdm_error *error)
+tdm_error
+tdm_output_unset_mirror(tdm_output *output)
 {
-	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_error ret = TDM_ERROR_NONE;
+	/* LCOV_EXCL_START */
+	tdm_private_module *private_module;
+	tdm_func_output *func_output;
 
-	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);
+	OUTPUT_FUNC_ENTRY();
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	if (error) *error = TDM_ERROR_NONE;
+	private_module = private_output->private_module;
+	func_output = &private_module->func_output;
 
-	private_voutput = calloc(1, sizeof(tdm_private_voutput));
-	if (!private_voutput) {
-		if (error) *error = TDM_ERROR_OUT_OF_MEMORY;
+	if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_MIRROR)) {
+		TDM_INFO("output(%d) doesn't support the mirror.", private_output->pipe);
 		_pthread_mutex_unlock(&private_display->lock);
-		return NULL;
+		return TDM_ERROR_BAD_REQUEST;
 	}
 
-	func_display = &private_module->func_display;
-	func_voutput = &private_module->func_voutput;
-	current_module = private_display->current_module;
-	private_display->current_module = private_module;
-
-	voutput_backend = func_display->voutput_create(private_module->bdata, name, &ret);
-
-	if (voutput_backend == NULL || ret != TDM_ERROR_NONE) {
-		TDM_ERR("voutput_create fail");
-		free(private_voutput);
-		if (error) *error = ret;
-		private_display->current_module = current_module;
-		_pthread_mutex_unlock(&private_display->lock);
-		return NULL;
-	}
-	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;
+	if (!func_output->output_unset_mirror) {
+		TDM_WRN("not implemented!!");
 		_pthread_mutex_unlock(&private_display->lock);
-		return NULL;
+		return TDM_ERROR_NOT_IMPLEMENTED;
 	}
 
-	ret = tdm_display_update_output(private_display->current_module, output_backend);
+	ret = func_output->output_unset_mirror(private_output->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;
+		TDM_ERR("output(%p) fails to unset MIRROR.", private_output);
 		_pthread_mutex_unlock(&private_display->lock);
-		return NULL;
-	}
-
-	LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
-		if (private_output->output_backend == output_backend) {
-			output_find = 1;
-			break;
-		}
+		return TDM_ERROR_BAD_REQUEST;
 	}
 
-	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';
+	_pthread_mutex_unlock(&private_display->lock);
 
-		private_voutput->private_output = private_output;
-		private_output->private_voutput = private_voutput;
+	return ret;
+	/* LCOV_EXCL_STOP */
+}
 
-		/* do not use vblank */
-		tdm_output_choose_commit_per_vblank_mode(private_output, 0);
+INTERN tdm_error
+tdm_output_choose_commit_per_vblank_mode(tdm_private_output *private_output, int mode)
+{
+	if (!private_output)
+		return TDM_ERROR_INVALID_PARAMETER;
 
-		LIST_ADDTAIL(&private_voutput->link, &private_module->voutput_list);
-	}
+	if (mode < 0 || mode > 2)
+		return TDM_ERROR_INVALID_PARAMETER;
 
-	private_display->current_module = current_module;
+	private_output->commit_per_vblank = mode;
 
-	_pthread_mutex_unlock(&private_display->lock);
+	if (private_output->commit_per_vblank == 0)
+		TDM_INFO("commit per vblank: disable");
+	else if (private_output->commit_per_vblank == 1)
+		TDM_INFO("commit per vblank: enable (1 layer)");
+	else if (private_output->commit_per_vblank == 2)
+		TDM_INFO("commit per vblank: enable (previous commit)");
 
-	return private_voutput;
+	return TDM_ERROR_NONE;
 }
 
 INTERN tdm_error