Modify calculating rotate value with content orientation

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

diff --git a/packaging/libmm-player.spec b/packaging/libmm-player.spec
index ac950fb..20158c6 100644 (file)
--- 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 (file)
--- 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 (executable)
--- 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 (file)
--- 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);
 }