[0.2.86] add aborting pause for unprepare and destroy

- add aborting pause for immediate unprepare and destroy.
- add internal state to specify the preparing state.
- do unset cb in legacy layer not to wait cmd lock.
  issue: can not do unset cb during pausing.

Change-Id: I450d0c6a068d3eaabb697fc38005bd7c8bd9ee7d

diff --git a/legacy/include/legacy_player.h b/legacy/include/legacy_player.h
index 65a7dbe..9556da8 100644 (file)
--- a/legacy/include/legacy_player.h
+++ b/legacy/include/legacy_player.h
@@ -868,24 +868,10 @@ int legacy_player_release_video_stream_bo(player_h player, void* bo);
  * @retval #PLAYER_ERROR_INVALID_PARAMETER Invalid parameter
  * @retval #PLAYER_ERROR_INVALID_STATE Invalid state
  * @pre        The player's state should be #PLAYER_STATE_IDLE. And, #PLAYER_DISPLAY_TYPE_NONE should be set by calling legacy_player_set_display().
- * @see legacy_player_unset_media_packet_video_frame_decoded_cb
  */
 int legacy_player_set_media_packet_video_frame_decoded_cb(player_h player, legacy_player_media_packet_video_decoded_cb callback, void *user_data);
 
 /**
- * @brief Unregisters the callback function.
- * @since_tizen 2.3
- * @param[in] player The handle to the media player
- * @return @c 0 on success,
- *         otherwise a negative error value
- * @retval #PLAYER_ERROR_NONE Successful
- * @retval #PLAYER_ERROR_INVALID_PARAMETER Invalid parameter
- * @pre The player's state should be #PLAYER_STATE_READY or #PLAYER_STATE_IDLE
- * @see legacy_player_set_media_packet_video_frame_decoded_cb()
- */
-int legacy_player_unset_media_packet_video_frame_decoded_cb(player_h player);
-
-/**
  * @brief  Pushes elementary stream to decode audio or video
  * @since_tizen 2.4
  * @remarks legacy_player_set_media_stream_info() should be called before using this API.

diff --git a/legacy/include/legacy_player_private.h b/legacy/include/legacy_player_private.h
index 2b8e2ba..340ebcc 100644 (file)
--- a/legacy/include/legacy_player_private.h
+++ b/legacy/include/legacy_player_private.h
@@ -92,6 +92,19 @@ typedef enum {
        PLAYER_MESSAGE_MAX
 } _player_message_e;
 
+typedef enum {
+       PLAYER_INTERNAL_STATE_NONE,
+       PLAYER_INTERNAL_STATE_IDLE,
+       PLAYER_INTERNAL_STATE_PRE_READY,
+       PLAYER_INTERNAL_STATE_READY,
+/*     PLAYER_INTERNAL_STATE_PRE_PLAYING, */
+       PLAYER_INTERNAL_STATE_PLAYING,
+/*     PLAYER_INTERNAL_STATE_PRE_PAUSED, */
+       PLAYER_INTERNAL_STATE_PAUSED,
+/*     PLAYER_INTERNAL_STATE_PRE_STOPPED, */
+       PLAYER_INTERNAL_STATE_STOPPED,
+} player_internal_state_e;
+
 typedef struct _player_s {
        MMHandleType mm_handle;
        const void* user_cb[MUSE_PLAYER_EVENT_TYPE_NUM];
@@ -100,8 +113,8 @@ typedef struct _player_s {
        void* wl_display;
        void* display_handle;
        player_display_type_e display_type;
-       int state;
-       bool is_stopped;
+       player_state_e state;
+       player_internal_state_e internal_state;
        bool is_display_visible;
        bool is_progressive_download;
        bool is_media_stream;

diff --git a/legacy/src/legacy_player.c b/legacy/src/legacy_player.c
index 9bb86c4..b5cdad5 100644 (file)
--- a/legacy/src/legacy_player.c
+++ b/legacy/src/legacy_player.c
@@ -236,6 +236,44 @@ int __player_convert_error_code(int code, char *func_name)
        return ret;
 }
 
+static void __player_update_state(player_s *handle, player_internal_state_e state)
+{
+       switch (state) {
+       case PLAYER_INTERNAL_STATE_NONE:
+               handle->state = PLAYER_STATE_NONE;
+               handle->internal_state = PLAYER_INTERNAL_STATE_IDLE;
+       break;
+       case PLAYER_INTERNAL_STATE_IDLE:
+               handle->state = PLAYER_STATE_IDLE;
+               handle->internal_state = PLAYER_INTERNAL_STATE_IDLE;
+       break;
+       case PLAYER_INTERNAL_STATE_PRE_READY:
+               handle->internal_state = PLAYER_INTERNAL_STATE_PRE_READY;
+       break;
+       case PLAYER_INTERNAL_STATE_READY:
+               handle->state = PLAYER_STATE_READY;
+               handle->internal_state = PLAYER_INTERNAL_STATE_READY;
+       break;
+       case PLAYER_INTERNAL_STATE_PLAYING:
+               handle->internal_state = PLAYER_INTERNAL_STATE_PLAYING;
+               handle->state = PLAYER_STATE_PLAYING;
+       break;
+       case PLAYER_INTERNAL_STATE_PAUSED:
+               handle->internal_state = PLAYER_INTERNAL_STATE_PAUSED;
+               handle->state = PLAYER_STATE_PAUSED;
+       break;
+       case PLAYER_INTERNAL_STATE_STOPPED:
+               handle->state = PLAYER_STATE_READY;
+               handle->internal_state = PLAYER_INTERNAL_STATE_STOPPED;
+       break;
+       default:
+       break;
+       }
+
+       LOGD("player state is updated to 0x%X, 0x%X", handle->state, handle->internal_state);
+       return;
+}
+
 bool __player_state_validate(player_s *handle, player_state_e threshold)
 {
        if (handle->state < threshold)
@@ -288,7 +326,7 @@ static void __message_cb_loop(void *data)
 
                                LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
                                if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
-                                       handle->state = PLAYER_STATE_READY;
+                                       __player_update_state(handle, PLAYER_INTERNAL_STATE_READY);
                                        ((player_prepared_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE])(handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE]);
                                        handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
                                        handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
@@ -577,7 +615,7 @@ int legacy_player_create(player_h *player)
        int ret = mm_player_create(&handle->mm_handle);
        if (ret != MM_ERROR_NONE) {
                LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION);
-               handle->state = PLAYER_STATE_NONE;
+               __player_update_state(handle, PLAYER_INTERNAL_STATE_NONE);
                free(handle);
                handle = NULL;
                return __player_convert_error_code(ret, (char *)__FUNCTION__);
@@ -585,9 +623,8 @@ int legacy_player_create(player_h *player)
                muse_player_event_e type = MUSE_PLAYER_EVENT_TYPE_PREPARE;
 
                *player = (player_h)handle;
-               handle->state = PLAYER_STATE_IDLE;
+               __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
                handle->display_type = PLAYER_DISPLAY_TYPE_NONE;
-               handle->is_stopped = FALSE;
                handle->is_display_visible = TRUE;
                handle->is_media_stream = FALSE;
 
@@ -620,9 +657,6 @@ int legacy_player_destroy(player_h player)
 
        __ADD_MESSAGE(handle, PLAYER_MESSAGE_LOOP_EXIT);
 
-       __RELEASEIF_PREPARE_THREAD(handle->prepare_async_thread);
-       __RELEASEIF_MESSAGE_THREAD(handle->message_thread);
-
        LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
        if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
                handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
@@ -633,6 +667,13 @@ int legacy_player_destroy(player_h player)
        }
        LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 
+       /* stop the pause state trasition to release prepare thread */
+       if (handle->internal_state == PLAYER_INTERNAL_STATE_PRE_READY)
+               mm_player_abort_pause(handle->mm_handle);
+
+       __RELEASEIF_PREPARE_THREAD(handle->prepare_async_thread);
+       __RELEASEIF_MESSAGE_THREAD(handle->message_thread);
+
        int ret = mm_player_destroy(handle->mm_handle);
 
        LOGI("[%s] Done mm_player_destroy", __FUNCTION__);
@@ -643,7 +684,7 @@ int legacy_player_destroy(player_h player)
        } else {
                muse_player_event_e type = MUSE_PLAYER_EVENT_TYPE_PREPARE;
 
-               handle->state = PLAYER_STATE_NONE;
+               __player_update_state(handle, PLAYER_INTERNAL_STATE_NONE);
 
                for (type = MUSE_PLAYER_EVENT_TYPE_PREPARE; type < MUSE_PLAYER_EVENT_TYPE_NUM; type++) {
                        if (_check_enabled_user_cb_lock(type))
@@ -686,6 +727,7 @@ static void *__prepare_async_thread_func(void *data)
                ret = mm_player_unrealize(handle->mm_handle);
                if (ret != MM_ERROR_NONE)
                        LOGE("[%s] Failed to unrealize - 0x%x", __FUNCTION__, ret);
+               __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
        }
        LOGI("[%s], done", __FUNCTION__);
        return NULL;
@@ -703,12 +745,14 @@ int legacy_player_prepare_async(player_h player, player_prepared_cb callback, vo
        PLAYER_TRACE_ASYNC_BEGIN("MM:PLAYER:PREPARE_ASYNC", *(int *)handle);
        PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
 
+       __player_update_state(handle, PLAYER_INTERNAL_STATE_PRE_READY);
        LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 
        handle->last_play_position = 0;
        if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
                LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION (0x%08x) : preparing... we can't do any more ", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION);
                LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+               __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
                return PLAYER_ERROR_INVALID_OPERATION;
        } else {
                /* LOGI("[%s] Event type : %d ",__FUNCTION__, MUSE_PLAYER_EVENT_TYPE_PREPARE); */
@@ -758,6 +802,7 @@ int legacy_player_prepare_async(player_h player, player_prepared_cb callback, vo
                                handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
                        }
                        LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+                       __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
                        return PLAYER_ERROR_OUT_OF_MEMORY;
                }
        }
@@ -774,6 +819,7 @@ ERROR:
                handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
        }
        LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+       __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
 
        LOGE("LEAVE mm_err:0x%X", ret);
        return __player_convert_error_code(ret, (char *)__FUNCTION__);
@@ -790,6 +836,7 @@ int legacy_player_prepare(player_h player)
        PLAYER_INSTANCE_CHECK(player);
        player_s *handle = (player_s *)player;
        PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
+       __player_update_state(handle, PLAYER_INTERNAL_STATE_PRE_READY);
 
        handle->last_play_position = 0;
        ret = mm_player_set_message_callback(handle->mm_handle, __msg_callback, (void *)handle);
@@ -802,8 +849,10 @@ int legacy_player_prepare(player_h player)
                        LOGW("[%s] Failed to set display surface type 'MM_DISPLAY_SURFACE_NULL' (0x%x)", __FUNCTION__, ret);
        } else {
                ret = mm_player_get_attribute(handle->mm_handle, NULL, "display_visible", &visible, (char *)NULL);
-               if (ret != MM_ERROR_NONE)
+               if (ret != MM_ERROR_NONE) {
+                       __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
                        return __player_convert_error_code(ret, (char *)__FUNCTION__);
+               }
 
                if (!visible)
                        value = FALSE;
@@ -819,6 +868,7 @@ int legacy_player_prepare(player_h player)
        ret = mm_player_realize(handle->mm_handle);
        if (ret != MM_ERROR_NONE) {
                LOGE("[%s] Failed to realize - 0x%x", __FUNCTION__, ret);
+               __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
                return __player_convert_error_code(ret, (char *)__FUNCTION__);
        }
 
@@ -832,9 +882,10 @@ int legacy_player_prepare(player_h player)
                        LOGE("[%s] Failed to unrealize - 0x%x", __FUNCTION__, uret);
 
                LOGE("[%s] Failed to pause - 0x%x", __FUNCTION__, ret);
+               __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
                return __player_convert_error_code(ret, (char *)__FUNCTION__);
        } else {
-               handle->state = PLAYER_STATE_READY;
+               __player_update_state(handle, PLAYER_INTERNAL_STATE_READY);
                LOGI("[%s] End", __FUNCTION__);
                PLAYER_TRACE_END();
                return PLAYER_ERROR_NONE;
@@ -854,7 +905,7 @@ int legacy_player_unprepare(player_h player)
                handle->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
        }
 
-       if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+       if (!__player_state_validate(handle, PLAYER_STATE_READY) && !handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
                LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
@@ -870,6 +921,10 @@ int legacy_player_unprepare(player_h player)
        }
        LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 
+       /* stop the pause state trasition to release prepare thread */
+       if (handle->internal_state == PLAYER_INTERNAL_STATE_PRE_READY)
+               mm_player_abort_pause(handle->mm_handle);
+
        __RELEASEIF_PREPARE_THREAD(handle->prepare_async_thread);
 
        int ret = mm_player_unrealize(handle->mm_handle);
@@ -877,8 +932,7 @@ int legacy_player_unprepare(player_h player)
        if (ret != MM_ERROR_NONE) {
                return __player_convert_error_code(ret, (char *)__FUNCTION__);
        } else {
-               handle->state = PLAYER_STATE_IDLE;
-               handle->is_stopped = FALSE;
+               __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
                handle->is_display_visible = TRUE;
                handle->is_progressive_download = FALSE;
                LOGI("[%s] End", __FUNCTION__);
@@ -1035,7 +1089,7 @@ int legacy_player_start(player_h player)
                        if (ret != MM_ERROR_NONE)
                                LOGW("[%s] Failed to set display_visible '1' (0x%x)", __FUNCTION__, ret);
                }
-               if (handle->is_stopped) {
+               if (handle->internal_state == PLAYER_INTERNAL_STATE_STOPPED) {
                        if (handle->is_progressive_download) {
                                LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION);
                                return PLAYER_ERROR_INVALID_OPERATION;
@@ -1057,8 +1111,7 @@ int legacy_player_start(player_h player)
        if (ret != MM_ERROR_NONE) {
                return __player_convert_error_code(ret, (char *)__FUNCTION__);
        } else {
-               handle->is_stopped = FALSE;
-               handle->state = PLAYER_STATE_PLAYING;
+               __player_update_state(handle, PLAYER_INTERNAL_STATE_PLAYING);
                LOGI("[%s] End", __FUNCTION__);
                return PLAYER_ERROR_NONE;
        }
@@ -1087,8 +1140,8 @@ int legacy_player_stop(player_h player)
                                handle->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
                        }
 
-                       handle->state = PLAYER_STATE_READY;
-                       handle->is_stopped = TRUE;
+                       __player_update_state(handle, PLAYER_INTERNAL_STATE_STOPPED);
+
                        LOGI("[%s] End", __FUNCTION__);
                        return PLAYER_ERROR_NONE;
                }
@@ -1109,7 +1162,7 @@ int legacy_player_pause(player_h player)
        if (ret != MM_ERROR_NONE) {
                return __player_convert_error_code(ret, (char *)__FUNCTION__);
        } else {
-               handle->state = PLAYER_STATE_PAUSED;
+               __player_update_state(handle, PLAYER_INTERNAL_STATE_PAUSED);
                LOGI("[%s] End", __FUNCTION__);
                return PLAYER_ERROR_NONE;
        }
@@ -1974,20 +2027,6 @@ int legacy_player_set_media_packet_video_frame_decoded_cb(player_h player, legac
        return PLAYER_ERROR_NONE;
 }
 
-int legacy_player_unset_media_packet_video_frame_decoded_cb(player_h player)
-{
-       PLAYER_INSTANCE_CHECK(player);
-       player_s *handle = (player_s *)player;
-
-       LOGI("Event type : %d ", MUSE_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME);
-
-       int ret = mm_player_set_video_stream_callback(handle->mm_handle, NULL, NULL);
-       if (ret != MM_ERROR_NONE)
-               return __player_convert_error_code(ret, (char *)__FUNCTION__);
-       else
-               return PLAYER_ERROR_NONE;
-}
-
 static bool __video_stream_changed_callback(void *user_data)
 {
        player_s *handle = (player_s *)user_data;
@@ -2035,17 +2074,11 @@ int legacy_player_set_video_stream_changed_cb(player_h player, player_video_stre
 
 int legacy_player_unset_video_stream_changed_cb(player_h player)
 {
-       int ret;
        PLAYER_INSTANCE_CHECK(player);
-       player_s *handle = (player_s *)player;
 
        __unset_callback(MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED, player);
 
-       ret = mm_player_set_video_stream_changed_callback(handle->mm_handle, NULL, NULL);
-       if (ret != MM_ERROR_NONE)
-               return __player_convert_error_code(ret, (char *)__FUNCTION__);
-       else
-               return PLAYER_ERROR_NONE;
+       return PLAYER_ERROR_NONE;
 }
 
 static bool __media_stream_buffer_status_callback(player_stream_type_e type, player_media_stream_buffer_status_e status, unsigned long long bytes, void *user_data)
@@ -2123,9 +2156,7 @@ int legacy_player_set_media_stream_buffer_status_cb(player_h player, player_stre
 
 int legacy_player_unset_media_stream_buffer_status_cb(player_h player, player_stream_type_e type)
 {
-       int ret;
        PLAYER_INSTANCE_CHECK(player);
-       player_s *handle = (player_s *)player;
 
        if (type == PLAYER_STREAM_TYPE_VIDEO)
                __unset_callback(MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS, player);
@@ -2134,11 +2165,7 @@ int legacy_player_unset_media_stream_buffer_status_cb(player_h player, player_st
        else
                return PLAYER_ERROR_INVALID_PARAMETER;
 
-       ret = mm_player_set_media_stream_buffer_status_callback(handle->mm_handle, type, NULL, NULL);
-       if (ret != MM_ERROR_NONE)
-               return __player_convert_error_code(ret, (char *)__FUNCTION__);
-       else
-               return PLAYER_ERROR_NONE;
+       return PLAYER_ERROR_NONE;
 }
 
 int legacy_player_set_media_stream_seek_cb(player_h player, player_stream_type_e type, player_media_stream_seek_cb callback, void *user_data)
@@ -2168,9 +2195,7 @@ int legacy_player_set_media_stream_seek_cb(player_h player, player_stream_type_e
 
 int legacy_player_unset_media_stream_seek_cb(player_h player, player_stream_type_e type)
 {
-       int ret;
        PLAYER_INSTANCE_CHECK(player);
-       player_s *handle = (player_s *)player;
 
        if (type == PLAYER_STREAM_TYPE_VIDEO)
                __unset_callback(MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK, player);
@@ -2179,11 +2204,7 @@ int legacy_player_unset_media_stream_seek_cb(player_h player, player_stream_type
        else
                return PLAYER_ERROR_INVALID_PARAMETER;
 
-       ret = mm_player_set_media_stream_seek_data_callback(handle->mm_handle, type, NULL, NULL);
-       if (ret != MM_ERROR_NONE)
-               return __player_convert_error_code(ret, (char *)__FUNCTION__);
-       else
-               return PLAYER_ERROR_NONE;
+       return PLAYER_ERROR_NONE;
 }
 
 int legacy_player_push_media_stream(player_h player, media_packet_h packet)

diff --git a/legacy/src/legacy_player_internal.c b/legacy/src/legacy_player_internal.c
index c420574..2bb7247 100644 (file)
--- a/legacy/src/legacy_player_internal.c
+++ b/legacy/src/legacy_player_internal.c
@@ -202,7 +202,6 @@ int legacy_player_set_media_stream_buffer_status_cb_ex(player_h player, player_s
 
 int legacy_player_unset_media_stream_buffer_status_cb_ex(player_h player, player_stream_type_e type)
 {
-       int ret;
        PLAYER_INSTANCE_CHECK(player);
        player_s *handle = (player_s *)player;
        muse_player_event_e event_type;
@@ -223,12 +222,7 @@ int legacy_player_unset_media_stream_buffer_status_cb_ex(player_h player, player
 
        LOGI("[%s] Event type : %d ", __FUNCTION__, type);
 
-       ret = mm_player_set_media_stream_buffer_status_callback(handle->mm_handle, type, NULL, NULL);
-
-       if (ret != MM_ERROR_NONE)
-               return __player_convert_error_code(ret, (char *)__FUNCTION__);
-       else
-               return PLAYER_ERROR_NONE;
+       return PLAYER_ERROR_NONE;
 }
 
 int legacy_player_set_media_stream_dynamic_resolution(player_h player, bool drc)

diff --git a/muse/src/muse_player.c b/muse/src/muse_player.c
index 0133f61..9e8a742 100644 (file)
--- a/muse/src/muse_player.c
+++ b/muse/src/muse_player.c
@@ -914,7 +914,7 @@ static void _error_cb(int code, void *user_data)
        muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_ERROR;
        muse_module_h module = (muse_module_h)user_data;
 
-       LOGD("ENTER");
+       LOGD("ENTER code 0x%X", code);
 
        PLAYER_SEND_EVENT_MSG(api, ev, module, MUSE_TYPE_INT, "code", code);
 }
@@ -993,7 +993,7 @@ static void _set_media_packet_video_frame_cb(player_h player, void *data, bool s
                ret = legacy_player_set_media_packet_video_frame_decoded_cb(player, __video_decoded_callback, module);
        } else {
                muse_player->export_video_data = false;
-               ret = legacy_player_unset_media_packet_video_frame_decoded_cb(player);
+               LOGD("video data will not be exported.");
        }
 
        PLAYER_RETURN_MSG(api, ret, module);

diff --git a/packaging/mmsvc-player.spec b/packaging/mmsvc-player.spec
index 7b6d04a..6324091 100644 (file)
--- a/packaging/mmsvc-player.spec
+++ b/packaging/mmsvc-player.spec
@@ -1,6 +1,6 @@
 Name:       mmsvc-player
 Summary:    A Media Player module for muse server
-Version:    0.2.85
+Version:    0.2.86
 Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0