change int to float about type of zoom

diff --git a/src/include/mm_player.h b/src/include/mm_player.h
index 4200347..6df508e 100644 (file)
--- a/src/include/mm_player.h
+++ b/src/include/mm_player.h
@@ -1546,6 +1546,63 @@ int mm_player_get_track_count(MMHandleType player,  MMPlayerTrackType track_type
 
 
 /**
+ * This function is to set zoom level.
+ *
+ * @param       player         [in]    handle of player.
+ * @param       level           [in]    level of zoom
+ *
+ * @return      This function returns zero on success, or negative value with error
+ *                      code.
+ *
+ * @see
+ * @remark      None
+ */
+int mm_player_set_display_zoom(MMHandleType player, float level);
+
+/**
+ * This function is to get zoom level.
+ *
+ * @param       player          [in]    handle of player.
+ * @param       type             [out]  current level of zoom
+ *
+ * @return      This function returns zero on success, or negative value with error
+ *                      code.
+ *
+ * @see
+ * @remark      None
+ */
+int mm_player_get_display_zoom(MMHandleType player, float *level);
+
+/**
+ * This function is to set the start position of zoom
+ *
+ * @param       player           [in]    handle of player
+ * @param       x              [in]    start x position
+ * @param       y              [in]    start y position
+ *
+ * @return      This function returns zero on success, or negative value with error
+ *                      code.
+ *
+ * @see
+ * @remark      None
+ */
+int mm_player_set_display_zoom_start_position(MMHandleType player, int x, int y);
+
+/**
+ * This function is to get the start position of zoom
+ *
+ * @param       player           [in]    handle of player
+ * @param       x              [out]    start x position
+ * @param       y              [out]    start y position
+ *
+ * @return      This function returns zero on success, or negative value with error
+ *                      code.
+ *
+ * @see
+ * @remark      None
+ */
+int mm_player_get_display_zoom_start_position(MMHandleType player, int *x, int *y);
+/**
        @}
  */
 

diff --git a/src/include/mm_player_priv.h b/src/include/mm_player_priv.h
index 6e44af2..fdbee11 100755 (executable)
--- a/src/include/mm_player_priv.h
+++ b/src/include/mm_player_priv.h
@@ -672,6 +672,10 @@ int _mmplayer_update_video_param(mm_player_t* player);
 int _mmplayer_set_audiobuffer_cb(MMHandleType hplayer, mm_player_audio_stream_callback callback, void *user_param);
 int _mmplayer_audio_effect_preset_apply(mm_player_t *player, MMAudioEffectPresetType effect_type);
 int _mmplayer_audio_effect_custom_apply(mm_player_t *player);
+int _mmplayer_set_display_zoom(MMHandleType hplayer, float level);
+int _mmplayer_get_display_zoom(MMHandleType hplayer, float *level);
+int _mmplayer_set_display_zoom_start_pos(MMHandleType hplayer, int x, int y);
+int _mmplayer_get_display_zoom_start_pos(MMHandleType hplayer, int *x, int *y);
 
 #ifdef __cplusplus
        }

diff --git a/src/include/mm_player_utils.h b/src/include/mm_player_utils.h
index 480e1b8..220c262 100644 (file)
--- a/src/include/mm_player_utils.h
+++ b/src/include/mm_player_utils.h
@@ -251,6 +251,16 @@ debug_log("------------------------------------------------------------\n");
 #define        MMPLAYER_PT_IS_AUDIO( x_pt )            ( strstr(x_pt, "_97") || strstr(x_pt, "audio") )
 #define        MMPLAYER_PT_IS_VIDEO( x_pt )            ( strstr(x_pt, "_96") || strstr(x_pt, "video") )
 
+#define MMPLAYER_VIDEO_SINK_CHECK(x_player) \
+do \
+{ \
+       return_val_if_fail ( x_player && \
+               x_player->pipeline && \
+               x_player->pipeline->videobin && \
+               x_player->pipeline->videobin[MMPLAYER_V_SINK].gst, \
+               MM_ERROR_PLAYER_NOT_INITIALIZED ); \
+} while(0);
+
 bool util_is_sdp_file ( const char *path );
 int64_t uti_get_time ( void );
 int util_get_rank_increase ( const char *factory_class );

diff --git a/src/mm_player.c b/src/mm_player.c
index 8075283..007e160 100644 (file)
--- a/src/mm_player.c
+++ b/src/mm_player.c
@@ -802,3 +802,63 @@ int mm_player_ignore_session(MMHandleType player)
 
        return result;
 }
+
+int mm_player_set_display_zoom(MMHandleType player, float level)
+{
+       int result = MM_ERROR_NONE;
+       return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+       MMPLAYER_CMD_LOCK( player );
+
+       result = _mmplayer_set_display_zoom(player, level);
+
+       MMPLAYER_CMD_UNLOCK( player );
+
+       return result;
+}
+
+int mm_player_get_display_zoom(MMHandleType player, float *level)
+{
+       int result = MM_ERROR_NONE;
+
+       return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+       return_val_if_fail(level, MM_ERROR_COMMON_INVALID_ARGUMENT);
+
+       MMPLAYER_CMD_LOCK( player );
+
+       result = _mmplayer_get_display_zoom(player, level);
+
+       MMPLAYER_CMD_UNLOCK( player );
+
+       return result;
+}
+
+int mm_player_set_display_zoom_start_position(MMHandleType player, int x, int y)
+{
+       int result = MM_ERROR_NONE;
+
+       return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+       MMPLAYER_CMD_LOCK( player );
+
+       result = _mmplayer_set_display_zoom_start_pos(player, x, y);
+
+       MMPLAYER_CMD_UNLOCK( player );
+
+       return result;
+}
+
+int mm_player_get_display_zoom_start_position(MMHandleType player, int *x, int *y)
+{
+       int result = MM_ERROR_NONE;
+
+       return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+       MMPLAYER_CMD_LOCK( player );
+
+       result = _mmplayer_get_display_zoom_start_pos(player, x, y);
+
+       MMPLAYER_CMD_UNLOCK( player );
+
+       return result;
+}
\ No newline at end of file

diff --git a/src/mm_player_attrs.c b/src/mm_player_attrs.c
index 4bf0319..d30537e 100644 (file)
--- a/src/mm_player_attrs.c
+++ b/src/mm_player_attrs.c
@@ -682,12 +682,12 @@ _mmplayer_construct_attribute(MMHandleType handle)
                },
                {
                        "display_zoom",
-                       MM_ATTRS_TYPE_INT,
+                       MM_ATTRS_TYPE_DOUBLE,
                        MM_ATTRS_FLAG_RW,
                        (void *) 1,
-                       MM_ATTRS_VALID_TYPE_INT_RANGE,
-                       1,
-                       MMPLAYER_MAX_INT
+                       MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
+                       1.0,
+                       9.0
                },
                {
                        "display_surface_type",

diff --git a/src/mm_player_priv.c b/src/mm_player_priv.c
index dc09fe8..9b7ce63 100755 (executable)
--- a/src/mm_player_priv.c
+++ b/src/mm_player_priv.c
@@ -2702,16 +2702,9 @@ _mmplayer_update_video_param(mm_player_t* player) // @
                {
                        debug_log ("missing 'orientation' field in video caps");
                }
-               else
-               {
-                       debug_log("origianl video orientation = %d", org_angle);
-               }
        }
 
-       debug_log("check user angle: %d, org angle: %d", user_angle, org_angle);
-
-       /* get rotation value to set */
-       __mmplayer_get_property_value_for_rotation(player, org_angle+user_angle, &rotation_value);
+       debug_log("check user angle: %d, orientation: %d", user_angle, org_angle);
 
        /* check video stream callback is used */
        if( player->use_video_stream )
@@ -2736,19 +2729,23 @@ _mmplayer_update_video_param(mm_player_t* player) // @
                                if (height)
                                        g_object_set(player->pipeline->videobin[MMPLAYER_V_CONV].gst, "dst-height", height, NULL);
 
+                               /* NOTE: fimcconvert does not manage index of src buffer from upstream src-plugin, decoder gives frame information in output buffer with no ordering */
+                               g_object_set(player->pipeline->videobin[MMPLAYER_V_CONV].gst, "src-rand-idx", TRUE, NULL);
+
+                               /* get rotation value to set */
+                               __mmplayer_get_property_value_for_rotation(player, org_angle+user_angle, &rotation_value);
+
                                g_object_set(player->pipeline->videobin[MMPLAYER_V_CONV].gst, "rotate", rotation_value, NULL);
                                debug_log("updating fimcconvert - r[%d], w[%d], h[%d]", rotation_value, width, height);
                        }
-                       else
-                       {
-                               debug_error("no available video converter");
-                               return MM_ERROR_PLAYER_INTERNAL;
-                       }
                }
                else
                {
                        debug_log("using video stream callback with memsink. player handle : [%p]", player);
 
+                       /* get rotation value to set */
+                       __mmplayer_get_property_value_for_rotation(player, org_angle+user_angle, &rotation_value);
+
                        g_object_set(player->pipeline->videobin[MMPLAYER_V_FLIP].gst, "method", rotation_value, NULL);
                }
 
@@ -2766,7 +2763,7 @@ _mmplayer_update_video_param(mm_player_t* player) // @
                {
                        /* ximagesink or xvimagesink */
                        void *xid = NULL;
-                       int zoom = 0;
+                       double zoom = 0;
                        int display_method = 0;
                        int roi_x = 0;
                        int roi_y = 0;
@@ -2800,35 +2797,52 @@ _mmplayer_update_video_param(mm_player_t* player) // @
                        if (!strcmp(PLAYER_INI()->videosink_element_x,"xvimagesink"))
                        {
                                mm_attrs_get_int_by_name(attrs, "display_force_aspect_ration", &force_aspect_ratio);
-                               mm_attrs_get_int_by_name(attrs, "display_zoom", &zoom);
+                               mm_attrs_get_double_by_name(attrs, "display_zoom", &zoom);
                                mm_attrs_get_int_by_name(attrs, "display_method", &display_method);
                                mm_attrs_get_int_by_name(attrs, "display_roi_x", &roi_x);
                                mm_attrs_get_int_by_name(attrs, "display_roi_y", &roi_y);
                                mm_attrs_get_int_by_name(attrs, "display_roi_width", &roi_w);
                                mm_attrs_get_int_by_name(attrs, "display_roi_height", &roi_h);
                                mm_attrs_get_int_by_name(attrs, "display_visible", &visible);
+                               #define DEFAULT_DISPLAY_MODE    2       // TV only, PRI_VIDEO_OFF_AND_SEC_VIDEO_FULL_SCREEN
+
+                               /* setting for ROI mode */
+                               if (display_method == 5)        // 5 for ROI mode
+                               {
+                                       int roi_mode = 0;
+                                       mm_attrs_get_int_by_name(attrs, "display_roi_mode", &roi_mode);
+                                       g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst,
+                                               "dst-roi-mode", roi_mode,
+                                               "dst-roi-x", roi_x,
+                                               "dst-roi-y", roi_y,
+                                               "dst-roi-w", roi_w,
+                                               "dst-roi-h", roi_h,
+                                               NULL );
+                                       /* get rotation value to set,
+                                          do not use org_angle because ROI mode in xvimagesink needs both a rotation value and an orientation value */
+                                       __mmplayer_get_property_value_for_rotation(player, user_angle, &rotation_value);
+                               }
+                               else
+                               {
+                                       /* get rotation value to set */
+                                       __mmplayer_get_property_value_for_rotation(player, org_angle+user_angle, &rotation_value);
+                               }
 
                                g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst,
                                        "force-aspect-ratio", force_aspect_ratio,
-                                       "zoom", zoom,
+                                       "zoom", (float)zoom,
+                                       "orientation", org_angle/90, // setting for orientation of media, it is used for ROI/ZOOM feature in xvimagesink
                                        "rotate", rotation_value,
                                        "handle-events", TRUE,
                                        "display-geometry-method", display_method,
                                        "draw-borders", FALSE,
-                                       "dst-roi-x", roi_x,
-                                       "dst-roi-y", roi_y,
-                                       "dst-roi-w", roi_w,
-                                       "dst-roi-h", roi_h,
                                        "visible", visible,
+                                       "display-mode", DEFAULT_DISPLAY_MODE,
                                        NULL );
 
-                               debug_log("set video param : zoom %d", zoom);
-                               debug_log("set video param : rotate %d", rotation_value);
-                               debug_log("set video param : method %d", display_method);
-                               debug_log("set video param : dst-roi-x: %d, dst-roi-y: %d, dst-roi-w: %d, dst-roi-h: %d",
-                                                               roi_x, roi_y, roi_w, roi_h );
-                               debug_log("set video param : visible %d", visible);
-                               debug_log("set video param : force aspect ratio %d", force_aspect_ratio);
+                               debug_log("set video param : zoom %lf, rotate %d, method %d visible %d", zoom, rotation_value, display_method, visible);
+                               debug_log("set video param : dst-roi-x: %d, dst-roi-y: %d, dst-roi-w: %d, dst-roi-h: %d", roi_x, roi_y, roi_w, roi_h );
+                               debug_log("set video param : force aspect ratio %d, display mode %d", force_aspect_ratio, DEFAULT_DISPLAY_MODE);
                        }
 
             /* if vaapisink */
@@ -2857,8 +2871,7 @@ _mmplayer_update_video_param(mm_player_t* player) // @
                                                "evas-object", object,
                                                "visible", visible,
                                                NULL);
-                               debug_log("set video param : evas-object %x", object);
-                               debug_log("set video param : visible %d", visible);
+                               debug_log("set video param : evas-object %x, visible %d", object, visible);
                        }
                        else
                        {
@@ -2877,6 +2890,7 @@ _mmplayer_update_video_param(mm_player_t* player) // @
                                mm_attrs_get_int_by_name(attrs, "display_height", &height);
 
                                /* NOTE: fimcconvert does not manage index of src buffer from upstream src-plugin, decoder gives frame information in output buffer with no ordering */
+                               g_object_set(player->pipeline->videobin[MMPLAYER_V_CONV].gst, "src-rand-idx", TRUE, NULL);
                                g_object_set(player->pipeline->videobin[MMPLAYER_V_CONV].gst, "dst-buffer-num", 5, NULL);
 
                                if (no_scaling)
@@ -2919,8 +2933,12 @@ _mmplayer_update_video_param(mm_player_t* player) // @
                                mm_attrs_get_int_by_name(attrs, "display_roi_width", &roi_w);
                                mm_attrs_get_int_by_name(attrs, "display_roi_height", &roi_h);
 
+                               /* get rotation value to set */
+                               __mmplayer_get_property_value_for_rotation(player, org_angle+user_angle, &rotation_value);
+
                                g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst,
                                        "origin-size", origin_size,
+                                       "rotate", rotation_value,
                                        "dst-roi-x", roi_x,
                                        "dst-roi-y", roi_y,
                                        "dst-roi-w", roi_w,
@@ -2933,7 +2951,6 @@ _mmplayer_update_video_param(mm_player_t* player) // @
                                                                roi_x, roi_y, roi_w, roi_h );
                                debug_log("set video param : display_evas_do_scaling %d (origin-size %d)", scaling, origin_size);
                        }
-                       g_object_set(player->pipeline->videobin[MMPLAYER_V_FLIP].gst, "method", rotation_value, NULL);
                }
                break;
                case MM_DISPLAY_SURFACE_X_EXT:  /* NOTE : this surface type is used for the videoTexture(canvasTexture) overlay */
@@ -10525,3 +10542,75 @@ __is_http_progressive_down(mm_player_t* player)
 
        return ((player->pd_mode) ? TRUE:FALSE);
 }
+
+int
+_mmplayer_set_display_zoom(MMHandleType hplayer, float level)
+{
+       mm_player_t* player = (mm_player_t*) hplayer;
+
+       return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
+
+       MMPLAYER_VIDEO_SINK_CHECK(player);
+
+       debug_log("setting display zoom level = %f", level);
+
+       g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "zoom", level, NULL);
+
+       return MM_ERROR_NONE;
+}
+
+int
+_mmplayer_get_display_zoom(MMHandleType hplayer, float *level)
+{
+       mm_player_t* player = (mm_player_t*) hplayer;
+       float _level = 0.0;
+
+       return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
+
+       MMPLAYER_VIDEO_SINK_CHECK(player);
+
+       g_object_get(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "zoom", &_level, NULL);
+
+       debug_log("display zoom level = %f", _level);
+
+       *level = _level;
+
+       return MM_ERROR_NONE;
+}
+
+int
+_mmplayer_set_display_zoom_start_pos(MMHandleType hplayer, int x, int y)
+{
+       mm_player_t* player = (mm_player_t*) hplayer;
+
+       return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
+
+       MMPLAYER_VIDEO_SINK_CHECK(player);
+
+       debug_log("setting display zoom offset = %d, %d", x, y);
+
+       g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "zoom-pos-x", x, "zoom-pos-y", y, NULL);
+
+       return MM_ERROR_NONE;
+}
+
+int
+_mmplayer_get_display_zoom_start_pos(MMHandleType hplayer, int *x, int *y)
+{
+       int _x = 0;
+       int _y = 0;
+       mm_player_t* player = (mm_player_t*) hplayer;
+
+       return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
+
+       MMPLAYER_VIDEO_SINK_CHECK(player);
+
+       g_object_get(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "zoom-pos-x", &_x, "zoom-pos-y", &_y, NULL);
+
+       debug_log("display zoom start off x = %d, y = %d", _x, _y);
+
+       *x = _x;
+       *y = _y;
+
+       return MM_ERROR_NONE;
+}