#define MIN_BUFFERING_TIME_MS 0 /* use platform default value */
-#define __RELEASEIF_PREPARE_THREAD(thread_id) \
+#define L_PLAYER_RELEASEIF_PREPARE_THREAD(thread_id) \
do { \
if (thread_id) { \
pthread_join(thread_id, NULL); \
} while (0)
/* user_cb_lock */
-#define LEGACY_PLAYER_USER_CB_LOCK(x_handle, type) \
+#define L_PLAYER_USER_CB_LOCK(x_handle, type) \
do { \
- if (__check_enabled_user_cb_lock(type)) \
+ if (__lplayer_check_enabled_user_cb_lock(type)) \
g_mutex_lock(&((legacy_player_t *)x_handle)->user_cb_lock[type]); \
} while (0)
-#define LEGACY_PLAYER_USER_CB_UNLOCK(x_handle, type) \
+#define L_PLAYER_USER_CB_UNLOCK(x_handle, type) \
do { \
- if (__check_enabled_user_cb_lock(type)) \
+ if (__lplayer_check_enabled_user_cb_lock(type)) \
g_mutex_unlock(&((legacy_player_t *)x_handle)->user_cb_lock[type]); \
} while (0)
/*
* Internal Implementation
*/
-int __player_convert_error_code(int code, char *func_name)
+int _lplayer_convert_error_code(int code, char *func_name)
{
int ret = PLAYER_ERROR_INVALID_OPERATION;
char *msg = "PLAYER_ERROR_INVALID_OPERATION";
return ret;
}
-static void __player_update_state(legacy_player_t *handle, player_internal_state_e state)
+static void __lplayer_update_state(legacy_player_t *handle, player_internal_state_e state)
{
switch (state) {
case PLAYER_INTERNAL_STATE_NONE:
return;
}
-bool __player_state_validate(legacy_player_t *handle, player_state_e threshold)
+bool _lplayer_state_validate(legacy_player_t *handle, player_state_e threshold)
{
if (handle->state < threshold)
return false;
return true;
}
-static player_state_e __convert_player_state(mmplayer_state_e state)
+static player_state_e __lplayer_convert_state(mmplayer_state_e state)
{
if (state == MM_PLAYER_STATE_NONE)
return PLAYER_STATE_NONE;
return state + 1;
}
-static bool __check_enabled_user_cb_lock(int type)
+static bool __lplayer_check_enabled_user_cb_lock(int type)
{
switch (type) {
case MUSE_PLAYER_EVENT_TYPE_PREPARE: /* fall through */
}
}
-static void __buffer_status_callback(legacy_player_t *handle, MMMessageParamType *msg)
+static void __lplayer_buffer_status_callback(legacy_player_t *handle, MMMessageParamType *msg)
{
muse_player_event_e event_type;
muse_player_event_e event_type_internal;
buffer_status = msg->buffer_status.status;
buffer_bytes = msg->buffer_status.bytes;
- LEGACY_PLAYER_USER_CB_LOCK(handle, event_type);
+ L_PLAYER_USER_CB_LOCK(handle, event_type);
if (handle->user_cb[event_type]) {
LOGD("event type %d, status %d", event_type, buffer_status);
- ((player_media_stream_buffer_status_cb)handle->user_cb[event_type]) \
+ ((legacy_player_media_stream_buffer_status_cb)handle->user_cb[event_type]) \
(event_type, buffer_status, handle->user_data[event_type]);
- LEGACY_PLAYER_USER_CB_UNLOCK(handle, event_type);
+ L_PLAYER_USER_CB_UNLOCK(handle, event_type);
return;
}
- LEGACY_PLAYER_USER_CB_UNLOCK(handle, event_type);
+ L_PLAYER_USER_CB_UNLOCK(handle, event_type);
/* check internal api callback */
- LEGACY_PLAYER_USER_CB_LOCK(handle, event_type_internal);
+ L_PLAYER_USER_CB_LOCK(handle, event_type_internal);
if (handle->user_cb[event_type_internal]) {
LOGD("event type %d, status %d, bytes %llu", event_type_internal, buffer_status, buffer_bytes);
- ((player_media_stream_buffer_status_cb_ex)handle->user_cb[event_type_internal]) \
+ ((legacy_player_media_stream_buffer_status_cb_ex)handle->user_cb[event_type_internal]) \
(event_type_internal, buffer_status, buffer_bytes, handle->user_data[event_type_internal]);
}
- LEGACY_PLAYER_USER_CB_UNLOCK(handle, event_type_internal);
+ L_PLAYER_USER_CB_UNLOCK(handle, event_type_internal);
}
-
-static void __video_stream_changed_callback(legacy_player_t *handle)
+static void __lplayer_video_stream_changed_callback(legacy_player_t *handle)
{
int ret = MM_ERROR_NONE;
muse_player_event_e event_type = MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED;
return;
}
- ((player_video_stream_changed_cb)handle->user_cb[event_type])(width, height, fps, bit_rate, handle->user_data[event_type]);
+ ((legacy_player_video_stream_changed_cb)handle->user_cb[event_type]) \
+ (width, height, fps, bit_rate, handle->user_data[event_type]);
return;
}
-static void __default_callback(legacy_player_t *handle, muse_player_event_e type)
+static void __lplayer_default_callback(legacy_player_t *handle, muse_player_event_e type)
{
LOGD("type %d", type);
- LEGACY_PLAYER_USER_CB_LOCK(handle, type);
+ L_PLAYER_USER_CB_LOCK(handle, type);
if (handle->user_cb[type])
((legacy_player_default_callback)handle->user_cb[type])(type, handle->user_data[type]);
- LEGACY_PLAYER_USER_CB_UNLOCK(handle, type);
+ L_PLAYER_USER_CB_UNLOCK(handle, type);
}
-static int __msg_callback(int message, void *param, void *user_data)
+static int __lplayer_message_callback(int message, void *param, void *user_data)
{
legacy_player_t *handle = (legacy_player_t *)user_data;
MMMessageParamType *msg = (MMMessageParamType *)param;
LOGW("Got message type : 0x%x", message);
switch (message) {
case MM_MESSAGE_ERROR: /* 0x01 */
- err_code = __player_convert_error_code(msg->code, (char *)__FUNCTION__);
+ err_code = _lplayer_convert_error_code(msg->code, (char *)__FUNCTION__);
- LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ L_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
if (PLAYER_ERROR_NOT_SUPPORTED_FILE == err_code && handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
LOGW("Failed to pause, so prepare cb will be released soon");
handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
}
}
- LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ L_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
break;
case MM_MESSAGE_STATE_CHANGED: /* 0x03 */
LOGI("state chagned from: %d, to: %d (CAPI State: %d)", msg->state.previous, msg->state.current, handle->state);
if (msg->state.previous == MM_PLAYER_STATE_READY && msg->state.current == MM_PLAYER_STATE_PAUSED) {
- LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ L_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
/* async && prepared cb has been set */
LOGD("Prepared! [current state : %d]", handle->state);
PLAYER_TRACE_ASYNC_END("MM:PLAYER:PREPARE_ASYNC", *(int *)handle);
- __player_update_state(handle, PLAYER_INTERNAL_STATE_READY);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_READY);
((legacy_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;
}
- LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ L_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
}
break;
case MM_MESSAGE_BEGIN_OF_STREAM: /* 0x104 */
break;
case MM_MESSAGE_END_OF_STREAM: /* 0x105 */
LOGD("Playback is completed.");
- __default_callback(handle, MUSE_PLAYER_EVENT_TYPE_COMPLETE);
+ __lplayer_default_callback(handle, MUSE_PLAYER_EVENT_TYPE_COMPLETE);
break;
#ifdef TIZEN_FEATURE_EVAS_RENDERER
case MM_MESSAGE_GAPLESS_CONSTRUCTION: /* 0x105 */
LOGD("Retrieve exported buffers.");
- __default_callback(handle, MUSE_PLAYER_EVENT_TYPE_RETURN_BUFFER);
+ __lplayer_default_callback(handle, MUSE_PLAYER_EVENT_TYPE_RETURN_BUFFER);
break;
#endif
case MM_MESSAGE_BUFFERING: /* 0x103 */
if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_BUFFERING])
- ((player_buffering_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_BUFFERING]) \
+ ((legacy_player_buffering_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_BUFFERING]) \
(msg->connection.buffering, handle->user_data[MUSE_PLAYER_EVENT_TYPE_BUFFERING]);
break;
case MM_MESSAGE_STATE_INTERRUPTED: /* 0x04 */
if (msg->union_type == MM_MSG_UNION_STATE) {
LOGW("received mm state msg prev:%d, curr:%d", msg->state.previous, msg->state.current);
- handle->state = __convert_player_state(msg->state.current);
+ handle->state = __lplayer_convert_state(msg->state.current);
LOGW("player state is changed to %d by resource conflict", handle->state);
}
LOGD("Interrupted");
- __default_callback(handle, MUSE_PLAYER_EVENT_TYPE_INTERRUPT);
+ __lplayer_default_callback(handle, MUSE_PLAYER_EVENT_TYPE_INTERRUPT);
break;
case MM_MESSAGE_CONNECTION_TIMEOUT: /* 0x102 */
LOGE("PLAYER_ERROR_CONNECTION_FAILED : CONNECTION_TIMEOUT");
break;
case MM_MESSAGE_UPDATE_SUBTITLE: /* 0x109 */
if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SUBTITLE])
- ((player_subtitle_updated_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SUBTITLE]) \
+ ((legacy_player_subtitle_updated_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SUBTITLE]) \
(msg->subtitle.duration, (char *)msg->data, handle->user_data[MUSE_PLAYER_EVENT_TYPE_SUBTITLE]);
break;
case MM_MESSAGE_VIDEO_NOT_CAPTURED: /* 0x113 */
LOGE("PLAYER_ERROR_VIDEO_CAPTURE_FAILED");
if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_ERROR])
- ((player_error_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_ERROR]) \
+ ((legacy_player_error_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_ERROR]) \
(PLAYER_ERROR_VIDEO_CAPTURE_FAILED, handle->user_data[MUSE_PLAYER_EVENT_TYPE_ERROR]);
break;
case MM_MESSAGE_VIDEO_CAPTURED: /* 0x110 */
capture->orientation, capture->width, capture->height, capture->size);
/* call application callback */
- ((player_video_captured_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE])(capture->data, \
+ ((legacy_player_video_captured_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE])(capture->data, \
capture->width, capture->height, capture->size, handle->user_data[MUSE_PLAYER_EVENT_TYPE_CAPTURE]);
}
}
LOGD("Seek is completed");
- __default_callback(handle, MUSE_PLAYER_EVENT_TYPE_SEEK);
+ __lplayer_default_callback(handle, MUSE_PLAYER_EVENT_TYPE_SEEK);
handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
handle->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
break;
break;
case MM_MESSAGE_VIDEO_STREAM_CHANGED:
if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED])
- __video_stream_changed_callback(handle);
+ __lplayer_video_stream_changed_callback(handle);
break;
case MM_MESSAGE_PUSH_BUFFER_STATUS:
- __buffer_status_callback(handle, msg);
+ __lplayer_buffer_status_callback(handle, msg);
break;
case MM_MESSAGE_PUSH_BUFFER_SEEK_DATA:
{
event_type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK;
if (handle->user_cb[event_type])
- ((player_media_stream_seek_cb)handle->user_cb[event_type])(event_type, msg->seek_data.offset, handle->user_data[event_type]);
+ ((legacy_player_media_stream_seek_cb)handle->user_cb[event_type])(event_type, msg->seek_data.offset, handle->user_data[event_type]);
break;
}
if (err_code != PLAYER_ERROR_NONE && handle->user_cb[MUSE_PLAYER_EVENT_TYPE_ERROR]) {
handle->error_code = err_code;
LOGE("ERROR is occurred 0x%X", err_code);
- ((player_error_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_ERROR])(err_code, handle->user_data[MUSE_PLAYER_EVENT_TYPE_ERROR]);
+ ((legacy_player_error_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_ERROR])(err_code, handle->user_data[MUSE_PLAYER_EVENT_TYPE_ERROR]);
}
LPLAYER_FLEAVE();
return 1;
}
-static MMDisplaySurfaceType __player_convert_display_type(player_display_type_e type)
+static MMDisplaySurfaceType __lplayer_convert_display_type(player_display_type_e type)
{
switch (type) {
case PLAYER_DISPLAY_TYPE_OVERLAY:
}
}
-static int __check_callback_precondition(legacy_player_t *handle, muse_player_event_e type)
+static int __lplayer_check_callback_precondition(legacy_player_t *handle, muse_player_event_e type)
{
int i = 0;
int size = 0;
}
static int
-__set_buffer_export_callback(legacy_player_t *handle)
+__lplayer_set_buffer_export_callback(legacy_player_t *handle)
{
int ret = MM_ERROR_NONE;
muse_player_event_e video_type = MUSE_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME;
ret = mm_player_create(&handle->mm_handle);
if (ret != MM_ERROR_NONE) {
LOGE("Failed to create player 0x%X", ret);
- __player_update_state(handle, PLAYER_INTERNAL_STATE_NONE);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_NONE);
g_free(handle);
handle = NULL;
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
muse_player_event_e type = MUSE_PLAYER_EVENT_TYPE_PREPARE;
*player = (legacy_player_h)handle;
- __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
handle->display_type = PLAYER_DISPLAY_TYPE_NONE;
handle->is_display_visible = true;
handle->is_media_stream = false;
for (type = MUSE_PLAYER_EVENT_TYPE_PREPARE; type < MUSE_PLAYER_EVENT_TYPE_NUM; type++) {
- if (__check_enabled_user_cb_lock(type))
+ if (__lplayer_check_enabled_user_cb_lock(type))
g_mutex_init(&handle->user_cb_lock[type]);
}
handle->is_shutdown = true;
- LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ L_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;
g_free(handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE]);
handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
}
- LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ L_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);
+ L_PLAYER_RELEASEIF_PREPARE_THREAD(handle->prepare_async_thread);
ret = mm_player_destroy(handle->mm_handle);
if (ret != MM_ERROR_NONE) {
muse_player_event_e type = MUSE_PLAYER_EVENT_TYPE_PREPARE;
- __player_update_state(handle, PLAYER_INTERNAL_STATE_NONE);
+ __lplayer_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))
+ if (__lplayer_check_enabled_user_cb_lock(type))
g_mutex_clear(&handle->user_cb_lock[type]);
}
return PLAYER_ERROR_NONE;
}
-static void *__prepare_async_thread_func(void *data)
+static void *__lplayer_prepare_async_thread_func(void *data)
{
legacy_player_t *handle = data;
int ret = MM_ERROR_NONE;
ret = mm_player_pause(handle->mm_handle);
if (ret != MM_ERROR_NONE) {
LOGE("Failed to pause - core fw error(0x%x)", ret);
- __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
if (handle->error_code == PLAYER_ERROR_NONE) {
/* if there is no received error msg, it has to be posted here. */
MMMessageParamType msg_param;
msg_param.code = ret;
- __msg_callback(MM_MESSAGE_ERROR, (void *)&msg_param, (void *)handle);
+ __lplayer_message_callback(MM_MESSAGE_ERROR, (void *)&msg_param, (void *)handle);
}
if (!handle->is_shutdown) {
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);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_PRE_READY);
+ L_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("player is already prepareing");
- LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
- __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
+ L_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
return PLAYER_ERROR_INVALID_OPERATION;
}
handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = callback;
handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = user_data;
- LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ L_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
- ret = mm_player_set_message_callback(handle->mm_handle, __msg_callback, (void *)handle);
+ ret = mm_player_set_message_callback(handle->mm_handle, __lplayer_message_callback, (void *)handle);
if (ret != MM_ERROR_NONE)
LOGW("Failed to set message callback function (0x%x)", ret);
- ret = __set_buffer_export_callback(handle);
+ ret = __lplayer_set_buffer_export_callback(handle);
if (ret != MM_ERROR_NONE) {
LOGW("Failed to set buffer export callback function (0x%x)", ret);
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
if (handle->display_type == PLAYER_DISPLAY_TYPE_NONE) {
goto ERROR;
}
- ret = pthread_create(&handle->prepare_async_thread, NULL, (void *)__prepare_async_thread_func, (void *)handle);
+ ret = pthread_create(&handle->prepare_async_thread, NULL, (void *)__lplayer_prepare_async_thread_func, (void *)handle);
if (ret != 0) {
LOGE("Failed to create thread ret = %d", ret);
- LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ L_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;
/* user_data will be free at player_disp_prepare_async() */
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);
+ L_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
return PLAYER_ERROR_OUT_OF_MEMORY;
}
ERROR:
LOGW("prepare cb is released");
- LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ L_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;
/* user_data will be free at player_disp_prepare_async() */
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);
+ L_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
LOGE("LEAVE 0x%X", ret);
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
int legacy_player_prepare(legacy_player_h player)
PLAYER_TRACE_BEGIN("MM:PLAYER:PREPARE");
PLAYER_INSTANCE_CHECK(player);
PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
- __player_update_state(handle, PLAYER_INTERNAL_STATE_PRE_READY);
+ __lplayer_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);
+ ret = mm_player_set_message_callback(handle->mm_handle, __lplayer_message_callback, (void *)handle);
if (ret != MM_ERROR_NONE)
LOGW("Failed to set message callback function (0x%x)", ret);
- ret = __set_buffer_export_callback(handle);
+ ret = __lplayer_set_buffer_export_callback(handle);
if (ret != MM_ERROR_NONE) {
LOGW("Failed to set buffer export callback function (0x%x)", ret);
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
if (handle->display_type == PLAYER_DISPLAY_TYPE_NONE) {
} else {
ret = mm_player_get_attribute(handle->mm_handle, NULL, "display_visible", &visible, (char *)NULL);
if (ret != MM_ERROR_NONE) {
- __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", visible, (char *)NULL);
ret = mm_player_realize(handle->mm_handle);
if (ret != MM_ERROR_NONE) {
LOGE("Failed to realize - 0x%x", ret);
- __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
ret = mm_player_pause(handle->mm_handle);
LOGE("Failed to unrealize - 0x%x", uret);
LOGE("Failed to pause - 0x%x", ret);
- __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
- __player_update_state(handle, PLAYER_INTERNAL_STATE_READY);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_READY);
LPLAYER_FLEAVE();
PLAYER_TRACE_END();
handle->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
}
- if (!__player_state_validate(handle, PLAYER_STATE_READY) && !handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY) && !handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
- LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ L_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
LOGW("Need to check. prepare cb have to be reset before");
handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
g_free(handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE]);
handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
}
- LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
+ L_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);
+ L_PLAYER_RELEASEIF_PREPARE_THREAD(handle->prepare_async_thread);
ret = mm_player_unrealize(handle->mm_handle);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
- __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
handle->is_display_visible = true;
LPLAYER_FLEAVE();
handle->is_media_stream = false;
ret = mm_player_set_uri(handle->mm_handle, uri);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
snprintf(uri, sizeof(uri), "mem:///ext=%s,size=%d", "", size);
ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_CONTENT_URI, uri, strlen(uri), MM_PLAYER_MEMORY_SRC, data, size, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_set_volume(handle->mm_handle, volume);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_get_volume(handle->mm_handle, volume);
if (ret != MM_ERROR_NONE) {
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
return PLAYER_ERROR_NONE;
/* check if stream_info is valid */
ret = sound_manager_is_available_stream_information(stream_info, NATIVE_API_PLAYER, &is_available);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
if (is_available) {
char *stream_type = NULL;
}
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_set_attribute(handle->mm_handle, NULL, "sound_latency_mode", latency_mode, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, "sound_latency_mode", latency_mode, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
}
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
- __player_update_state(handle, PLAYER_INTERNAL_STATE_PLAYING);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_PLAYING);
LPLAYER_FLEAVE();
return PLAYER_ERROR_NONE;
ret = mm_player_stop(handle->mm_handle);
if (ret != MM_ERROR_NONE) {
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK]) {
handle->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
}
- __player_update_state(handle, PLAYER_INTERNAL_STATE_STOPPED);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_STOPPED);
LPLAYER_FLEAVE();
return PLAYER_ERROR_NONE;
ret = mm_player_pause(handle->mm_handle);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
- __player_update_state(handle, PLAYER_INTERNAL_STATE_PAUSED);
+ __lplayer_update_state(handle, PLAYER_INTERNAL_STATE_PAUSED);
LPLAYER_FLEAVE();
return PLAYER_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
PLAYER_CHECK_CONDITION(nanoseconds >= 0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_set_attribute(handle->mm_handle, NULL, "accurate_seek", accurated, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
ret = mm_player_set_position(handle->mm_handle, nanoseconds);
if (ret != MM_ERROR_NONE) {
handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
handle->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
LPLAYER_FLEAVE();
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(nanoseconds);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
return PLAYER_ERROR_NONE;
}
}
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
*nanoseconds = pos;
ret = mm_player_set_mute(handle->mm_handle, muted);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_get_mute(handle->mm_handle, muted);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_PLAYBACK_COUNT, value, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_PLAYBACK_COUNT, &count, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
*looping = (count == -1) ? true : false;
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(duration);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_duration(handle->mm_handle, duration);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
LOGD("content dur: %"PRId64, *duration);
return PLAYER_ERROR_NONE;
ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_method", mode, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, "display_method", mode, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
PLAYER_INSTANCE_CHECK(player);
PLAYER_CHECK_CONDITION(rate >= -5.0 && rate <= 5.0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = PLAYER_ERROR_INVALID_OPERATION;
break;
default:
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
return ret;
ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_VIDEO_ROTATION, rotation, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_VIDEO_ROTATION, rotation, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", value, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
handle->is_display_visible = visible;
return PLAYER_ERROR_NONE;
ret = mm_player_get_attribute(handle->mm_handle, NULL, "display_visible", &value, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
*visible = (value == 0) ? false : true;
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(value);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, attr, &val, &val_len, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
*value = NULL;
if (val != NULL)
PLAYER_NULL_ARG_CHECK(audio_codec);
PLAYER_NULL_ARG_CHECK(video_codec);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_AUDIO_CODEC, &audio, &audio_len, MM_PLAYER_VIDEO_CODEC, &video, &video_len, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
*audio_codec = NULL;
if (audio != NULL)
PLAYER_NULL_ARG_CHECK(channel);
PLAYER_NULL_ARG_CHECK(bit_rate);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_AUDIO_SAMPLERATE, sample_rate, MM_PLAYER_AUDIO_CHANNEL, channel, MM_PLAYER_AUDIO_BITRATE, bit_rate, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
PLAYER_NULL_ARG_CHECK(fps);
PLAYER_NULL_ARG_CHECK(bit_rate);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_VIDEO_FPS, fps, MM_PLAYER_VIDEO_BITRATE, bit_rate, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(width);
PLAYER_NULL_ARG_CHECK(height);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_VIDEO_WIDTH, &w, MM_PLAYER_VIDEO_HEIGHT, &h, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
*width = w;
*height = h;
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(size);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, "tag_album_cover", album_art, size, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_audio_effect_custom_get_eq_bands_number(handle->mm_handle, count);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_audio_effect_custom_set_level_eq_from_list(handle->mm_handle, band_levels, length);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
ret = mm_player_audio_effect_custom_apply(handle->mm_handle);
- return (ret == MM_ERROR_NONE) ? PLAYER_ERROR_NONE : __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return (ret == MM_ERROR_NONE) ? PLAYER_ERROR_NONE : _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
int legacy_player_audio_effect_set_equalizer_band_level(legacy_player_h player, int index, int level)
ret = mm_player_audio_effect_custom_set_level(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ, index, level);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
ret = mm_player_audio_effect_custom_apply(handle->mm_handle);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_audio_effect_custom_get_level(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ, index, level);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_audio_effect_custom_get_level_range(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ, min, max);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_audio_effect_custom_get_eq_bands_freq(handle->mm_handle, index, frequency);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_audio_effect_custom_get_eq_bands_width(handle->mm_handle, index, range);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_audio_effect_custom_clear_eq_all(handle->mm_handle);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
ret = mm_player_audio_effect_custom_apply(handle->mm_handle);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(available);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_set_external_subtitle_path(handle->mm_handle, path);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
LPLAYER_FLEAVE();
return PLAYER_ERROR_NONE;
legacy_player_t *handle = (legacy_player_t *)player;
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
- if (!__player_state_validate(handle, PLAYER_STATE_PLAYING)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_PLAYING)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_adjust_subtitle_position(handle->mm_handle, millisecond);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
-int legacy_player_capture_video(legacy_player_h player, player_video_captured_cb callback, void *user_data)
+int legacy_player_capture_video(legacy_player_h player, legacy_player_video_captured_cb callback, void *user_data)
{
legacy_player_t *handle = (legacy_player_t *)player;
int ret = MM_ERROR_NONE;
if (ret != MM_ERROR_NONE) {
handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
handle->user_data[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
return PLAYER_ERROR_NONE;
}
ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_STREAMING_COOKIE, cookie, size, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_STREAMING_USER_AGENT, user_agent, size, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(start_pos && end_pos);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("invalid state error, current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_buffer_position(handle->mm_handle, start_pos, end_pos);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(callback);
- ret = __check_callback_precondition(handle, type);
+ ret = __lplayer_check_callback_precondition(handle, type);
if (ret != PLAYER_ERROR_NONE) {
LOGE("precondition failure, type %d", type);
return ret;
}
- LEGACY_PLAYER_USER_CB_LOCK(player, type);
+ L_PLAYER_USER_CB_LOCK(player, type);
LOGD("event type : %d ", type);
handle->user_cb[type] = callback;
handle->user_data[type] = user_data;
- LEGACY_PLAYER_USER_CB_UNLOCK(player, type);
+ L_PLAYER_USER_CB_UNLOCK(player, type);
return PLAYER_ERROR_NONE;
}
LOGD("event type : %d ", type);
- LEGACY_PLAYER_USER_CB_LOCK(player, type);
+ L_PLAYER_USER_CB_LOCK(player, type);
handle->user_cb[type] = NULL;
handle->user_data[type] = NULL;
- LEGACY_PLAYER_USER_CB_UNLOCK(player, type);
+ L_PLAYER_USER_CB_UNLOCK(player, type);
return PLAYER_ERROR_NONE;
}
ret = mm_player_submit_packet(handle->mm_handle, packet);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
return PLAYER_ERROR_INVALID_PARAMETER;
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
legacy_player_t *handle = (legacy_player_t *)player;
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_set_media_stream_buffer_max_size(handle->mm_handle, type, max_size);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_get_media_stream_buffer_max_size(handle->mm_handle, type, &_max_size);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
*max_size = _max_size;
return PLAYER_ERROR_NONE;
legacy_player_t *handle = (legacy_player_t *)player;
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_set_media_stream_buffer_min_percent(handle->mm_handle, type, percent);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_get_media_stream_buffer_min_percent(handle->mm_handle, type, &_value);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
*percent = _value;
return PLAYER_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(count);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_track_count(handle->mm_handle, track_type, count);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
mmplayer_track_type_e track_type = 0;
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(index);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_current_track(handle->mm_handle, track_type, index);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
LPLAYER_FENTER();
PLAYER_INSTANCE_CHECK(player);
PLAYER_CHECK_CONDITION(index >= 0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_select_track(handle->mm_handle, track_type, index);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
LPLAYER_FLEAVE();
return PLAYER_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(code);
PLAYER_NULL_ARG_CHECK(len);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
*code = NULL;
ret = mm_player_get_track_language_code(handle->mm_handle, track_type, index, code);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
LOGD("idx %d, lang code %s", index, *code);
*len = strlen(*code);
ret = mm_player_set_video_roi_area(handle->mm_handle, scale_x, scale_y, scale_width, scale_heights);
if (ret != PLAYER_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_get_video_roi_area(handle->mm_handle, scale_x, scale_y, scale_width, scale_height);
if (ret != PLAYER_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
/* set roi area */
ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_win_roi_x", x, "display_win_roi_y", y, "display_win_roi_width", w, "display_win_roi_height", h, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
int ret = MM_ERROR_NONE;
void *set_handle = NULL;
void *temp = NULL;
- MMDisplaySurfaceType mmType = __player_convert_display_type(type);
+ MMDisplaySurfaceType surface_type = __lplayer_convert_display_type(type);
PLAYER_INSTANCE_CHECK(player);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
if (handle->display_type == PLAYER_DISPLAY_TYPE_NONE || type == handle->display_type) {
/* first time or same type */
LOGW("first time or same type");
- ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", mmType, "display_overlay", set_handle, sizeof(wl_surface_id), NULL);
+ ret = mm_player_set_attribute(handle->mm_handle, NULL,
+ "display_surface_type", surface_type, "display_overlay", set_handle, sizeof(wl_surface_id), NULL);
if (ret != MM_ERROR_NONE) {
handle->display_handle = temp;
}
} else {
/* changing surface case */
- ret = mm_player_change_videosink(handle->mm_handle, mmType, set_handle);
+ ret = mm_player_change_videosink(handle->mm_handle, surface_type, set_handle);
if (ret != MM_ERROR_NONE) {
handle->display_handle = temp;
if (ret == MM_ERROR_NOT_SUPPORT_API) {
if (ret != MM_ERROR_NONE) {
handle->display_type = PLAYER_DISPLAY_TYPE_NONE;
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
}
return PLAYER_ERROR_NONE;
ret = mm_player_set_sound_stream_info(handle->mm_handle, stream_type, stream_index);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_get_timeout(handle->mm_handle, timeout);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_VIDEO_BUFFER_TOTAL_SIZE, num,
MM_PLAYER_VIDEO_BUFFER_EXTRA_SIZE, extra_num, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_manage_external_storage_state(handle->mm_handle, id, state);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
PLAYER_NULL_ARG_CHECK(num);
PLAYER_NULL_ARG_CHECK(var_info);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_adaptive_variant_info(handle->mm_handle, num, var_info);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_set_max_adaptive_variant_limit(handle->mm_handle, bandwidth, width, height);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_get_max_adaptive_variant_limit(handle->mm_handle, bandwidth, width, height);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_set_audio_only(handle->mm_handle, audio_only);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_get_audio_only(handle->mm_handle, &audio_only);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
*paudio_only = audio_only;
return PLAYER_ERROR_NONE;
ret = mm_player_set_client_pid(handle->mm_handle, pid);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_REBUFFER_MS, rebuffer_ms, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(prebuffer_ms && rebuffer_ms);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL,
MM_PLAYER_PREBUFFER_MS, prebuffer_ms, MM_PLAYER_REBUFFER_MS, rebuffer_ms, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
LOGD("pre: %d ms, re: %d ms", *prebuffer_ms, *rebuffer_ms);
return PLAYER_ERROR_NONE;
ret = mm_player_get_streaming_buffering_time(handle->mm_handle, prebuffer_ms, rebuffer_ms);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
LOGD("pre: %d ms, re: %d ms", *prebuffer_ms, *rebuffer_ms);
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(is_spherical);
- if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_360_is_content_spherical(handle->mm_handle, is_spherical);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_360_set_enabled(handle->mm_handle, enabled);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(enabled);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_360_is_enabled(handle->mm_handle, enabled);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_360_set_direction_of_view(handle->mm_handle, yaw, pitch);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
PLAYER_NULL_ARG_CHECK(yaw);
PLAYER_NULL_ARG_CHECK(pitch);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_360_get_direction_of_view(handle->mm_handle, yaw, pitch);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_360_set_zoom(handle->mm_handle, level);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_360_get_zoom(handle->mm_handle, level);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_360_set_field_of_view(handle->mm_handle, horizontal_degrees, vertical_degrees);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
PLAYER_NULL_ARG_CHECK(horizontal_degrees);
PLAYER_NULL_ARG_CHECK(vertical_degrees);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_360_get_field_of_view(handle->mm_handle, horizontal_degrees, vertical_degrees);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
int ret = MM_ERROR_NONE;
PLAYER_INSTANCE_CHECK(player);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_set_replaygain_enabled(handle->mm_handle, enabled);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(enabled);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_is_replaygain_enabled(handle->mm_handle, &_enable);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
*enabled = _enable;
return PLAYER_ERROR_NONE;
ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_AUDIO_OFFLOAD, (int)enabled, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(enabled);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_AUDIO_OFFLOAD, &val, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
*enabled = (bool)val;
LOGD("get audio offload %d", *enabled);
ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_PITCH_CONTROL, (int)enabled, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(enabled);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_PITCH_CONTROL, &val, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
*enabled = (bool)val;
LOGD("get pitch control %d", *enabled);
PLAYER_INSTANCE_CHECK(player);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_PITCH_CONTROL, &is_enabled, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
if (!is_enabled) {
LOGE("pitch is not enabled");
LOGD("set pitch value %1.3f", pitch);
ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_PITCH_VALUE, (double)pitch, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
return PLAYER_ERROR_NONE;
}
PLAYER_INSTANCE_CHECK(player);
PLAYER_NULL_ARG_CHECK(pitch);
- if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
+ if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
return PLAYER_ERROR_INVALID_STATE;
}
ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_PITCH_VALUE, &value, (char *)NULL);
if (ret != MM_ERROR_NONE)
- return __player_convert_error_code(ret, (char *)__FUNCTION__);
+ return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
*pitch = (float)value;
LOGD("get pitch value %1.3f", *pitch);
* see ../api.list
* see ../make_api.py
*/
-static bool _create_export_data(muse_player_handle_t *muse_player, void *data, int size, void *ext_data, int ext_size, tbm_fd *out_tfd, int *out_key)
+static bool __mplayer_create_export_data(muse_player_handle_t *muse_player,
+ void *data, int size, void *ext_data, int ext_size, tbm_fd *out_tfd, int *out_key)
{
muse_player_export_data_t *export_data = NULL;
tbm_bo bo = NULL;
return false;
}
-static bool _remove_export_data(muse_module_h module, int key, bool remove_all)
+static bool __mplayer_remove_export_data(muse_module_h module, int key, bool remove_all)
{
bool ret = true;
muse_player_handle_t *muse_player = NULL;
return ret;
}
-static void _remove_video_stream_data(muse_module_h module, mmplayer_video_decoded_data_info_t *video_data)
+static void __mplayer_remove_video_stream_data(muse_module_h module, mmplayer_video_decoded_data_info_t *video_data)
{
int i = 0, bo_num = 0;
muse_player_handle_t *muse_player = NULL;
}
-static void _remove_export_media_packet(muse_module_h module)
+static void __mplayer_remove_export_media_packet(muse_module_h module)
{
muse_player_handle_t *muse_player = NULL;
LOGW("number of remained video_list %d", g_list_length(muse_player->video_data_list));
for (video_list = g_list_first(muse_player->video_data_list); video_list; video_list = g_list_next(video_list)) {
LOGW("%p will be removed", video_list->data);
- _remove_video_stream_data(module, (mmplayer_video_decoded_data_info_t *)video_list->data);
+ __mplayer_remove_video_stream_data(module, (mmplayer_video_decoded_data_info_t *)video_list->data);
}
g_list_free(muse_player->video_data_list);
muse_player->video_data_list = NULL;
}
/* check the given path is indicating sdp file */
-static bool _is_sdp_file(const char *path)
+static bool __mplayer_is_sdp_file(const char *path)
{
bool ret = false;
gchar *uri = NULL;
return ret;
}
-static bool _check_network_availability(void)
+static bool __mplayer_check_network_availability(void)
{
#define _FEATURE_NAME_WIFI "http://tizen.org/feature/network.wifi"
#define _FEATURE_NAME_TELEPHONY "http://tizen.org/feature/network.telephony"
return true;
}
-static int _check_supportable(muse_module_h module, char *path)
+static int __mplayer_check_supportable(muse_module_h module, char *path)
{
int ret = PLAYER_ERROR_NONE;
int client_fd = -1;
if (strncmp(path, "file://", strlen("file://")) == 0)
file_path = path + 7; /* remove file prefix */
- if (_is_sdp_file(file_path)) /* check internet privilege */
+ if (__mplayer_is_sdp_file(file_path)) /* check internet privilege */
privilege = INTERNET_PRIVILEGE_NAME;
if (!privilege) {
} else {
if (strncmp(privilege, INTERNET_PRIVILEGE_NAME, strlen(INTERNET_PRIVILEGE_NAME)) == 0) {
/*check internet feature*/
- if (!_check_network_availability()) {
+ if (!__mplayer_check_network_availability()) {
ret = PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE;
LOGE("feature is not supportable.");
}
return ret;
}
-static void _prepare_async_cb(void *user_data)
+static void __mplayer_prepare_async_cb(void *user_data)
{
muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_PREPARE;
muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
PLAYER_SEND_EVENT_MSG(api, ev, module);
}
-static void _capture_video_cb(unsigned char *data, int width, int height, unsigned int size, void *user_data)
+static void __mplayer_capture_video_cb(unsigned char *data, int width, int height, unsigned int size, void *user_data)
{
muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_CAPTURE;
return;
}
- ret = _create_export_data(muse_player, (void *)data, size, NULL, 0, &tfd, &key);
+ ret = __mplayer_create_export_data(muse_player, (void *)data, size, NULL, 0, &tfd, &key);
if (!ret) {
LOGE("failed to create export data");
return;
return;
}
-static int _get_tbm_surface_format(int in_format, uint32_t *out_format)
+static int __mplayer_get_tbm_surface_format(int in_format, uint32_t *out_format)
{
if (in_format <= MM_PIXEL_FORMAT_INVALID || in_format >= MM_PIXEL_FORMAT_NUM || out_format == NULL) {
LOGE("INVALID_PARAMETER : in_format %d, out_format ptr %p", in_format, out_format);
return PLAYER_ERROR_NONE;
}
-static int _get_media_packet_mimetype(int in_format, media_format_mimetype_e *mimetype)
+static int __mplayer_get_media_packet_mimetype(int in_format, media_format_mimetype_e *mimetype)
{
if (in_format <= MM_PIXEL_FORMAT_INVALID || in_format >= MM_PIXEL_FORMAT_NUM || mimetype == NULL) {
LOGE("INVALID_PARAMETER : in_format %d, mimetype ptr %p", in_format, mimetype);
}
/* get format info */
- ret = _get_tbm_surface_format(video_stream->format, &bo_format);
- ret |= _get_media_packet_mimetype(video_stream->format, &mimetype);
+ ret = __mplayer_get_tbm_surface_format(video_stream->format, &bo_format);
+ ret |= __mplayer_get_media_packet_mimetype(video_stream->format, &mimetype);
if (ret != PLAYER_ERROR_NONE) {
LOGE("Fail to get format info");
LOGD("ENTER");
PLAYER_SEND_EVENT_MSG(api, ev, module, MUSE_TYPE_INT, "percent", percent);
-
}
static void __mplayer_set_enable_data_export(legacy_player_h player, void *data, bool set)
return ret;
}
-static int _push_media_stream(muse_player_handle_t *muse_player, player_push_media_msg_type *push_media, char *buf)
+static int __mplayer_push_media_stream(muse_player_handle_t *muse_player, player_push_media_msg_type *push_media, char *buf)
{
int ret = MEDIA_FORMAT_ERROR_NONE;
media_format_h format;
return ret;
}
-static bool __audio_decoded_cb(void *audio_data, void *user_data)
+static bool __mplayer_audio_decoded_cb(void *audio_data, void *user_data)
{
muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_MEDIA_PACKET_AUDIO_FRAME;
return false;
}
- ret = _create_export_data(muse_player, data, size, audio_info, sizeof(mmplayer_audio_decoded_data_info_t), &tfd, &key);
+ ret = __mplayer_create_export_data(muse_player, data, size, audio_info, sizeof(mmplayer_audio_decoded_data_info_t), &tfd, &key);
if (!ret) {
LOGE("failed to create export data");
return false;
return true;
}
-int _player_disp_send_msg(int send_fd, char *msg, int *tfd)
-{
- int send_len = 0;
-
- if ((send_fd <= 0) || !muse_core_fd_is_valid(send_fd)) {
- LOGE("invalid socket fd %d", send_fd);
- return PLAYER_ERROR_INVALID_OPERATION;
- }
-
- if (tfd != NULL)
- send_len = muse_core_msg_send_fd(send_fd, tfd, msg);
- else
- send_len = muse_core_msg_send(send_fd, msg);
-
- if (send_len <= 0) {
- LOGE("sending message failed");
- return PLAYER_ERROR_INVALID_OPERATION;
- }
-
- return PLAYER_ERROR_NONE;
-}
-
-int _player_disp_send_msg_async(int send_fd, char *msg)
-{
- int send_len = 0;
-
- if ((send_fd <= 0) || !muse_core_fd_is_valid(send_fd)) {
- LOGE("invalid socket fd %d", send_fd);
- return PLAYER_ERROR_INVALID_OPERATION;
- }
-
- send_len = muse_core_msg_send(send_fd, msg);
- if (send_len <= 0) {
- LOGE("sending message failed");
- return PLAYER_ERROR_INVALID_OPERATION;
- }
-
- return PLAYER_ERROR_NONE;
-}
-
-static bool _player_disp_get_param_value(char *buf, ...)
+static bool __mplayer_disp_get_param_value(char *buf, ...)
{
muse_core_msg_parse_err_e err = MUSE_MSG_PARSE_ERROR_NONE;
bool ret = true;
return ret;
}
+int _mplayer_disp_send_msg(int send_fd, char *msg, int *tfd)
+{
+ int send_len = 0;
+
+ if ((send_fd <= 0) || !muse_core_fd_is_valid(send_fd)) {
+ LOGE("invalid socket fd %d", send_fd);
+ return PLAYER_ERROR_INVALID_OPERATION;
+ }
+
+ if (tfd != NULL)
+ send_len = muse_core_msg_send_fd(send_fd, tfd, msg);
+ else
+ send_len = muse_core_msg_send(send_fd, msg);
+
+ if (send_len <= 0) {
+ LOGE("sending message failed");
+ return PLAYER_ERROR_INVALID_OPERATION;
+ }
+
+ return PLAYER_ERROR_NONE;
+}
+
int player_disp_create(muse_module_h module)
{
int ret = PLAYER_ERROR_NONE;
muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
/* decoder buffer need to be released first to destroy pipeline */
- _remove_export_media_packet(module);
+ __mplayer_remove_export_media_packet(module);
ret = legacy_player_destroy(muse_player->player_handle);
muse_player->video_format = NULL;
}
- _remove_export_data(module, 0, true);
+ __mplayer_remove_export_data(module, 0, true);
g_mutex_clear(&muse_player->list_lock);
muse_player->bufmgr = NULL;
prepare_data->player = muse_player->player_handle;
prepare_data->module = module;
- ret = legacy_player_prepare_async(muse_player->player_handle, _prepare_async_cb, prepare_data);
+ ret = legacy_player_prepare_async(muse_player->player_handle, __mplayer_prepare_async_cb, prepare_data);
if (ret == PLAYER_ERROR_NONE) {
legacy_player_get_timeout_for_muse(muse_player->player_handle, &timeout);
PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "timeout", timeout);
muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
/* decoder buffer need to be released first to destroy pipeline */
- _remove_export_media_packet(module);
+ __mplayer_remove_export_media_packet(module);
ret = legacy_player_unprepare(muse_player->player_handle);
- _remove_export_data(module, 0, true);
+ __mplayer_remove_export_data(module, 0, true);
PLAYER_RETURN_MSG(api, ret, module);
muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
player_msg_get_string(path, muse_server_module_get_msg(module));
- if ((ret = _check_supportable(module, path)) == PLAYER_ERROR_NONE)
+ if ((ret = __mplayer_check_supportable(module, path)) == PLAYER_ERROR_NONE)
ret = legacy_player_set_uri(muse_player->player_handle, path);
PLAYER_RETURN_MSG(api, ret, module);
double volume = 0.0;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_DOUBLE, "volume", (void *)&volume,
INVALID_MUSE_TYPE_VALUE);
if (ret_val) {
char stream_type[MUSE_URI_MAX_LENGTH] = { 0, };
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_INT, "stream_index", (void *)&stream_index,
MUSE_TYPE_STRING, "stream_type", (void *)stream_type,
INVALID_MUSE_TYPE_VALUE);
int accurate = 0;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_INT64, "pos", (void *)&pos,
MUSE_TYPE_INT, "accurate", (void *)&accurate,
INVALID_MUSE_TYPE_VALUE);
double x_scale = 0, y_scale = 0, w_scale = 0, h_scale = 0;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_DOUBLE, "x_scale", (void *)&x_scale,
MUSE_TYPE_DOUBLE, "y_scale", (void *)&y_scale,
MUSE_TYPE_DOUBLE, "w_scale", (void *)&w_scale,
goto ERROR;
if ((album_art != NULL) && (size > 0)) {
- ret_val = _create_export_data(muse_player, album_art, size, NULL, 0, &tfd, &key);
+ ret_val = __mplayer_create_export_data(muse_player, album_art, size, NULL, 0, &tfd, &key);
if (!ret_val) {
LOGE("failed to create export data");
ret = PLAYER_ERROR_INVALID_OPERATION;
int index = 0, level = 0;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_INT, "index", (void *)&index,
MUSE_TYPE_INT, "level", (void *)&level,
INVALID_MUSE_TYPE_VALUE);
muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
- ret = legacy_player_capture_video(muse_player->player_handle, _capture_video_cb, module);
+ ret = legacy_player_capture_video(muse_player->player_handle, __mplayer_capture_video_cb, module);
PLAYER_RETURN_MSG(api, ret, module);
player_msg_get_string(subtitle_path, muse_server_module_get_msg(module));
if (strncmp(subtitle_path, "", 1)) {
- if ((ret = _check_supportable(module, subtitle_path)) == PLAYER_ERROR_NONE)
+ if ((ret = __mplayer_check_supportable(module, subtitle_path)) == PLAYER_ERROR_NONE)
ret = legacy_player_set_subtitle_path(muse_player->player_handle, subtitle_path);
} else {
ret = legacy_player_set_subtitle_path(muse_player->player_handle, NULL);
buf = muse_server_ipc_get_data(module);
}
- ret = _push_media_stream(muse_player, &push_media, buf);
+ ret = __mplayer_push_media_stream(muse_player, &push_media, buf);
if (push_media.buf_type == PUSH_MEDIA_BUF_TYPE_TBM)
tbm_bo_unmap(bo);
int set = 0;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_INT, "type", (void *)&type,
MUSE_TYPE_INT, "set", (void *)&set,
INVALID_MUSE_TYPE_VALUE);
g_mutex_unlock(&muse_player->list_lock);
if (find_data)
- _remove_video_stream_data(module, v_data);
+ __mplayer_remove_video_stream_data(module, v_data);
}
return PLAYER_ERROR_NONE;
unsigned long long max_size;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_INT, "type", (void *)&type,
MUSE_TYPE_INT64, "max_size", (void *)&max_size,
INVALID_MUSE_TYPE_VALUE);
unsigned percent = 0;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_INT, "type", (void *)&type,
MUSE_TYPE_INT, "percent", (void *)&percent,
INVALID_MUSE_TYPE_VALUE);
int index = 0;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_INT, "type", (void *)&type,
MUSE_TYPE_INT, "index", (void *)&index,
INVALID_MUSE_TYPE_VALUE);
int code_len = 0;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_INT, "type", (void *)&type,
MUSE_TYPE_INT, "index", (void *)&index,
INVALID_MUSE_TYPE_VALUE);
muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
player_msg_get(sync, muse_server_module_get_msg(module));
- ret = legacy_player_set_pcm_extraction_mode(muse_player->player_handle, sync, __audio_decoded_cb, module);
+ ret = legacy_player_set_pcm_extraction_mode(muse_player->player_handle, sync, __mplayer_audio_decoded_cb, module);
PLAYER_RETURN_MSG(api, ret, module);
int channel = 0;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_INT, "samplerate", (void *)&samplerate,
MUSE_TYPE_INT, "channel", (void *)&channel,
MUSE_TYPE_STRING, "format", (void *)format,
/* LOGD("handle : %p, key : %d", muse_player, key); */
- if (!_remove_export_data(module, key, false))
+ if (!__mplayer_remove_export_data(module, key, false))
LOGE("failed to remove export data : key %d", key);
/* This funct does not send return value to client. *
int width = ADAPTIVE_VARIANT_DEFAULT_VALUE;
int height = ADAPTIVE_VARIANT_DEFAULT_VALUE;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_INT, "bandwidth", (void *)&bandwidth,
MUSE_TYPE_INT, "width", (void *)&width,
MUSE_TYPE_INT, "height", (void *)&height,
int prebuffer_ms = -1, rebuffer_ms = -1;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_INT, "prebuffer_ms", (void *)&prebuffer_ms,
MUSE_TYPE_INT, "rebuffer_ms", (void *)&rebuffer_ms,
INVALID_MUSE_TYPE_VALUE);
double yaw, pitch;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_DOUBLE, "yaw", (void *)&yaw,
MUSE_TYPE_DOUBLE, "pitch", (void *)&pitch,
INVALID_MUSE_TYPE_VALUE);
int horizontal_degrees = 0, vertical_degrees = 0;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_INT, "horizontal_degrees", (void *)&horizontal_degrees,
MUSE_TYPE_INT, "vertical_degrees", (void *)&vertical_degrees,
INVALID_MUSE_TYPE_VALUE);
double level = 0;
bool ret_val = true;
- ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
+ ret_val = __mplayer_disp_get_param_value(muse_server_module_get_msg(module),
MUSE_TYPE_DOUBLE, "level", (void *)&level,
MUSE_TYPE_INT, "horizontal_degrees", (void *)&horizontal_degrees,
MUSE_TYPE_INT, "vertical_degrees", (void *)&vertical_degrees,
projects / platform / core / multimedia / mmsvc-player.git / commitdiff