AC_SUBST(MEDIAPACKET_CFLAGS)
AC_SUBST(MEDIAPACKET_LIBS)
-PKG_CHECK_MODULES(MRP_RESOURCE, murphy-resource)
-AC_SUBST(MRP_RESOURCE_CFLAGS)
-AC_SUBST(MRP_RESOURCE_LIBS)
-
-PKG_CHECK_MODULES(MRP_GLIB, murphy-glib)
-AC_SUBST(MRP_GLIB_CFLAGS)
-AC_SUBST(MRP_GLIB_LIBS)
+PKG_CHECK_MODULES(MM_RESOURCE_MANAGER, mm-resource-manager)
+AC_SUBST(MM_RESOURCE_MANAGER_CFLAGS)
+AC_SUBST(MM_RESOURCE_MANAGER_LIBS)
PKG_CHECK_MODULES(DLOG, dlog)
AC_SUBST(DLOG_CFLAGS)
Name: libmm-player
Summary: Multimedia Framework Player Library
-Version: 0.6.79
+Version: 0.6.80
Release: 0
Group: Multimedia/Libraries
License: Apache-2.0
BuildRequires: pkgconfig(iniparser)
BuildRequires: pkgconfig(icu-i18n)
BuildRequires: pkgconfig(capi-media-tool)
-BuildRequires: pkgconfig(murphy-resource)
-BuildRequires: pkgconfig(murphy-glib)
+BuildRequires: pkgconfig(mm-resource-manager)
BuildRequires: pkgconfig(capi-system-info)
BuildRequires: pkgconfig(storage)
BuildRequires: pkgconfig(libtzplatform-config)
libmmfplayer_la_SOURCES = mm_player.c \
mm_player_priv.c \
mm_player_utils.c \
- mm_player_resource.c \
mm_player_sound_focus.c \
mm_player_capture.c \
mm_player_pd.c \
$(GST_APP_CFLAGS) \
$(MMSESSION_CFLAGS) \
$(MMSOUND_CFLAGS) \
- $(MRP_RESOURCE_CFLAGS) \
- $(MRP_GLIB_CFLAGS) \
+ $(MM_RESOURCE_MANAGER_CFLAGS) \
$(ICU_CFLAGS) \
$(UTILX_CFLAGS) \
$(MEDIAPACKET_CFLAGS) \
$(INIPARSER_LIBS) \
$(MMSESSION_LIBS) \
$(MMSOUND_LIBS) \
- $(MRP_RESOURCE_LIBS) \
- $(MRP_GLIB_LIBS) \
+ $(MM_RESOURCE_MANAGER_LIBS) \
$(ICU_LIBS) \
$(MEDIAPACKET_LIBS) \
$(DLOG_LIBS) \
#include "mm_player_audioeffect.h"
#include "mm_message.h"
#include "mm_player_ini.h"
-#include "mm_player_resource.h"
+#include <mm_resource_manager.h>
#include "mm_player_sound_focus.h"
#include "mm_player_pd.h"
#include "mm_player_streaming.h"
gboolean is_nv12_tiled;
/* resource manager for H/W resources */
- MMPlayerResourceManager resource_manager[RESOURCE_TYPE_MAX];
+ mm_resource_manager_h resource_manager;
+ mm_resource_manager_res_h video_overlay_resource;
+ mm_resource_manager_res_h video_decoder_resource;
+ gboolean interrupted_by_resource;
/* sound focus for being compatible with legacy session policy internally */
MMPlayerSoundFocus sound_focus;
+++ /dev/null
-/*
- * libmm-player
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Heechul Jeon <heechul.jeon@samsung.com>
- * Seungbae Shin <seungbae.shin@samsung.com>, YoungHwan An <younghwan_.an@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef __MM_PLAYER_RESOURCE_H__
-#define __MM_PLAYER_RESOURCE_H__
-
-#include <murphy/plugins/resource-native/libmurphy-resource/resource-api.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define MMPLAYER_RESOURCE_TIMEOUT 5
-
-#define MMPLAYER_GET_RESOURCE_SET_LOCK(rm) (&((MMPlayerResourceManager *)rm)->rset_lock)
-#define MMPLAYER_RESOURCE_SET_LOCK(rm) (g_mutex_lock(MMPLAYER_GET_RESOURCE_SET_LOCK(rm)))
-#define MMPLAYER_RESOURCE_SET_UNLOCK(rm) (g_mutex_unlock(MMPLAYER_GET_RESOURCE_SET_LOCK(rm)))
-
-#define MMPLAYER_GET_RM_LOCK(rm) (&((MMPlayerResourceManager *)rm)->rm_lock)
-#define MMPLAYER_RM_LOCK(rm) (g_mutex_lock(MMPLAYER_GET_RM_LOCK(rm)))
-#define MMPLAYER_RM_UNLOCK(rm) (g_mutex_unlock(MMPLAYER_GET_RM_LOCK(rm)))
-
-#define MMPLAYER_GET_RESOURCE_SET_COND(rm) (&((MMPlayerResourceManager *)rm)->rset_cond)
-#define MMPLAYER_RESOURCE_SET_WAIT(rm) g_cond_wait(MMPLAYER_GET_RESOURCE_SET_COND(rm), MMPLAYER_GET_RESOURCE_SET_LOCK(rm)
-#define MMPLAYER_RESOURCE_SET_WAIT_UNTIL(rm, end_time) \
- g_cond_wait_until(MMPLAYER_GET_RESOURCE_SET_COND(rm), MMPLAYER_GET_RESOURCE_SET_LOCK(rm), end_time)
-#define MMPLAYER_RESOURCE_SET_SIGNAL(rm) g_cond_signal(MMPLAYER_GET_RESOURCE_SET_COND(rm));
-
-typedef enum {
- RESOURCE_TYPE_VIDEO_DECODER,
- RESOURCE_TYPE_VIDEO_OVERLAY,
- RESOURCE_TYPE_MAX,
-} MMPlayerResourceType;
-
-typedef enum {
- RESOURCE_STATE_NONE,
- RESOURCE_STATE_INITIALIZED,
- RESOURCE_STATE_PREPARED,
- RESOURCE_STATE_ACQUIRED,
- RESOURCE_STATE_MAX,
-} MMPlayerResourceState;
-
-typedef struct {
- mrp_mainloop_t *mloop;
- mrp_res_context_t *context;
- mrp_res_resource_set_t *rset;
- MMPlayerResourceState state;
- bool is_connected;
- void *user_data;
- bool by_rm_cb;
- GCond rset_cond;
- GMutex rset_lock;
- GMutex rm_lock;
-} MMPlayerResourceManager;
-
-int _mmplayer_resource_manager_init(MMPlayerResourceManager *resource_manager, void *user_data);
-int _mmplayer_resource_manager_prepare(MMPlayerResourceManager *resource_manager, MMPlayerResourceType resource_type);
-int _mmplayer_resource_manager_acquire(MMPlayerResourceManager *resource_manager);
-int _mmplayer_resource_manager_release(MMPlayerResourceManager *resource_manager);
-int _mmplayer_resource_manager_unprepare(MMPlayerResourceManager *resource_manager);
-int _mmplayer_resource_manager_deinit(MMPlayerResourceManager *resource_manager);
-int _mmplayer_resource_manager_get_state(MMPlayerResourceManager *resource_manager, MMPlayerResourceState *state);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __MM_PLAYER_RESOURCE_H__ */
static void __mmplayer_audio_stream_send_data(mm_player_t* player, mm_player_audio_stream_buff_t *a_buffer);
static void __mmplayer_initialize_storage_info(mm_player_t* player, MMPlayerPathType path_type);
static void __mmplayer_get_metadata_360_from_tags(GstTagList *tags, mm_player_spherical_metadata_t *metadata);
+static int __resource_release_cb(mm_resource_manager_h rm, mm_resource_manager_res_h res, void *user_data);
/*===========================================================================================
| |
int sound_result = MM_ERROR_NONE;
gboolean post_bos = FALSE;
gboolean interrupted_by_focus = FALSE;
- gboolean interrupted_by_resource = FALSE;
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
/* do some FSM stuffs before posting new state to application */
interrupted_by_focus = player->sound_focus.by_asm_cb;
- interrupted_by_resource = (player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY].by_rm_cb ||
- player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER].by_rm_cb);
switch (MMPLAYER_CURRENT_STATE(player)) {
case MM_PLAYER_STATE_NULL:
LOGD("player reach the target state (%s)", MMPLAYER_STATE_GET_NAME(MMPLAYER_TARGET_STATE(player)));
/* state changed by focus or resource callback */
- if (interrupted_by_focus || interrupted_by_resource) {
+ if (interrupted_by_focus || player->interrupted_by_resource) {
if (interrupted_by_focus)
msg.state.code = player->sound_focus.focus_changed_msg;
- else if (interrupted_by_resource)
+ else if (player->interrupted_by_resource)
msg.state.code = MM_PLAYER_FOCUS_CHANGED_BY_RESOURCE_CONFLICT;
MMPLAYER_POST_MSG(player, MM_MESSAGE_STATE_INTERRUPTED, &msg);
} else { /* state changed by usecase */
GstElement* sinkbin = NULL;
gboolean reusing = FALSE;
GstElement *text_selector = NULL;
- MMPlayerResourceState resource_state = RESOURCE_STATE_NONE;
/* check handles */
player = (mm_player_t*) data;
}
if (surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
- if (_mmplayer_resource_manager_get_state(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY], &resource_state) == MM_ERROR_NONE) {
- /* prepare resource manager for video overlay */
- if (resource_state >= RESOURCE_STATE_INITIALIZED) {
- if (_mmplayer_resource_manager_prepare(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY], RESOURCE_TYPE_VIDEO_OVERLAY)
- != MM_ERROR_NONE) {
- LOGE("could not prepare for video_overlay resource\n");
- goto ERROR;
- }
+ /* mark video overlay for acquire */
+ if (player->video_overlay_resource == NULL) {
+ if (mm_resource_manager_mark_for_acquire(player->resource_manager,
+ MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_OVERLAY,
+ MM_RESOURCE_MANAGER_RES_VOLUME_FULL,
+ &player->video_overlay_resource)
+ != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ LOGE("could not mark video_overlay resource for acquire\n");
+ goto ERROR;
}
}
}
- if (_mmplayer_resource_manager_get_state(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY], &resource_state) == MM_ERROR_NONE) {
- /* acquire resources for video overlay */
- if (resource_state == RESOURCE_STATE_PREPARED) {
- if (_mmplayer_resource_manager_acquire(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY]) != MM_ERROR_NONE) {
- LOGE("could not acquire resources for video playing\n");
- _mmplayer_resource_manager_unprepare(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY]);
- goto ERROR;
- }
- }
+ player->interrupted_by_resource = FALSE;
+ /* acquire resources for video overlay */
+ if (mm_resource_manager_commit(player->resource_manager) !=
+ MM_RESOURCE_MANAGER_ERROR_NONE) {
+ LOGE("could not acquire resources for video playing\n");
+ goto ERROR;
}
if (MM_ERROR_NONE != __mmplayer_gst_create_video_pipeline(player, caps, surface_type)) {
{
gboolean disable_overlay = FALSE;
mm_player_t* player = (mm_player_t*) hplayer;
- MMPlayerResourceState resource_state = RESOURCE_STATE_NONE;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "disable-overlay", TRUE, NULL);
/* release overlay resource */
- if (_mmplayer_resource_manager_get_state(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY], &resource_state) == MM_ERROR_NONE) {
- if (resource_state >= RESOURCE_STATE_ACQUIRED) {
- ret = _mmplayer_resource_manager_release(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY]);
- if (ret != MM_ERROR_NONE) {
- LOGE("failed to release overlay resource, ret(0x%x)\n", ret);
- goto ERROR;
- }
+ if (player->video_overlay_resource != NULL) {
+ ret = mm_resource_manager_mark_for_release(player->resource_manager,
+ player->video_overlay_resource);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ LOGE("failed to mark overlay resource for release, ret(0x%x)\n", ret);
+ goto ERROR;
}
+ player->video_overlay_resource = NULL;
}
- if (_mmplayer_resource_manager_get_state(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY], &resource_state) == MM_ERROR_NONE) {
- if (resource_state == RESOURCE_STATE_PREPARED) {
- ret = _mmplayer_resource_manager_unprepare(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY]);
- if (ret != MM_ERROR_NONE) {
- LOGE("failed to unprepare overlay resource, ret(0x%x)\n", ret);
- goto ERROR;
- }
- }
+ ret = mm_resource_manager_commit(player->resource_manager);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ LOGE("failed to commit acquiring of overlay resource, ret(0x%x)\n", ret);
+ goto ERROR;
}
} else {
- if (_mmplayer_resource_manager_get_state(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY], &resource_state) == MM_ERROR_NONE) {
- /* prepare resource manager for video overlay */
- if (resource_state >= RESOURCE_STATE_INITIALIZED) {
- ret = _mmplayer_resource_manager_prepare(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY], RESOURCE_TYPE_VIDEO_OVERLAY);
- if (ret != MM_ERROR_NONE) {
- LOGE("could not prepare for video_overlay resource\n");
- goto ERROR;
- }
+ /* mark video overlay for acquire */
+ if (player->video_overlay_resource == NULL) {
+ ret = mm_resource_manager_mark_for_acquire(player->resource_manager,
+ MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_OVERLAY,
+ MM_RESOURCE_MANAGER_RES_VOLUME_FULL,
+ &player->video_overlay_resource);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ LOGE("could not prepare for video_overlay resource\n");
+ goto ERROR;
}
}
- if (_mmplayer_resource_manager_get_state(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY], &resource_state) == MM_ERROR_NONE) {
- /* acquire resources for video overlay */
- if (resource_state == RESOURCE_STATE_PREPARED) {
- ret = _mmplayer_resource_manager_acquire(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY]);
- if (ret != MM_ERROR_NONE) {
- LOGE("could not acquire resources for video playing\n");
- _mmplayer_resource_manager_unprepare(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY]);
- goto ERROR;
- }
- }
+ player->interrupted_by_resource = FALSE;
+ /* acquire resources for video overlay */
+ ret = mm_resource_manager_commit(player->resource_manager);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ LOGE("could not acquire resources for video playing\n");
+ goto ERROR;
}
LOGD("enable overlay");
return TRUE;
}
+static int
+__resource_release_cb(mm_resource_manager_h rm, mm_resource_manager_res_h res,
+ void *user_data)
+{
+ mm_player_t *player = NULL;
+
+ MMPLAYER_FENTER();
+
+ if (user_data == NULL) {
+ LOGE("- user_data is null\n");
+ return FALSE;
+ }
+ player = (mm_player_t *)user_data;
+
+ /* do something to release resource here.
+ * player stop and interrupt forwarding */
+ if (!__mmplayer_can_do_interrupt(player)) {
+ LOGW("no need to interrupt, so leave");
+ } else {
+ MMMessageParamType msg = {0, };
+ unsigned long pos = 0;
+
+ player->interrupted_by_resource = TRUE;
+
+ /* get last play position */
+ if (_mmplayer_get_position((MMHandleType)player, MM_PLAYER_POS_FORMAT_TIME, &pos) != MM_ERROR_NONE) {
+ LOGW("failed to get play position.");
+ } else {
+ msg.union_type = MM_MSG_UNION_TIME;
+ msg.time.elapsed = (unsigned int)pos;
+ MMPLAYER_POST_MSG(player, MM_MESSAGE_PLAY_POSITION, &msg);
+ }
+ LOGD("video resource conflict so, resource will be freed by unrealizing");
+ if (_mmplayer_unrealize((MMHandleType)player))
+ LOGW("failed to unrealize");
+
+ /* lock is called in __mmplayer_can_do_interrupt() */
+ MMPLAYER_CMD_UNLOCK(player);
+ }
+
+ if (res == player->video_overlay_resource)
+ player->video_overlay_resource = FALSE;
+ else
+ player->video_decoder_resource = FALSE;
+
+ MMPLAYER_FLEAVE();
+
+ return FALSE;
+}
+
/* if you want to enable USE_ASM, please check the history get the ASM cb code. */
static int
__mmplayer_convert_sound_focus_state(gboolean acquire, const char *reason_for_change, MMPlayerFocusChangedMsg *msg)
}
/* initialize resource manager */
- if (MM_ERROR_NONE != _mmplayer_resource_manager_init(&player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER], player)) {
- LOGE("failed to initialize resource manager\n");
- goto ERROR;
- }
-
- if (MM_ERROR_NONE != _mmplayer_resource_manager_init(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY], player)) {
+ if (MM_RESOURCE_MANAGER_ERROR_NONE != mm_resource_manager_create(
+ MM_RESOURCE_MANAGER_APP_CLASS_MEDIA, __resource_release_cb, player,
+ &player->resource_manager)) {
LOGE("failed to initialize resource manager\n");
goto ERROR;
}
LOGE("failed to deregister asm server\n");
/* de-initialize resource manager */
- if (MM_ERROR_NONE != _mmplayer_resource_manager_deinit(&player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER]))
- LOGE("failed to deinitialize resource manager\n");
-
- if (MM_ERROR_NONE != _mmplayer_resource_manager_deinit(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY]))
+ if (MM_RESOURCE_MANAGER_ERROR_NONE != mm_resource_manager_destroy(
+ player->resource_manager))
LOGE("failed to deinitialize resource manager\n");
if (player->resume_event_id) {
_mmplayer_unrealize(MMHandleType hplayer)
{
mm_player_t* player = (mm_player_t*)hplayer;
- MMPlayerResourceState resource_state = RESOURCE_STATE_NONE;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
if (ret != MM_ERROR_NONE)
LOGE("failed to release sound focus, ret(0x%x)\n", ret);
- if (!player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER].by_rm_cb && /* is being released */
- !player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY].by_rm_cb &&
- _mmplayer_resource_manager_get_state(&player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER], &resource_state) == MM_ERROR_NONE) {
- if (resource_state >= RESOURCE_STATE_ACQUIRED) {
- ret = _mmplayer_resource_manager_release(&player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER]);
- if (ret != MM_ERROR_NONE)
- LOGE("failed to release decoder resource, ret(0x%x)\n", ret);
- }
- }
-
- if (!player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER].by_rm_cb && /* is being released */
- !player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY].by_rm_cb &&
- _mmplayer_resource_manager_get_state(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY], &resource_state) == MM_ERROR_NONE) {
- if (resource_state >= RESOURCE_STATE_ACQUIRED) {
- ret = _mmplayer_resource_manager_release(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY]);
- if (ret != MM_ERROR_NONE)
- LOGE("failed to release overlay resource, ret(0x%x)\n", ret);
+ if (!player->interrupted_by_resource) {
+ if (player->video_decoder_resource != NULL) {
+ ret = mm_resource_manager_mark_for_release(player->resource_manager,
+ player->video_decoder_resource);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE)
+ LOGE("failed to mark decoder resource for release, ret(0x%x)\n", ret);
+ else
+ player->video_decoder_resource = NULL;
}
- }
- if (_mmplayer_resource_manager_get_state(&player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER], &resource_state) == MM_ERROR_NONE) {
- if (resource_state == RESOURCE_STATE_PREPARED) {
- ret = _mmplayer_resource_manager_unprepare(&player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER]);
- if (ret != MM_ERROR_NONE)
- LOGE("failed to unprepare decoder resource, ret(0x%x)\n", ret);
+ if (player->video_overlay_resource != NULL) {
+ ret = mm_resource_manager_mark_for_release(player->resource_manager,
+ player->video_overlay_resource);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE)
+ LOGE("failed to mark overlay resource for release, ret(0x%x)\n", ret);
+ else
+ player->video_overlay_resource = NULL;
}
- }
-
- if (_mmplayer_resource_manager_get_state(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY], &resource_state) == MM_ERROR_NONE) {
- if (resource_state == RESOURCE_STATE_PREPARED) {
- ret = _mmplayer_resource_manager_unprepare(&player->resource_manager[RESOURCE_TYPE_VIDEO_OVERLAY]);
- if (ret != MM_ERROR_NONE)
- LOGE("failed to unprepare overlay resource, ret(0x%x)\n", ret);
- }
+ ret = mm_resource_manager_commit(player->resource_manager);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE)
+ LOGE("failed to commit resource releases, ret(0x%x)\n", ret);
}
} else
LOGE("failed and don't change asm state to stop");
} else if (g_strrstr(klass, "Codec/Decoder/Video")) {
if ((strlen(player->ini.videocodec_element_hw) > 0) &&
(g_strrstr(factory_name, player->ini.videocodec_element_hw))) {
- /* prepare resource manager for video decoder */
- MMPlayerResourceState resource_state = RESOURCE_STATE_NONE;
-
- if (_mmplayer_resource_manager_get_state(&player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER], &resource_state) == MM_ERROR_NONE) {
- /* prepare resource manager for video decoder */
- if ((resource_state >= RESOURCE_STATE_INITIALIZED) && (resource_state < RESOURCE_STATE_ACQUIRED)) {
- if (_mmplayer_resource_manager_prepare(&player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER], RESOURCE_TYPE_VIDEO_DECODER)
- != MM_ERROR_NONE) {
- LOGW("could not prepare for video_decoder resource, skip it.");
- result = GST_AUTOPLUG_SELECT_SKIP;
- goto DONE;
- }
+
+ /* mark video decoder for acquire */
+ if (player->video_decoder_resource == NULL) {
+ if (mm_resource_manager_mark_for_acquire(player->resource_manager,
+ MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_DECODER,
+ MM_RESOURCE_MANAGER_RES_VOLUME_FULL,
+ &player->video_decoder_resource)
+ != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ LOGE("could not mark video_decoder resource for acquire");
+ goto DONE;
}
+ } else {
+ LOGW("video decoder resource is already acquired, skip it.");
+ result = GST_AUTOPLUG_SELECT_SKIP;
+ goto DONE;
}
- if (_mmplayer_resource_manager_get_state(&player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER], &resource_state)
- == MM_ERROR_NONE) {
- /* acquire resources for video playing */
- if (resource_state == RESOURCE_STATE_PREPARED) {
- if (_mmplayer_resource_manager_acquire(&player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER])
- != MM_ERROR_NONE) {
- LOGE("could not acquire resources for video decoding\n");
- _mmplayer_resource_manager_unprepare(&player->resource_manager[RESOURCE_TYPE_VIDEO_DECODER]);
- goto DONE;
- }
- }
+ player->interrupted_by_resource = FALSE;
+ /* acquire resources for video playing */
+ if (mm_resource_manager_commit(player->resource_manager)
+ != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ LOGE("could not acquire resources for video decoding\n");
+ goto DONE;
}
}
}
+++ /dev/null
-/*
- * libmm-player
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, YeJin Cho <cho.yejin@samsung.com>,
- * Seungbae Shin <seungbae.shin@samsung.com>, YoungHwan An <younghwan_.an@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include "mm_player_utils.h"
-#include "mm_player_resource.h"
-#include "mm_player_priv.h"
-#include <murphy/common/glib-glue.h>
-
-#define MRP_APP_CLASS_FOR_PLAYER "media"
-#define MRP_RESOURCE_TYPE_MANDATORY TRUE
-#define MRP_RESOURCE_TYPE_EXCLUSIVE FALSE
-
-enum {
- MRP_RESOURCE_FOR_VIDEO_OVERLAY,
- MRP_RESOURCE_FOR_VIDEO_DECODER,
- MRP_RESOURCE_MAX,
-};
-const char* resource_str[MRP_RESOURCE_MAX] = {
- "video_overlay",
- "video_decoder",
-};
-
-#define MMPLAYER_CHECK_RESOURCE_MANAGER_INSTANCE(x_player_resource_manager) \
-do { \
- if (!x_player_resource_manager) { \
- LOGE("no resource manager instance");\
- return MM_ERROR_INVALID_ARGUMENT; \
- } \
-} while (0);
-
-#define MMPLAYER_CHECK_CONNECTION_RESOURCE_MANAGER(x_player_resource_manager) \
-do { \
- if (!x_player_resource_manager) { \
- LOGE("no resource manager instance");\
- return MM_ERROR_INVALID_ARGUMENT; \
- } else { \
- if (!x_player_resource_manager->is_connected) { \
- LOGE("not connected to resource server yet"); \
- return MM_ERROR_RESOURCE_NOT_INITIALIZED; \
- } \
- } \
-} while (0);
-
-static char *state_to_str(mrp_res_resource_state_t st)
-{
- char *state = "unknown";
- switch (st) {
- case MRP_RES_RESOURCE_ACQUIRED:
- state = "acquired";
- break;
- case MRP_RES_RESOURCE_LOST:
- state = "lost";
- break;
- case MRP_RES_RESOURCE_AVAILABLE:
- state = "available";
- break;
- case MRP_RES_RESOURCE_PENDING:
- state = "pending";
- break;
- case MRP_RES_RESOURCE_ABOUT_TO_LOOSE:
- state = "about to loose";
- break;
- }
- return state;
-}
-
-static void mrp_state_callback(mrp_res_context_t *context, mrp_res_error_t err, void *user_data)
-{
- int i = 0;
- const mrp_res_resource_set_t *rset = NULL;
- mrp_res_resource_t *resource = NULL;
- MMPlayerResourceManager *resource_manager = NULL;
-
- MMPLAYER_FENTER();
-
- if (user_data == NULL) {
- LOGE(" - user data is null\n");
- return;
- }
- resource_manager = (MMPlayerResourceManager *)user_data;
- if (err != MRP_RES_ERROR_NONE) {
- LOGE(" - error message received from Murphy, for the rm(%p), err(0x%x)\n", resource_manager, err);
- return;
- }
-
- switch (context->state) {
- case MRP_RES_CONNECTED:
- LOGD(" - connected to Murphy\n");
- if ((rset = mrp_res_list_resources(context)) != NULL) {
- mrp_res_string_array_t *resource_names;
- resource_names = mrp_res_list_resource_names(rset);
- if (!resource_names) {
- LOGE(" - no resources available\n");
- return;
- }
- for (i = 0; i < resource_names->num_strings; i++) {
- resource = mrp_res_get_resource_by_name(rset, resource_names->strings[i]);
- if (resource)
- LOGD(" - available resource: %s", resource->name);
- }
- mrp_res_free_string_array(resource_names);
- }
- resource_manager->is_connected = TRUE;
- break;
- case MRP_RES_DISCONNECTED:
- LOGD(" - disconnected from Murphy\n");
- if (resource_manager->rset) {
- mrp_res_delete_resource_set(resource_manager->rset);
- resource_manager->rset = NULL;
- }
- mrp_res_destroy(resource_manager->context);
- resource_manager->context = NULL;
- resource_manager->is_connected = FALSE;
- break;
- }
-
- MMPLAYER_FLEAVE();
-
- return;
-}
-
-static void mrp_rset_state_callback(mrp_res_context_t *cx, const mrp_res_resource_set_t *rs, void *user_data)
-{
- int i = 0;
- mrp_res_resource_t *res;
- MMPlayerResourceManager *resource_manager = (MMPlayerResourceManager *)user_data;
-
- MMPLAYER_FENTER();
-
- MMPLAYER_RESOURCE_SET_LOCK(resource_manager);
-
- if (!mrp_res_equal_resource_set(rs, resource_manager->rset)) {
- LOGW("- resource set(%p) is not same as this player handle's rset(%p)", rs, resource_manager->rset);
- MMPLAYER_RESOURCE_SET_UNLOCK(resource_manager);
- return;
- }
-
- LOGD(" - resource set state of rm(%p) is changed to [%s]\n", resource_manager, state_to_str(rs->state));
- for (i = 0; i < MRP_RESOURCE_MAX; i++) {
- res = mrp_res_get_resource_by_name(rs, resource_str[i]);
- if (res == NULL)
- LOGW(" -- %s not present in resource set\n", resource_str[i]);
- else
- LOGD(" -- resource name [%s] -> [%s]'\n", res->name, state_to_str(res->state));
- }
-
- mrp_res_delete_resource_set(resource_manager->rset);
- resource_manager->rset = mrp_res_copy_resource_set(rs);
-
- if (rs->state == MRP_RES_RESOURCE_ACQUIRED) {
- LOGD(" - resource set is acquired");
- resource_manager->state = RESOURCE_STATE_ACQUIRED;
- MMPLAYER_RESOURCE_SET_SIGNAL(resource_manager);
- } else if ((resource_manager->state >= RESOURCE_STATE_ACQUIRED) &&
- (rs->state == MRP_RES_RESOURCE_AVAILABLE)) {
- LOGD(" - resource set is released");
- resource_manager->state = RESOURCE_STATE_PREPARED;
- MMPLAYER_RESOURCE_SET_SIGNAL(resource_manager);
-
- /* mm player was unrealized by resource conflict. */
- if (resource_manager->by_rm_cb == TRUE) {
- LOGD(" - delete resource set ");
- if (resource_manager->rset) {
- mrp_res_delete_resource_set(resource_manager->rset);
- resource_manager->rset = NULL;
- }
- resource_manager->state = RESOURCE_STATE_INITIALIZED;
- resource_manager->by_rm_cb = FALSE;
- }
- }
-
- MMPLAYER_RESOURCE_SET_UNLOCK(resource_manager);
-
- MMPLAYER_FLEAVE();
-}
-
-
-static void mrp_resource_release_cb(mrp_res_context_t *cx, const mrp_res_resource_set_t *rs, void *user_data)
-{
- int i = 0;
- int result = MM_ERROR_NONE;
- mm_player_t *player = NULL;
- MMPlayerResourceManager *resource_manager = NULL;
- mrp_res_resource_t *res = NULL;
- gboolean resource_released = FALSE;
-
- MMPLAYER_FENTER();
-
- if (user_data == NULL) {
- LOGE("- user_data is null\n");
- return;
- }
- resource_manager = (MMPlayerResourceManager *)user_data;
- player = (mm_player_t *)resource_manager->user_data;
-
- if (!mrp_res_equal_resource_set(rs, resource_manager->rset)) {
- LOGW("- resource set(%p) is not same as this player handle's(%p)", rs, resource_manager->rset);
- return;
- }
-
- LOGD(" - resource set state of rm(%p) is changed to [%s]\n", resource_manager, state_to_str(rs->state));
- for (i = 0; i < MRP_RESOURCE_MAX; i++) {
- res = mrp_res_get_resource_by_name(rs, resource_str[i]);
- if (res == NULL) {
- LOGW(" -- %s not present in resource set\n", resource_str[i]);
- } else {
- LOGD(" -- resource name [%s] -> [%s]'\n", res->name, state_to_str(res->state));
- if (res->state == MRP_RES_RESOURCE_ABOUT_TO_LOOSE)
- resource_released = TRUE;
- }
- }
-
- /* do something to release resource here.
- * player stop and interrupt forwarding */
- if (!__mmplayer_can_do_interrupt(player)) {
- LOGW("no need to interrupt, so leave");
- } else {
- if (resource_released) {
- MMMessageParamType msg = {0, };
- unsigned long pos = 0;
-
- resource_manager->by_rm_cb = TRUE; /* will be reset in state cb */
-
- /* get last play position */
- if (_mmplayer_get_position((MMHandleType)player, MM_PLAYER_POS_FORMAT_TIME, &pos) != MM_ERROR_NONE) {
- LOGW("failed to get play position.");
- } else {
- msg.union_type = MM_MSG_UNION_TIME;
- msg.time.elapsed = (unsigned int)pos;
- MMPLAYER_POST_MSG(player, MM_MESSAGE_PLAY_POSITION, &msg);
- }
- LOGD("video resource conflict so, resource will be freed by unrealizing");
- result = _mmplayer_unrealize((MMHandleType)player);
- if (result)
- LOGW("failed to unrealize");
- } else {
- LOGW("could not find videobin");
- }
-
- /* lock is called in __mmplayer_can_do_interrupt() */
- MMPLAYER_CMD_UNLOCK(player);
- }
-
- MMPLAYER_FLEAVE();
-
- return;
-}
-
-static int create_rset(MMPlayerResourceManager *resource_manager)
-{
- if (resource_manager->rset) {
- LOGE(" - resource set was already created\n");
- return MM_ERROR_RESOURCE_INVALID_STATE;
- }
-
- resource_manager->rset = mrp_res_create_resource_set(resource_manager->context,
- MRP_APP_CLASS_FOR_PLAYER,
- mrp_rset_state_callback,
- (void*)resource_manager);
- if (resource_manager->rset == NULL) {
- LOGE(" - could not create resource set\n");
- return MM_ERROR_RESOURCE_INTERNAL;
- }
-
- if (!mrp_res_set_autorelease(TRUE, resource_manager->rset))
- LOGW(" - could not set autorelease flag!\n");
-
- return MM_ERROR_NONE;
-}
-
-static int include_resource(MMPlayerResourceManager *resource_manager, const char *resource_name)
-{
- mrp_res_resource_t *resource = NULL;
- resource = mrp_res_create_resource(resource_manager->rset,
- resource_name,
- MRP_RESOURCE_TYPE_MANDATORY,
- MRP_RESOURCE_TYPE_EXCLUSIVE);
- if (resource == NULL) {
- LOGE(" - could not include resource[%s]\n", resource_name);
- return MM_ERROR_RESOURCE_INTERNAL;
- }
-
- LOGD(" - include resource[%s]\n", resource_name);
-
- return MM_ERROR_NONE;
-}
-
-static int set_resource_release_cb(MMPlayerResourceManager *resource_manager)
-{
- int ret = MM_ERROR_NONE;
- bool mrp_ret = FALSE;
-
- if (resource_manager->rset) {
- mrp_ret = mrp_res_set_release_callback(resource_manager->rset, mrp_resource_release_cb, resource_manager);
- if (!mrp_ret) {
- LOGE(" - could not set release callback\n");
- ret = MM_ERROR_RESOURCE_INTERNAL;
- }
- } else {
- LOGE(" - resource set is null\n");
- ret = MM_ERROR_RESOURCE_INVALID_STATE;
- }
-
- return ret;
-}
-
-int _mmplayer_resource_manager_init(MMPlayerResourceManager *resource_manager, void *user_data)
-{
- MMPLAYER_FENTER();
- MMPLAYER_CHECK_RESOURCE_MANAGER_INSTANCE(resource_manager);
-
- GMainContext *mrp_ctx = g_main_context_new();
- if (!mrp_ctx) {
- LOGE("- could not create main context for resource manager\n");
- return MM_ERROR_RESOURCE_INTERNAL;
- }
-
- GMainLoop *mrp_loop = g_main_loop_new(mrp_ctx, TRUE);
- g_main_context_unref(mrp_ctx);
- if (!mrp_loop) {
- LOGE("- could not create glib mainloop for resource manager\n");
- return MM_ERROR_RESOURCE_INTERNAL;
- }
-
- resource_manager->mloop = mrp_mainloop_glib_get(mrp_loop);
- g_main_loop_unref(mrp_loop);
- if (resource_manager->mloop) {
- resource_manager->context = mrp_res_create(resource_manager->mloop, mrp_state_callback, resource_manager);
- if (resource_manager->context == NULL) {
- LOGE(" - could not get context for resource manager\n");
- mrp_mainloop_destroy(resource_manager->mloop);
- resource_manager->mloop = NULL;
- return MM_ERROR_RESOURCE_INTERNAL;
- }
- resource_manager->user_data = user_data;
- } else {
- LOGE("- could not get mainloop for resource manager\n");
- return MM_ERROR_RESOURCE_INTERNAL;
- }
-
- resource_manager->state = RESOURCE_STATE_INITIALIZED;
- g_mutex_init(&resource_manager->rset_lock);
- g_cond_init(&resource_manager->rset_cond);
- g_mutex_init(&resource_manager->rm_lock);
-
- MMPLAYER_FLEAVE();
-
- return MM_ERROR_NONE;
-}
-
-int _mmplayer_resource_manager_prepare(MMPlayerResourceManager *resource_manager, MMPlayerResourceType resource_type)
-{
- int ret = MM_ERROR_NONE;
- MMPLAYER_FENTER();
- MMPLAYER_CHECK_RESOURCE_MANAGER_INSTANCE(resource_manager);
- MMPLAYER_CHECK_CONNECTION_RESOURCE_MANAGER(resource_manager);
-
- if (!resource_manager->rset)
- ret = create_rset(resource_manager);
-
- if (ret == MM_ERROR_NONE) {
- switch (resource_type) {
- case RESOURCE_TYPE_VIDEO_OVERLAY:
- ret = include_resource(resource_manager, resource_str[MRP_RESOURCE_FOR_VIDEO_OVERLAY]);
- break;
- case RESOURCE_TYPE_VIDEO_DECODER:
- ret = include_resource(resource_manager, resource_str[MRP_RESOURCE_FOR_VIDEO_DECODER]);
- break;
- default:
- LOGE("unknown resource type %d", resource_type);
- return MM_ERROR_INVALID_ARGUMENT;
- }
- }
-
- resource_manager->state = RESOURCE_STATE_PREPARED;
-
- MMPLAYER_FLEAVE();
-
- return ret;
-}
-
-int _mmplayer_resource_manager_acquire(MMPlayerResourceManager *resource_manager)
-{
- int ret = MM_ERROR_NONE;
- MMPLAYER_FENTER();
- MMPLAYER_CHECK_RESOURCE_MANAGER_INSTANCE(resource_manager);
- MMPLAYER_CHECK_CONNECTION_RESOURCE_MANAGER(resource_manager);
-
- MMPLAYER_RM_LOCK(resource_manager);
-
- if (resource_manager->rset == NULL) {
- LOGE("- could not acquire resource, resource set is null\n");
- ret = MM_ERROR_RESOURCE_INVALID_STATE;
- } else {
- ret = set_resource_release_cb(resource_manager);
- if (ret) {
- LOGE("- could not set resource release cb, ret(%d)\n", ret);
- ret = MM_ERROR_RESOURCE_INTERNAL;
- } else {
- MMPLAYER_RESOURCE_SET_LOCK(resource_manager);
-
- ret = mrp_res_acquire_resource_set(resource_manager->rset);
- if (ret) {
- LOGE("- could not acquire resource, ret(%d)\n", ret);
- ret = MM_ERROR_RESOURCE_INTERNAL;
- } else {
- gint64 end_time = g_get_monotonic_time() + MMPLAYER_RESOURCE_TIMEOUT*G_TIME_SPAN_SECOND;
-
- LOGD("- acquire resource waiting..%p till %lld\n", resource_manager, end_time);
- if (!MMPLAYER_RESOURCE_SET_WAIT_UNTIL(resource_manager, end_time)) {
- LOGE("- could not acquire resource\n");
- ret = MM_ERROR_RESOURCE_INTERNAL;
- } else {
- LOGD("- resources are acquired\n");
- }
- }
- MMPLAYER_RESOURCE_SET_UNLOCK(resource_manager);
- }
- }
-
- MMPLAYER_RM_UNLOCK(resource_manager);
- MMPLAYER_FLEAVE();
-
- return ret;
-}
-
-int _mmplayer_resource_manager_release(MMPlayerResourceManager *resource_manager)
-{
- int ret = MM_ERROR_NONE;
- MMPLAYER_FENTER();
- MMPLAYER_CHECK_RESOURCE_MANAGER_INSTANCE(resource_manager);
- MMPLAYER_CHECK_CONNECTION_RESOURCE_MANAGER(resource_manager);
-
- MMPLAYER_RM_LOCK(resource_manager);
-
- if (resource_manager->rset == NULL) {
- LOGE("- could not release resource, resource set is null\n");
- ret = MM_ERROR_RESOURCE_INVALID_STATE;
- } else {
- if (resource_manager->rset->state != MRP_RES_RESOURCE_ACQUIRED) {
- LOGE("- could not release resource, resource set state is [%s]\n", state_to_str(resource_manager->rset->state));
- ret = MM_ERROR_RESOURCE_INVALID_STATE;
- } else {
- MMPLAYER_RESOURCE_SET_LOCK(resource_manager);
- ret = mrp_res_release_resource_set(resource_manager->rset);
- if (ret) {
- LOGE("- could not release resource, ret(%d)\n", ret);
- ret = MM_ERROR_RESOURCE_INTERNAL;
- } else {
- gint64 end_time = g_get_monotonic_time() + MMPLAYER_RESOURCE_TIMEOUT*G_TIME_SPAN_SECOND;
-
- LOGD("- release resource waiting..%p till %lld\n", resource_manager, end_time);
- if (!MMPLAYER_RESOURCE_SET_WAIT_UNTIL(resource_manager, end_time)) {
- LOGW("- could not release resource in time\n");
- /* ret = MM_ERROR_RESOURCE_INTERNAL */
- } else {
- LOGD("- resources are released\n");
- }
- }
- MMPLAYER_RESOURCE_SET_UNLOCK(resource_manager);
- }
- }
-
- MMPLAYER_RM_UNLOCK(resource_manager);
- MMPLAYER_FLEAVE();
-
- return ret;
-}
-
-int _mmplayer_resource_manager_unprepare(MMPlayerResourceManager *resource_manager)
-{
- int ret = MM_ERROR_NONE;
- MMPLAYER_FENTER();
- MMPLAYER_CHECK_RESOURCE_MANAGER_INSTANCE(resource_manager);
- MMPLAYER_CHECK_CONNECTION_RESOURCE_MANAGER(resource_manager);
-
- MMPLAYER_RM_LOCK(resource_manager);
-
- if (resource_manager->rset == NULL) {
- LOGE("- could not unprepare for resource_manager, _mmplayer_resource_manager_prepare() first\n");
- ret = MM_ERROR_RESOURCE_INVALID_STATE;
- } else {
- MMPLAYER_RESOURCE_SET_LOCK(resource_manager);
- mrp_res_delete_resource_set(resource_manager->rset);
- resource_manager->rset = NULL;
- MMPLAYER_RESOURCE_SET_UNLOCK(resource_manager);
- }
-
- resource_manager->state = RESOURCE_STATE_INITIALIZED;
-
- MMPLAYER_RM_UNLOCK(resource_manager);
- MMPLAYER_FLEAVE();
-
- return ret;
-}
-
-int _mmplayer_resource_manager_deinit(MMPlayerResourceManager *resource_manager)
-{
- MMPLAYER_FENTER();
- MMPLAYER_CHECK_RESOURCE_MANAGER_INSTANCE(resource_manager);
- MMPLAYER_CHECK_CONNECTION_RESOURCE_MANAGER(resource_manager);
-
- MMPLAYER_RM_LOCK(resource_manager);
-
- MMPLAYER_RESOURCE_SET_LOCK(resource_manager);
- if (resource_manager->rset) {
- if (resource_manager->rset->state == MRP_RES_RESOURCE_ACQUIRED) {
- if (mrp_res_release_resource_set(resource_manager->rset))
- LOGE("- could not release resource\n");
- }
- mrp_res_delete_resource_set(resource_manager->rset);
- resource_manager->rset = NULL;
- }
- MMPLAYER_RESOURCE_SET_UNLOCK(resource_manager);
-
- if (resource_manager->context) {
- mrp_res_destroy(resource_manager->context);
- resource_manager->context = NULL;
- }
-
- if (resource_manager->mloop) {
- mrp_mainloop_quit(resource_manager->mloop, 0);
- mrp_mainloop_destroy(resource_manager->mloop);
- resource_manager->mloop = NULL;
- }
-
- resource_manager->state = RESOURCE_STATE_NONE;
- g_mutex_clear(&resource_manager->rset_lock);
- g_cond_clear(&resource_manager->rset_cond);
-
- MMPLAYER_RM_UNLOCK(resource_manager);
- g_mutex_clear(&resource_manager->rm_lock);
-
- MMPLAYER_FLEAVE();
-
- return MM_ERROR_NONE;
-}
-
-int _mmplayer_resource_manager_get_state(MMPlayerResourceManager *resource_manager, MMPlayerResourceState *state)
-{
-
- MMPLAYER_FENTER();
- MMPLAYER_CHECK_RESOURCE_MANAGER_INSTANCE(resource_manager);
- MMPLAYER_RETURN_VAL_IF_FAIL(state, MM_ERROR_INVALID_ARGUMENT);
-
- MMPLAYER_RM_LOCK(resource_manager);
- LOGD("resource_state is %d", resource_manager->state);
-
- *state = resource_manager->state;
-
- MMPLAYER_RM_UNLOCK(resource_manager);
- MMPLAYER_FLEAVE();
-
- return MM_ERROR_NONE;
-}
-
projects / platform / core / multimedia / libmm-player.git / commitdiff