X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftdm_output.c;h=07cfa4a5f1dfceef90c7094d3cb68821ece07f3c;hb=398989bae0addb8c17264d1bee02509fafcd101d;hp=43efed1b8021a08ad83757ef2b7f3fb6af5cc637;hpb=b28f4175918e663075033cc185959f69a710f7e0;p=platform%2Fcore%2Fuifw%2Flibtdm.git

diff --git a/src/tdm_output.c b/src/tdm_output.c
index 43efed1..07cfa4a 100644
--- a/src/tdm_output.c
+++ b/src/tdm_output.c
@@ -429,7 +429,7 @@ 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;
@@ -526,7 +526,7 @@ tdm_output_add_mode_change_request_handler(tdm_output *output,
 		}
 	}
 
-	mode_change_handler = calloc(1, sizeof(tdm_private_output_change_handler));
+	mode_change_handler = calloc(1, sizeof(tdm_private_output_mode_change_handler));
 	if (!mode_change_handler) {
 		/* LCOV_EXCL_START */
 		TDM_ERR("failed: alloc memory");
@@ -1427,6 +1427,7 @@ tdm_output_set_voutput_commit(tdm_voutput *voutput)
 		ret = tdm_voutput_set_commit_func(private_voutput, _tdm_voutput_cb_commit);
 		if (ret != TDM_ERROR_NONE) {
 			TDM_ERR("failed: tdm_voutput_set_commit_func");
+			_pthread_mutex_unlock(&private_display->lock);
 			return ret;
 		}
 	}
@@ -1629,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;
@@ -1813,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)) {
@@ -1868,11 +1873,18 @@ tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms 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;
 
@@ -2023,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