Modify calculating rotate value with content orientation

Change-Id: Icfb710b6aa8202a03e69f9bc1910a3e81adeffcc
Signed-off-by: Hyunil <hyunil46.park@samsung.com>

4 files changed, 62 insertions, 123 deletions

diff --git a/packaging/libmm-player.spec b/packaging/libmm-player.spec
index ac950fb..20158c6 100644
--- a/packaging/libmm-player.spec
+++ b/packaging/libmm-player.spec
@@ -1,6 +1,6 @@
 Name:       libmm-player
 Summary:    Multimedia Framework Player Library
-Version:    0.6.131
+Version:    0.6.132
 Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0
diff --git a/src/include/mm_player_priv.h b/src/include/mm_player_priv.h
index da43974..3cc5069 100644
--- a/src/include/mm_player_priv.h
+++ b/src/include/mm_player_priv.h
@@ -73,10 +73,6 @@
  */
 #define MM_PLAYER_GET_ATTRS(x_player)	(MM_PLAYER_CAST(x_player)->attrs)
 
-#define ROTATION_USING_SINK     0
-#define ROTATION_USING_CUSTOM   1
-#define ROTATION_USING_FLIP     2
-
 #define MM_MAX_STRING_LENGTH    4000 /* have to be less than MUSE_MSG_MAX_LENGTH */
 
 #define VIDEO360_MAX_ZOOM	10.0f
@@ -964,7 +960,7 @@ void __mmplayer_cancel_eos_timer(mm_player_t* player);
 void __mmplayer_audio_stream_clear_buffer(mm_player_t* player, gboolean send_all);
 gboolean __mmplayer_configure_audio_callback(mm_player_t* player);
 MMStreamingType __mmplayer_get_stream_service_type(mm_player_t* player);
-int __mmplayer_get_video_angle(mm_player_t* player, int *user_angle, int *org_angle);
+int __mmplayer_get_video_angle(mm_player_t* player, int *display_angle, int *orientations);
 gboolean __mmplayer_gst_remove_fakesink(mm_player_t* player, MMPlayerGstElement* fakesink);
 void __mmplayer_add_signal_connection(mm_player_t* player, GObject* object, MMPlayerSignalType type, const gchar* signal, GCallback cb_funct, gpointer u_data);
 void __mmplayer_gst_decode_pad_added(GstElement *elem, GstPad *pad, gpointer data);
diff --git a/src/mm_player_capture.c b/src/mm_player_capture.c
index 8a05907..dc8ba6c 100755
--- a/src/mm_player_capture.c
+++ b/src/mm_player_capture.c
@@ -273,7 +273,7 @@ __mmplayer_capture_thread(gpointer data)
 	unsigned char * linear_y_plane = NULL;
 	unsigned char * linear_uv_plane = NULL;
 	int orientation = 0;
-	int user_angle = 0;
+	int display_angle = 0;
 	int ret = 0;
 	int planes[MAX_BUFFER_PLANE] = {0, };
 	unsigned char * p_buf = NULL;
@@ -459,13 +459,13 @@ __mmplayer_capture_thread(gpointer data)
 			}
 		}
 
-		ret = __mmplayer_get_video_angle((MMHandleType)player, &user_angle, &orientation);
+		ret = __mmplayer_get_video_angle((MMHandleType)player, &display_angle, &orientation);
 		if (ret != MM_ERROR_NONE) {
 			LOGE("failed to get rotation angle");
 			goto ERROR;
 		}
 
-		LOGD("orientation value = %d user_angle = %d", orientation, user_angle);
+		LOGD("orientation value = %d user_angle = %d", orientation, display_angle);
 
 		ret = __mmplayer_handle_orientation(player, orientation, MM_UTIL_COLOR_RGB24);
 		if (ret != MM_ERROR_NONE) {
diff --git a/src/mm_player_priv.c b/src/mm_player_priv.c
index 1464b82..8a3c025 100644
--- a/src/mm_player_priv.c
+++ b/src/mm_player_priv.c
@@ -2277,113 +2277,56 @@ ERROR:
 }
 
 static gboolean
-__mmplayer_get_property_value_for_rotation(mm_player_t* player, int rotation_angle, int *value)
+__mmplayer_get_property_value_for_rotation(mm_player_t* player, int display_angle, int orientation, int *value)
 {
-	int pro_value = 0; // in the case of expection, default will be returned.
-	int dest_angle = rotation_angle;
-	int rotation_type = -1;
+	int required_angle = 0; /* Angle required for straight view */
+	int rotation_angle = 0;
 
 	MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
 	MMPLAYER_RETURN_VAL_IF_FAIL(value, FALSE);
-	MMPLAYER_RETURN_VAL_IF_FAIL(rotation_angle >= 0, FALSE);
 
+	/* Counter clockwise */
+	switch (orientation) {
+	case 0:
+		required_angle = 0;
+		break;
+	case 90:
+		required_angle = 270;
+		break;
+	case 180:
+		required_angle = 180;
+		break;
+	case 270:
+		required_angle = 90;
+		break;
+	}
+
+	rotation_angle = display_angle + required_angle;
 	if (rotation_angle >= 360)
-		dest_angle = rotation_angle - 360;
+		rotation_angle -= 360;
 
 	/* chech if supported or not */
-	if (dest_angle % 90) {
+	if (rotation_angle % 90) {
 		LOGD("not supported rotation angle = %d", rotation_angle);
 		return FALSE;
 	}
 
-	/*
-	  * tizenwlsink	(A)
-	  * custom_convert - none (B)
-	  * videoflip - none (C)
-	  */
-	if (player->set_mode.video_zc) {
-		if (player->pipeline->videobin[MMPLAYER_V_CONV].gst) // B
-			rotation_type = ROTATION_USING_CUSTOM;
-		else // A
-			rotation_type = ROTATION_USING_SINK;
-	} else {
-		int surface_type = 0;
-		rotation_type = ROTATION_USING_FLIP;
-
-		mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &surface_type);
-		LOGD("check display surface type attribute: %d", surface_type);
-
-		if (surface_type == MM_DISPLAY_SURFACE_OVERLAY)
-			rotation_type = ROTATION_USING_SINK;
-		else
-			rotation_type = ROTATION_USING_FLIP; //C
-
-		LOGD("using %d type for rotation", rotation_type);
-	}
-
-	/* get property value for setting */
-	switch (rotation_type) {
-	case ROTATION_USING_SINK: // tizenwlsink
-		{
-			switch (dest_angle) {
-			case 0:
-				break;
-			case 90:
-				pro_value = 3; // clockwise 90
-				break;
-			case 180:
-				pro_value = 2;
-				break;
-			case 270:
-				pro_value = 1; // counter-clockwise 90
-				break;
-			}
-		}
+	switch (rotation_angle) {
+	case 0:
+		*value = MM_DISPLAY_ROTATION_NONE;
 		break;
-	case ROTATION_USING_CUSTOM:
-		{
-			gchar *ename = NULL;
-			ename = GST_OBJECT_NAME(gst_element_get_factory(player->pipeline->videobin[MMPLAYER_V_CONV].gst));
-
-			if (g_strrstr(ename, "fimcconvert")) {
-				switch (dest_angle) {
-				case 0:
-					break;
-				case 90:
-					pro_value = 90; // clockwise 90
-					break;
-				case 180:
-					pro_value = 180;
-					break;
-				case 270:
-					pro_value = 270; // counter-clockwise 90
-					break;
-				}
-			}
-		}
+	case 90:
+		*value = MM_DISPLAY_ROTATION_90;
 		break;
-	case ROTATION_USING_FLIP: // videoflip
-		{
-				switch (dest_angle) {
-				case 0:
-					break;
-				case 90:
-					pro_value = 1; // clockwise 90
-					break;
-				case 180:
-					pro_value = 2;
-					break;
-				case 270:
-					pro_value = 3; // counter-clockwise 90
-					break;
-				}
-		}
+	case 180:
+		*value = MM_DISPLAY_ROTATION_180;
+		break;
+	case 270:
+		*value = MM_DISPLAY_ROTATION_270;
 		break;
 	}
 
-	LOGD("setting rotation property value : %d, used rotation type : %d", pro_value, rotation_type);
-
-	*value = pro_value;
+	LOGD("setting rotation property value : %d", value);
 
 	return TRUE;
 }
@@ -2403,9 +2346,9 @@ __mmplayer_video_param_check_video_sink_bin(mm_player_t* player)
 }
 
 int
-__mmplayer_get_video_angle(mm_player_t* player, int *user_angle, int *org_angle)
+__mmplayer_get_video_angle(mm_player_t* player, int *display_angle, int *orientation)
 {
-	int user_angle_type = 0;
+	int display_rotation = 0;
 	gchar *org_orient = NULL;
 	MMHandleType attrs = MMPLAYER_GET_ATTRS(player);
 
@@ -2414,49 +2357,49 @@ __mmplayer_get_video_angle(mm_player_t* player, int *user_angle, int *org_angle)
 		return MM_ERROR_PLAYER_INTERNAL;
 	}
 
-	if (user_angle) {
+	if (display_angle) {
 		/* update user roation */
-		mm_attrs_get_int_by_name(attrs, "display_rotation", &user_angle_type);
+		mm_attrs_get_int_by_name(attrs, "display_rotation", &display_rotation);
 
-		/* get angle with user type */
-		switch (user_angle_type) {
+		/* Counter clockwise */
+		switch (display_rotation) {
 		case MM_DISPLAY_ROTATION_NONE:
-			*user_angle = 0;
+			*display_angle = 0;
 			break;
-		case MM_DISPLAY_ROTATION_90: /* counter-clockwise 90 */
-			*user_angle = 270;
+		case MM_DISPLAY_ROTATION_90:
+			*display_angle = 90;
 			break;
 		case MM_DISPLAY_ROTATION_180:
-			*user_angle = 180;
+			*display_angle = 180;
 			break;
-		case MM_DISPLAY_ROTATION_270: /* clockwise 90 */
-			*user_angle = 90;
+		case MM_DISPLAY_ROTATION_270:
+			*display_angle = 270;
 			break;
 		default:
-			LOGW("wrong angle type : %d", user_angle_type);
+			LOGW("wrong angle type : %d", display_rotation);
 			break;
 		}
-		LOGD("check user angle: %d", *user_angle);
+		LOGD("check user angle: %d", *display_angle);
 	}
 
-	if (org_angle) {
-		/* get original orientation */
+	if (orientation) {
+		/* Counter clockwise */
 		mm_attrs_get_string_by_name(attrs, "content_video_orientation", &org_orient);
 
 		if (org_orient) {
 			if (!strcmp(org_orient, "rotate-90"))
-				*org_angle = 90;
+				*orientation = 90;
 			else if (!strcmp(org_orient, "rotate-180"))
-				*org_angle = 180;
+				*orientation = 180;
 			else if (!strcmp(org_orient, "rotate-270"))
-				*org_angle = 270;
+				*orientation = 270;
 			else
 				LOGD("original rotation is %s", org_orient);
 		} else {
 			LOGD("content_video_orientation get fail");
 		}
 
-		LOGD("check orientation: %d", *org_angle);
+		LOGD("check orientation: %d", *orientation);
 	}
 
 	return MM_ERROR_NONE;
@@ -2466,18 +2409,18 @@ void
 __mmplayer_video_param_set_display_rotation(mm_player_t* player)
 {
 	int rotation_value = 0;
-	int org_angle = 0; // current supported angle values are 0, 90, 180, 270
-	int user_angle = 0;
+	int orientations = 0; // current supported angle values are 0, 90, 180, 270
+	int display_angle = 0;
 	MMPLAYER_FENTER();
 
 	/* check video sinkbin is created */
 	if (MM_ERROR_NONE != __mmplayer_video_param_check_video_sink_bin(player))
 		return;
 
-	__mmplayer_get_video_angle(player, &user_angle, &org_angle);
+	__mmplayer_get_video_angle(player, &display_angle, &orientations);
 
 	/* get rotation value to set */
-	__mmplayer_get_property_value_for_rotation(player, org_angle+user_angle, &rotation_value);
+	__mmplayer_get_property_value_for_rotation(player, display_angle, orientations, &rotation_value);
 	g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "rotate", rotation_value, NULL);
 	LOGD("set video param : rotate %d", rotation_value);
 }