static GstElement * __mmplayer_create_decodebin(mm_player_t* player);
static gboolean __mmplayer_try_to_plug_decodebin(mm_player_t* player, GstPad *srcpad, const GstCaps *caps);
-static void __mmplayer_typefind_have_type( GstElement *tf, guint probability, GstCaps *caps, gpointer data);
+static void __mmplayer_typefind_have_type(GstElement *tf, guint probability, GstCaps *caps, gpointer data);
static gboolean __mmplayer_try_to_plug(mm_player_t* player, GstPad *pad, const GstCaps *caps);
static void __mmplayer_pipeline_complete(GstElement *decodebin, gpointer data);
static gboolean __mmplayer_is_midi_type(gchar* str_caps);
static int __mmplayer_change_selector_pad(mm_player_t* player, MMPlayerTrackType type, int index);
static gboolean __mmplayer_check_subtitle(mm_player_t* player);
-static gboolean __mmplayer_handle_streaming_error (mm_player_t* player, GstMessage * message);
+static gboolean __mmplayer_handle_streaming_error(mm_player_t* player, GstMessage * message);
static void __mmplayer_handle_eos_delay(mm_player_t* player, int delay_in_ms);
static void __mmplayer_cancel_eos_timer(mm_player_t* player);
static gboolean __mmplayer_eos_timer_cb(gpointer u_data);
-static gboolean __mmplayer_link_decoder(mm_player_t* player,GstPad *srcpad);
-static gboolean __mmplayer_link_sink(mm_player_t* player,GstPad *srcpad);
+static gboolean __mmplayer_link_decoder(mm_player_t* player, GstPad *srcpad);
+static gboolean __mmplayer_link_sink(mm_player_t* player, GstPad *srcpad);
static int __mmplayer_handle_missed_plugin(mm_player_t* player);
static int __mmplayer_check_not_supported_codec(mm_player_t* player, const gchar* factory_class, const gchar* mime);
static gboolean __mmplayer_configure_audio_callback(mm_player_t* player);
static gboolean __is_ms_buff_src(mm_player_t* player);
static gboolean __has_suffix(mm_player_t * player, const gchar * suffix);
-static int __mmplayer_realize_streaming_ext(mm_player_t* player);
+static int __mmplayer_realize_streaming_ext(mm_player_t* player);
static int __mmplayer_unrealize_streaming_ext(mm_player_t *player);
static int __mmplayer_start_streaming_ext(mm_player_t *player);
static int __mmplayer_destroy_streaming_ext(mm_player_t* player);
static gboolean __gst_seek_audio_data(GstElement * appsrc, guint64 position, gpointer user_data);
static gboolean __gst_seek_video_data(GstElement * appsrc, guint64 position, gpointer user_data);
static gboolean __gst_seek_subtitle_data(GstElement * appsrc, guint64 position, gpointer user_data);
-static void __mmplayer_gst_caps_notify_cb(GstPad * pad, GParamSpec * unused, gpointer data);
+static void __mmplayer_gst_caps_notify_cb(GstPad * pad, GParamSpec * unused, gpointer data);
static void __mmplayer_audio_stream_clear_buffer(mm_player_t* player, gboolean send_all);
static void __mmplayer_audio_stream_send_data(mm_player_t* player, mm_player_audio_stream_buff_t *a_buffer);
static void
print_tag(const GstTagList * list, const gchar * tag, gpointer unused)
{
- gint i, count;
+ gint i, count;
- count = gst_tag_list_get_tag_size(list, tag);
+ count = gst_tag_list_get_tag_size(list, tag);
- LOGD("count = %d", count);
+ LOGD("count = %d", count);
- for (i = 0; i < count; i++) {
- gchar *str;
+ for (i = 0; i < count; i++) {
+ gchar *str;
- if (gst_tag_get_type(tag) == G_TYPE_STRING) {
- if (!gst_tag_list_get_string_index(list, tag, i, &str))
- g_assert_not_reached();
- } else {
- str =
- g_strdup_value_contents(gst_tag_list_get_value_index(list, tag, i));
- }
+ if (gst_tag_get_type(tag) == G_TYPE_STRING) {
+ if (!gst_tag_list_get_string_index(list, tag, i, &str))
+ g_assert_not_reached();
+ } else
+ str = g_strdup_value_contents(gst_tag_list_get_value_index(list, tag, i));
- if (i == 0) {
- g_print(" %15s: %s\n", gst_tag_get_nick(tag), str);
- } else {
- g_print(" : %s\n", str);
- }
+ if (i == 0)
+ g_print(" %15s: %s\n", gst_tag_get_nick(tag), str);
+ else
+ g_print(" : %s\n", str);
- g_free(str);
- }
+ g_free(str);
+ }
}
#endif
/* check player state here */
if (MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_PAUSED &&
- MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_PLAYING)
- {
+ MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_PLAYING) {
/* give warning now only */
LOGW("be careful. content attributes may not available in this state ");
}
/* get content attribute first */
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("cannot get content attribute");
return FALSE;
}
/* get update flag */
- if (flag & ATTR_MISSING_ONLY)
- {
+ if (flag & ATTR_MISSING_ONLY) {
missing_only = TRUE;
LOGD("updating missed attr only");
}
- if (flag & ATTR_ALL)
- {
+ if (flag & ATTR_ALL) {
all = TRUE;
has_duration = FALSE;
has_video_attrs = FALSE;
LOGD("updating all attrs");
}
- if (missing_only && all)
- {
+ if (missing_only && all) {
LOGW("cannot use ATTR_MISSING_ONLY and ATTR_ALL. ignoring ATTR_MISSING_ONLY flag!");
missing_only = FALSE;
}
- if ((flag & ATTR_DURATION) || (!has_duration && missing_only) || all)
- {
+ if ((flag & ATTR_DURATION) || (!has_duration && missing_only) || all) {
LOGD("try to update duration");
has_duration = FALSE;
- if (gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &dur_nsec))
- {
+ if (gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &dur_nsec)) {
player->duration = dur_nsec;
LOGW("duration : %lld msec", GST_TIME_AS_MSECONDS(dur_nsec));
}
mm_attrs_set_int_by_name(attrs, "streaming_type", stream_service_type);
/* check duration is OK */
- if (dur_nsec == 0 && !MMPLAYER_IS_LIVE_STREAMING(player))
- {
+ if (dur_nsec == 0 && !MMPLAYER_IS_LIVE_STREAMING(player)) {
/* FIXIT : find another way to get duration here. */
LOGE("finally it's failed to get duration from pipeline. progressbar will not work correctely!");
- }
- else
- {
+ } else {
/*update duration */
mm_attrs_set_int_by_name(attrs, "content_duration", GST_TIME_AS_MSECONDS(dur_nsec));
has_duration = TRUE;
}
}
- if ((flag & ATTR_AUDIO) || (!has_audio_attrs && missing_only) || all)
- {
+ if ((flag & ATTR_AUDIO) || (!has_audio_attrs && missing_only) || all) {
/* update audio params
NOTE : We need original audio params and it can be only obtained from src pad of audio
decoder. Below code only valid when we are not using 'resampler' just before
has_audio_attrs = FALSE;
if (player->pipeline->audiobin &&
- player->pipeline->audiobin[MMPLAYER_A_SINK].gst)
- {
+ player->pipeline->audiobin[MMPLAYER_A_SINK].gst) {
GstCaps *caps_a = NULL;
GstPad* pad = NULL;
gint samplerate = 0, channels = 0;
pad = gst_element_get_static_pad(
player->pipeline->audiobin[MMPLAYER_A_CONV].gst, "sink");
- if (pad)
- {
+ if (pad) {
caps_a = gst_pad_get_current_caps(pad);
- if (caps_a)
- {
+ if (caps_a) {
p = gst_caps_get_structure(caps_a, 0);
mm_attrs_get_int_by_name(attrs, "content_audio_samplerate", &samplerate);
caps_a = NULL;
has_audio_attrs = TRUE;
- }
- else
- {
+ } else
LOGW("not ready to get audio caps");
- }
gst_object_unref(pad);
- }
- else
- {
+ } else
LOGW("failed to get pad from audiosink");
- }
}
}
- if ((flag & ATTR_VIDEO) || (!has_video_attrs && missing_only) || all)
- {
+ if ((flag & ATTR_VIDEO) || (!has_video_attrs && missing_only) || all) {
LOGD("try to update video attrs");
has_video_attrs = FALSE;
if (player->pipeline->videobin &&
- player->pipeline->videobin[MMPLAYER_V_SINK].gst)
- {
+ player->pipeline->videobin[MMPLAYER_V_SINK].gst) {
GstCaps *caps_v = NULL;
GstPad* pad = NULL;
gint tmpNu, tmpDe;
gint width, height;
pad = gst_element_get_static_pad(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "sink");
- if (pad)
- {
+ if (pad) {
caps_v = gst_pad_get_current_caps(pad);
/* Use v_stream_caps, if fail to get video_sink sink pad*/
- if (!caps_v && player->v_stream_caps)
- {
+ if (!caps_v && player->v_stream_caps) {
caps_v = player->v_stream_caps;
gst_caps_ref(caps_v);
}
- if (caps_v)
- {
+ if (caps_v) {
p = gst_caps_get_structure(caps_v, 0);
gst_structure_get_int(p, "width", &width);
mm_attrs_set_int_by_name(attrs, "content_video_width", width);
gst_caps_unref(caps_v);
caps_v = NULL;
- if (tmpDe > 0)
- {
+ if (tmpDe > 0) {
mm_attrs_set_int_by_name(attrs, "content_video_fps", tmpNu / tmpDe);
SECURE_LOGD("fps : %d", tmpNu / tmpDe);
}
has_video_attrs = TRUE;
- }
- else
- {
+ } else
LOGD("no negitiated caps from videosink");
- }
gst_object_unref(pad);
pad = NULL;
- }
- else
- {
+ } else
LOGD("no videosink sink pad");
- }
}
}
- if ((flag & ATTR_BITRATE) || (!has_bitrate && missing_only) || all)
- {
+ if ((flag & ATTR_BITRATE) || (!has_bitrate && missing_only) || all) {
has_bitrate = FALSE;
/* FIXIT : please make it clear the dependancy with duration/codec/uritype */
- if (player->duration)
- {
+ if (player->duration) {
guint64 data_size = 0;
- if (!MMPLAYER_IS_STREAMING(player) && (player->can_support_codec & FOUND_PLUGIN_VIDEO))
- {
+ if (!MMPLAYER_IS_STREAMING(player) && (player->can_support_codec & FOUND_PLUGIN_VIDEO)) {
mm_attrs_get_string_by_name(attrs, "profile_uri", &path);
if (stat(path, &sb) == 0)
- {
data_size = (guint64)sb.st_size;
- }
- }
- else if (MMPLAYER_IS_HTTP_STREAMING(player))
- {
+ } else if (MMPLAYER_IS_HTTP_STREAMING(player))
data_size = player->http_content_size;
- }
LOGD("try to update bitrate : data_size = %lld", data_size);
- if (data_size)
- {
+ if (data_size) {
guint64 bitrate = 0;
guint64 msec_dur = 0;
has_bitrate = TRUE;
}
- if (MMPLAYER_IS_RTSP_STREAMING(player))
- {
- if (player->total_bitrate)
- {
+ if (MMPLAYER_IS_RTSP_STREAMING(player)) {
+ if (player->total_bitrate) {
mm_attrs_set_int_by_name(attrs, "content_video_bitrate", player->total_bitrate);
has_bitrate = TRUE;
}
}
/* validate all */
- if ( mmf_attrs_commit(attrs))
- {
+ if (mmf_attrs_commit(attrs)) {
LOGE("failed to update attributes\n");
return FALSE;
}
return STREAMING_SERVICE_NONE;
if (MMPLAYER_IS_HTTP_STREAMING(player))
- {
streaming_type = (player->duration == 0) ?
STREAMING_SERVICE_LIVE : STREAMING_SERVICE_VOD;
- }
- switch (streaming_type)
- {
- case STREAMING_SERVICE_LIVE:
- LOGD("it's live streaming");
+ switch (streaming_type) {
+ case STREAMING_SERVICE_LIVE:
+ LOGD("it's live streaming");
break;
- case STREAMING_SERVICE_VOD:
- LOGD("it's vod streaming");
+ case STREAMING_SERVICE_VOD:
+ LOGD("it's vod streaming");
break;
- case STREAMING_SERVICE_NONE:
- LOGE("should not get here");
+ case STREAMING_SERVICE_NONE:
+ LOGE("should not get here");
break;
- default:
- LOGE("should not get here");
+ default:
+ LOGE("should not get here");
}
player->streaming_type = streaming_type;
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- if (MMPLAYER_CURRENT_STATE(player) == state)
- {
+ if (MMPLAYER_CURRENT_STATE(player) == state) {
LOGW("already same state(%s)\n", MMPLAYER_STATE_GET_NAME(state));
MMPLAYER_PENDING_STATE(player) = MM_PLAYER_STATE_NONE;
return ret;
interrupted_by_focus = player->sound_focus.by_asm_cb;
interrupted_by_resource = player->resource_manager.by_rm_cb;
- switch (MMPLAYER_CURRENT_STATE(player))
- {
- case MM_PLAYER_STATE_NULL:
- case MM_PLAYER_STATE_READY:
+ switch (MMPLAYER_CURRENT_STATE(player)) {
+ case MM_PLAYER_STATE_NULL:
+ case MM_PLAYER_STATE_READY:
{
- if (player->cmd == MMPLAYER_COMMAND_STOP)
- {
+ if (player->cmd == MMPLAYER_COMMAND_STOP) {
sound_result = _mmplayer_sound_release_focus(&player->sound_focus);
- if (sound_result != MM_ERROR_NONE)
- {
+ if (sound_result != MM_ERROR_NONE) {
LOGE("failed to release sound focus\n");
return MM_ERROR_POLICY_INTERNAL;
}
}
break;
- case MM_PLAYER_STATE_PAUSED:
+ case MM_PLAYER_STATE_PAUSED:
{
- if (!player->sent_bos)
- {
+ if (!player->sent_bos) {
int found = 0;
#define MMPLAYER_MAX_SOUND_PRIORITY 3
_mmplayer_update_content_attrs(player, ATTR_ALL);
/* set max sound priority to keep own sound and not to mute other's one */
mm_attrs_get_int_by_name(player->attrs, "content_video_found", &found);
- if (found)
- {
+ if (found) {
mm_attrs_get_int_by_name(player->attrs, "content_audio_found", &found);
- if (found)
- {
+ if (found) {
LOGD("set max audio priority");
g_object_set(player->pipeline->audiobin[MMPLAYER_A_SINK].gst, "priority", MMPLAYER_MAX_SOUND_PRIORITY, NULL);
}
/* add audio callback probe if condition is satisfied */
if (!player->audio_cb_probe_id && player->set_mode.pcm_extraction && !player->audio_stream_render_cb_ex)
- {
__mmplayer_configure_audio_callback(player);
/* FIXIT : handle return value */
- }
- if (!MMPLAYER_IS_STREAMING(player) || (player->streamer && !player->streamer->is_buffering))
- {
+ if (!MMPLAYER_IS_STREAMING(player) || (player->streamer && !player->streamer->is_buffering)) {
sound_result = _mmplayer_sound_release_focus(&player->sound_focus);
- if (sound_result != MM_ERROR_NONE)
- {
+ if (sound_result != MM_ERROR_NONE) {
LOGE("failed to release sound focus\n");
return MM_ERROR_POLICY_INTERNAL;
}
}
break;
- case MM_PLAYER_STATE_PLAYING:
+ case MM_PLAYER_STATE_PLAYING:
{
/* try to get content metadata */
- if (!player->sent_bos)
- {
+ if (!player->sent_bos) {
/* NOTE : giving ATTR_MISSING_ONLY may have dependency with
* c-api since c-api doesn't use _start() anymore. It may not work propery with
* legacy mmfw-player api */
_mmplayer_update_content_attrs(player, ATTR_MISSING_ONLY);
}
- if ((player->cmd == MMPLAYER_COMMAND_START) || (player->cmd == MMPLAYER_COMMAND_RESUME))
- {
+ if ((player->cmd == MMPLAYER_COMMAND_START) || (player->cmd == MMPLAYER_COMMAND_RESUME)) {
if (!player->sent_bos)
- {
__mmplayer_handle_missed_plugin(player);
- }
sound_result = _mmplayer_sound_acquire_focus(&player->sound_focus);
- if (sound_result != MM_ERROR_NONE)
- {
+ if (sound_result != MM_ERROR_NONE) {
// FIXME : need to check history
- if (player->pipeline->videobin)
- {
+ if (player->pipeline->videobin) {
MMMessageParamType msg = {0, };
LOGE("failed to go ahead because of video conflict\n");
MMPLAYER_POST_MSG(player, MM_MESSAGE_STATE_INTERRUPTED, &msg);
_mmplayer_unrealize((MMHandleType)player);
- }
- else
- {
+ } else {
LOGE("failed to play by sound focus error : 0x%X\n", sound_result);
_mmplayer_pause((MMHandleType)player);
return sound_result;
}
}
- if (player->resumed_by_rewind && player->playback_rate < 0.0)
- {
+ if (player->resumed_by_rewind && player->playback_rate < 0.0) {
/* initialize because auto resume is done well. */
player->resumed_by_rewind = FALSE;
player->playback_rate = 1.0;
}
- if (!player->sent_bos)
- {
+ if (!player->sent_bos) {
/* check audio codec field is set or not
* we can get it from typefinder or codec's caps.
*/
* Because, parser don't make related TAG.
* So, if it's not set yet, fill it with found data.
*/
- if (!audio_codec)
- {
+ if (!audio_codec) {
if (g_strrstr(player->type, "audio/midi"))
- {
audio_codec = g_strdup("MIDI");
-
- }
else if (g_strrstr(player->type, "audio/x-amr"))
- {
audio_codec = g_strdup("AMR");
- }
else if (g_strrstr(player->type, "audio/mpeg") && !g_strrstr(player->type, "mpegversion= (int)1"))
- {
audio_codec = g_strdup("AAC");
- }
else
- {
audio_codec = g_strdup("unknown");
- }
mm_attrs_set_string_by_name(player->attrs, "content_audio_codec", audio_codec);
MMPLAYER_FREEIF(audio_codec);
}
break;
- case MM_PLAYER_STATE_NONE:
- default:
- LOGW("invalid target state, there is nothing to do.\n");
- break;
+ case MM_PLAYER_STATE_NONE:
+ default:
+ LOGW("invalid target state, there is nothing to do.\n");
+ break;
}
/* post message to application */
- if (MMPLAYER_TARGET_STATE(player) == state)
- {
+ if (MMPLAYER_TARGET_STATE(player) == state) {
/* fill the message with state of player */
msg.state.previous = MMPLAYER_PREV_STATE(player);
msg.state.current = MMPLAYER_CURRENT_STATE(player);
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 || interrupted_by_resource) {
msg.union_type = MM_MSG_UNION_CODE;
if (interrupted_by_focus)
msg.code = player->sound_focus.focus_changed_msg; /* FIXME: player.c convert function have to be modified. */
else if (interrupted_by_resource)
msg.code = MM_MSG_CODE_INTERRUPTED_BY_RESOURCE_CONFLICT;
MMPLAYER_POST_MSG(player, MM_MESSAGE_STATE_INTERRUPTED, &msg);
- }
- /* state changed by usecase */
- else
- {
+ } else /* state changed by usecase */
MMPLAYER_POST_MSG(player, MM_MESSAGE_STATE_CHANGED, &msg);
- }
- }
- else
- {
+ } else {
LOGD("intermediate state, do nothing.\n");
MMPLAYER_PRINT_STATE(player);
return ret;
}
- if (post_bos)
- {
+ if (post_bos) {
MMPLAYER_POST_MSG(player, MM_MESSAGE_BEGIN_OF_STREAM, NULL);
player->sent_bos = TRUE;
}
MMPLAYER_RETURN_VAL_IF_FAIL(player, NULL);
g_mutex_lock(&player->next_play_thread_mutex);
- while (!player->next_play_thread_exit)
- {
+ while (!player->next_play_thread_exit) {
LOGD("next play thread started. waiting for signal.\n");
g_cond_wait(&player->next_play_thread_cond, &player->next_play_thread_mutex);
LOGD("reconfigure pipeline for gapless play.\n");
- if (player->next_play_thread_exit)
- {
- if (player->gapless.reconfigure)
- {
+ if (player->next_play_thread_exit) {
+ if (player->gapless.reconfigure) {
player->gapless.reconfigure = false;
MMPLAYER_PLAYBACK_UNLOCK(player);
}
MMPLAYER_RETURN_VAL_IF_FAIL(player, NULL);
g_mutex_lock(&player->repeat_thread_mutex);
- while (!player->repeat_thread_exit)
- {
+ while (!player->repeat_thread_exit) {
LOGD("repeat thread started. waiting for signal.\n");
g_cond_wait(&player->repeat_thread_cond, &player->repeat_thread_mutex);
- if (player->repeat_thread_exit)
- {
+ if (player->repeat_thread_exit) {
LOGD("exiting repeat thread\n");
break;
}
attrs = MMPLAYER_GET_ATTRS(player);
- if (mm_attrs_get_int_by_name(attrs, "profile_play_count", &count) != MM_ERROR_NONE)
- {
+ if (mm_attrs_get_int_by_name(attrs, "profile_play_count", &count) != MM_ERROR_NONE) {
LOGE("can not get play count\n");
break;
}
- if (player->section_repeat)
- {
+ if (player->section_repeat) {
ret_value = _mmplayer_activate_section_repeat((MMHandleType)player, player->section_repeat_start, player->section_repeat_end);
- }
- else
- {
- if (player->playback_rate < 0.0)
- {
+ } else {
+ if (player->playback_rate < 0.0) {
player->resumed_by_rewind = TRUE;
_mmplayer_set_mute((MMHandleType)player, 0);
MMPLAYER_POST_MSG(player, MM_MESSAGE_RESUMED_BY_REW, NULL);
player->sent_bos = FALSE;
}
- if (!ret_value)
- {
+ if (!ret_value) {
LOGE("failed to set position to zero for rewind\n");
continue;
}
/* decrease play count */
- if (count > 1)
- {
+ if (count > 1) {
/* we successeded to rewind. update play count and then wait for next EOS */
count--;
/* commit attribute */
if (mmf_attrs_commit(attrs))
- {
LOGE("failed to commit attribute\n");
- }
}
/* unlock */
__gst_get_position(player, MM_PLAYER_POS_FORMAT_TIME, &pos_msec); // update last_position
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("fail to get attributes.\n");
return;
}
- if (!MMPLAYER_IS_STREAMING(player) && (player->can_support_codec & FOUND_PLUGIN_VIDEO))
- {
+ if (!MMPLAYER_IS_STREAMING(player) && (player->can_support_codec & FOUND_PLUGIN_VIDEO)) {
mm_attrs_get_string_by_name(attrs, "profile_uri", &path);
if (stat(path, &sb) == 0)
- {
data_size = (guint64)sb.st_size;
- }
- }
- else if (MMPLAYER_IS_HTTP_STREAMING(player))
- {
+ } else if (MMPLAYER_IS_HTTP_STREAMING(player))
data_size = player->http_content_size;
- }
- __mm_player_streaming_buffering( player->streamer,
+ __mm_player_streaming_buffering(player->streamer,
buffering_msg,
data_size,
player->last_position,
MMPlayerStateType target_state = MM_PLAYER_STATE_NONE;
MMPlayerStateType pending_state = MM_PLAYER_STATE_NONE;
- if (!player || !player->streamer || (MMPLAYER_IS_LIVE_STREAMING(player) && MMPLAYER_IS_RTSP_STREAMING(player)))
- {
+ if (!player || !player->streamer || (MMPLAYER_IS_LIVE_STREAMING(player) && MMPLAYER_IS_RTSP_STREAMING(player))) {
LOGW("do nothing for buffering msg\n");
ret = MM_ERROR_PLAYER_INVALID_STATE;
goto exit;
MMPLAYER_STATE_GET_NAME(target_state),
player->streamer->is_buffering);
- if (!player->streamer->is_buffering)
- {
+ if (!player->streamer->is_buffering) {
/* NOTE : if buffering has done, player has to go to target state. */
- switch (target_state)
- {
- case MM_PLAYER_STATE_PAUSED :
+ switch (target_state) {
+ case MM_PLAYER_STATE_PAUSED:
{
- switch (pending_state)
- {
- case MM_PLAYER_STATE_PLAYING:
- {
- __gst_pause(player, TRUE);
- }
+ switch (pending_state) {
+ case MM_PLAYER_STATE_PLAYING:
+ __gst_pause(player, TRUE);
break;
- case MM_PLAYER_STATE_PAUSED:
- {
- LOGD("player is already going to paused state, there is nothing to do.\n");
- }
+ case MM_PLAYER_STATE_PAUSED:
+ LOGD("player is already going to paused state, there is nothing to do.\n");
break;
- case MM_PLAYER_STATE_NONE:
- case MM_PLAYER_STATE_NULL:
- case MM_PLAYER_STATE_READY:
- default :
- {
- LOGW("invalid pending state [%s].\n", MMPLAYER_STATE_GET_NAME(pending_state));
- }
- break;
+ case MM_PLAYER_STATE_NONE:
+ case MM_PLAYER_STATE_NULL:
+ case MM_PLAYER_STATE_READY:
+ default:
+ LOGW("invalid pending state [%s].\n", MMPLAYER_STATE_GET_NAME(pending_state));
+ break;
}
}
break;
- case MM_PLAYER_STATE_PLAYING :
+ case MM_PLAYER_STATE_PLAYING:
{
- switch (pending_state)
- {
- case MM_PLAYER_STATE_NONE:
+ switch (pending_state) {
+ case MM_PLAYER_STATE_NONE:
{
if (current_state != MM_PLAYER_STATE_PLAYING)
__gst_resume(player, TRUE);
}
break;
- case MM_PLAYER_STATE_PAUSED:
- {
- /* NOTE: It should be worked as asynchronously.
- * Because, buffering can be completed during autoplugging when pipeline would try to go playing state directly.
- */
- __gst_resume(player, TRUE);
- }
+ case MM_PLAYER_STATE_PAUSED:
+ /* NOTE: It should be worked as asynchronously.
+ * Because, buffering can be completed during autoplugging when pipeline would try to go playing state directly.
+ */
+ __gst_resume(player, TRUE);
break;
- case MM_PLAYER_STATE_PLAYING:
- {
- LOGD("player is already going to playing state, there is nothing to do.\n");
- }
+ case MM_PLAYER_STATE_PLAYING:
+ LOGD("player is already going to playing state, there is nothing to do.\n");
break;
- case MM_PLAYER_STATE_NULL:
- case MM_PLAYER_STATE_READY:
- default :
- {
- LOGW("invalid pending state [%s].\n", MMPLAYER_STATE_GET_NAME(pending_state));
- }
- break;
+ case MM_PLAYER_STATE_NULL:
+ case MM_PLAYER_STATE_READY:
+ default:
+ LOGW("invalid pending state [%s].\n", MMPLAYER_STATE_GET_NAME(pending_state));
+ break;
}
}
break;
- case MM_PLAYER_STATE_NULL :
- case MM_PLAYER_STATE_READY :
- case MM_PLAYER_STATE_NONE :
- default:
- {
- LOGW("invalid target state [%s].\n", MMPLAYER_STATE_GET_NAME(target_state));
- }
- break;
+ case MM_PLAYER_STATE_NULL:
+ case MM_PLAYER_STATE_READY:
+ case MM_PLAYER_STATE_NONE:
+ default:
+ LOGW("invalid target state [%s].\n", MMPLAYER_STATE_GET_NAME(target_state));
+ break;
}
- }
- else
- {
+ } else {
/* NOTE : during the buffering, pause the player for stopping pipeline clock.
* it's for stopping the pipeline clock to prevent dropping the data in sink element.
*/
- switch (pending_state)
- {
- case MM_PLAYER_STATE_NONE:
+ switch (pending_state) {
+ case MM_PLAYER_STATE_NONE:
{
- if (current_state != MM_PLAYER_STATE_PAUSED)
- {
+ if (current_state != MM_PLAYER_STATE_PAUSED) {
LOGD("set pause state during buffering\n");
__gst_pause(player, TRUE);
// to cover the weak-signal environment.
- if (MMPLAYER_IS_RTSP_STREAMING(player))
- {
+ if (MMPLAYER_IS_RTSP_STREAMING(player)) {
unsigned long position = 0;
gint64 pos_msec = 0;
LOGD("[RTSP] seek to the buffering start point\n");
- if (__gst_get_position(player, MM_PLAYER_POS_FORMAT_TIME, &position))
- {
+ if (__gst_get_position(player, MM_PLAYER_POS_FORMAT_TIME, &position)) {
LOGE("failed to get position\n");
break;
}
}
break;
- case MM_PLAYER_STATE_PLAYING:
- {
- __gst_pause(player, TRUE);
- }
+ case MM_PLAYER_STATE_PLAYING:
+ __gst_pause(player, TRUE);
break;
- case MM_PLAYER_STATE_PAUSED:
- {
- }
+ case MM_PLAYER_STATE_PAUSED:
break;
- case MM_PLAYER_STATE_NULL:
- case MM_PLAYER_STATE_READY:
- default :
- {
- LOGW("invalid pending state [%s].\n", MMPLAYER_STATE_GET_NAME(pending_state));
- }
- break;
+ case MM_PLAYER_STATE_NULL:
+ case MM_PLAYER_STATE_READY:
+ default:
+ LOGW("invalid pending state [%s].\n", MMPLAYER_STATE_GET_NAME(pending_state));
+ break;
}
}
textbin = player->pipeline->textbin;
- if (is_drop)
- {
+ if (is_drop) {
LOGD("Drop subtitle text after getting EOS\n");
g_object_set(textbin[MMPLAYER_T_FAKE_SINK].gst, "async", FALSE, NULL);
g_object_set(textbin[MMPLAYER_T_IDENTITY].gst, "drop-probability", (gfloat)1.0, NULL);
player->is_subtitle_force_drop = TRUE;
- }
- else
- {
- if (player->is_subtitle_force_drop == TRUE)
- {
+ } else {
+ if (player->is_subtitle_force_drop == TRUE) {
LOGD("Enable subtitle data path without drop\n");
g_object_set(textbin[MMPLAYER_T_IDENTITY].gst, "drop-probability", (gfloat)0.0, NULL);
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
MMPLAYER_RETURN_VAL_IF_FAIL(msg && GST_IS_MESSAGE(msg), FALSE);
- switch (GST_MESSAGE_TYPE(msg))
- {
- case GST_MESSAGE_UNKNOWN:
- LOGD("unknown message received\n");
+ switch (GST_MESSAGE_TYPE(msg)) {
+ case GST_MESSAGE_UNKNOWN:
+ LOGD("unknown message received\n");
break;
- case GST_MESSAGE_EOS:
+ case GST_MESSAGE_EOS:
{
MMHandleType attrs = 0;
gint count = 0;
/* NOTE : EOS event is comming multiple time. watch out it */
/* check state. we only process EOS when pipeline state goes to PLAYING */
- if (!(player->cmd == MMPLAYER_COMMAND_START || player->cmd == MMPLAYER_COMMAND_RESUME))
- {
+ if (!(player->cmd == MMPLAYER_COMMAND_START || player->cmd == MMPLAYER_COMMAND_RESUME)) {
LOGD("EOS received on non-playing state. ignoring it\n");
break;
}
- if (player->pipeline)
- {
+ if (player->pipeline) {
if (player->pipeline->textbin)
__mmplayer_drop_subtitle(player, TRUE);
- if ((player->audio_stream_cb) && (player->set_mode.pcm_extraction) && (!player->audio_stream_render_cb_ex))
- {
+ if ((player->audio_stream_cb) && (player->set_mode.pcm_extraction) && (!player->audio_stream_render_cb_ex)) {
GstPad *pad = NULL;
pad = gst_element_get_static_pad(player->pipeline->audiobin[MMPLAYER_A_SINK].gst, "sink");
}
}
- if ((player->audio_stream_render_cb_ex) && (!player->audio_stream_sink_sync)) {
+ if ((player->audio_stream_render_cb_ex) && (!player->audio_stream_sink_sync))
__mmplayer_audio_stream_clear_buffer(player, TRUE);
- }
/* rewind if repeat count is greater then zero */
/* get play count */
attrs = MMPLAYER_GET_ATTRS(player);
- if (attrs)
- {
+ if (attrs) {
gboolean smooth_repeat = FALSE;
mm_attrs_get_int_by_name(attrs, "profile_play_count", &count);
LOGD("remaining play count: %d, playback rate: %f\n", count, player->playback_rate);
- if (count > 1 || count == -1 || player->playback_rate < 0.0) /* default value is 1 */
- {
- if (smooth_repeat)
- {
+ if (count > 1 || count == -1 || player->playback_rate < 0.0) /* default value is 1 */ {
+ if (smooth_repeat) {
LOGD("smooth repeat enabled. seeking operation will be excuted in new thread\n");
g_cond_signal(&player->repeat_thread_cond);
break;
- }
- else
- {
+ } else {
gint ret_value = 0;
- if (player->section_repeat)
- {
+ if (player->section_repeat) {
ret_value = _mmplayer_activate_section_repeat((MMHandleType)player, player->section_repeat_start, player->section_repeat_end);
- }
- else
- {
- if (player->playback_rate < 0.0)
- {
+ } else {
+ if (player->playback_rate < 0.0) {
player->resumed_by_rewind = TRUE;
_mmplayer_set_mute((MMHandleType)player, 0);
MMPLAYER_POST_MSG(player, MM_MESSAGE_RESUMED_BY_REW, NULL);
}
if (MM_ERROR_NONE != ret_value)
- {
LOGE("failed to set position to zero for rewind\n");
- }
/* not posting eos when repeating */
break;
}
break;
- case GST_MESSAGE_ERROR:
+ case GST_MESSAGE_ERROR:
{
GError *error = NULL;
gchar* debug = NULL;
/* get error code */
gst_message_parse_error(msg, &error, &debug);
- if (gst_structure_has_name(gst_message_get_structure(msg), "streaming_error"))
- {
+ if (gst_structure_has_name(gst_message_get_structure(msg), "streaming_error")) {
/* Note : the streaming error from the streaming source is handled
* using __mmplayer_handle_streaming_error.
*/
/* dump state of all element */
__mmplayer_dump_pipeline_state(player);
- }
- else
- {
+ } else {
/* traslate gst error code to msl error code. then post it
* to application if needed
*/
__mmplayer_handle_gst_error(player, msg, error);
if (debug)
- {
LOGE("error debug : %s", debug);
- }
-
}
if (MMPLAYER_IS_HTTP_PD(player))
- {
_mmplayer_unrealize_pd_downloader((MMHandleType)player);
- }
MMPLAYER_FREEIF(debug);
g_error_free(error);
}
break;
- case GST_MESSAGE_WARNING:
+ case GST_MESSAGE_WARNING:
{
char* debug = NULL;
GError* error = NULL;
}
break;
- case GST_MESSAGE_TAG:
+ case GST_MESSAGE_TAG:
{
LOGD("GST_MESSAGE_TAG\n");
if (!__mmplayer_gst_extract_tag_from_msg(player, msg))
- {
LOGW("failed to extract tags from gstmessage\n");
- }
}
break;
- case GST_MESSAGE_BUFFERING:
+ case GST_MESSAGE_BUFFERING:
{
MMMessageParamType msg_param = {0, };
}
/* ignore the prev buffering message */
- if ((player->streamer) && (player->streamer->is_buffering == FALSE) && (player->streamer->is_buffering_done == TRUE))
- {
+ if ((player->streamer) && (player->streamer->is_buffering == FALSE) && (player->streamer->is_buffering_done == TRUE)) {
gint buffer_percent = 0;
gst_message_parse_buffering(msg, &buffer_percent);
- if (buffer_percent == MAX_BUFFER_PERCENT)
- {
+ if (buffer_percent == MAX_BUFFER_PERCENT) {
LOGD("Ignored all the previous buffering msg!(got %d%%)\n", buffer_percent);
player->streamer->is_buffering_done = FALSE;
}
__mmplayer_update_buffer_setting(player, msg);
if (__mmplayer_handle_buffering_message(player) == MM_ERROR_NONE) {
-
msg_param.connection.buffering = player->streamer->buffering_percent;
MMPLAYER_POST_MSG(player, MM_MESSAGE_BUFFERING, &msg_param);
if (MMPLAYER_IS_RTSP_STREAMING(player) &&
- (player->streamer->buffering_percent >= MAX_BUFFER_PERCENT))
- {
- if (player->doing_seek)
- {
- if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PAUSED)
- {
+ (player->streamer->buffering_percent >= MAX_BUFFER_PERCENT)) {
+ if (player->doing_seek) {
+ if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PAUSED) {
player->doing_seek = FALSE;
MMPLAYER_POST_MSG(player, MM_MESSAGE_SEEK_COMPLETED, NULL);
- }
- else if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PLAYING)
- {
+ } else if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PLAYING)
async_done = TRUE;
- }
}
}
}
}
break;
- case GST_MESSAGE_STATE_CHANGED:
+ case GST_MESSAGE_STATE_CHANGED:
{
MMPlayerGstElement *mainbin;
const GValue *voldstate, *vnewstate, *vpending;
GstState newstate = GST_STATE_NULL;
GstState pending = GST_STATE_NULL;
- if (!(player->pipeline && player->pipeline->mainbin))
- {
+ if (!(player->pipeline && player->pipeline->mainbin)) {
LOGE("player pipeline handle is null");
break;
}
gst_element_state_get_name((GstState)newstate),
gst_element_state_get_name((GstState)pending));
- if (oldstate == newstate)
- {
+ if (oldstate == newstate) {
LOGD("pipeline reports state transition to old state");
break;
}
- switch (newstate)
- {
- case GST_STATE_VOID_PENDING:
+ switch (newstate) {
+ case GST_STATE_VOID_PENDING:
break;
- case GST_STATE_NULL:
+ case GST_STATE_NULL:
break;
- case GST_STATE_READY:
+ case GST_STATE_READY:
break;
- case GST_STATE_PAUSED:
+ case GST_STATE_PAUSED:
{
gboolean prepare_async = FALSE;
if (!player->audio_cb_probe_id && player->set_mode.pcm_extraction && !player->audio_stream_render_cb_ex)
__mmplayer_configure_audio_callback(player);
- if (!player->sent_bos && oldstate == GST_STATE_READY) // managed prepare async case
- {
+ if (!player->sent_bos && oldstate == GST_STATE_READY) {
+ // managed prepare async case
mm_attrs_get_int_by_name(player->attrs, "profile_prepare_async", &prepare_async);
LOGD("checking prepare mode for async transition - %d", prepare_async);
}
- if (MMPLAYER_IS_STREAMING(player) || MMPLAYER_IS_MS_BUFF_SRC(player) || prepare_async)
- {
+ if (MMPLAYER_IS_STREAMING(player) || MMPLAYER_IS_MS_BUFF_SRC(player) || prepare_async) {
MMPLAYER_SET_STATE(player, MM_PLAYER_STATE_PAUSED);
if (MMPLAYER_IS_STREAMING(player) && (player->streamer))
- {
__mm_player_streaming_set_content_bitrate(player->streamer,
player->total_maximum_bitrate, player->total_bitrate);
- }
}
}
break;
- case GST_STATE_PLAYING:
+ case GST_STATE_PLAYING:
{
- if (MMPLAYER_IS_STREAMING(player)) // managed prepare async case when buffering is completed
- {
+ if (MMPLAYER_IS_STREAMING(player)) {
+ // managed prepare async case when buffering is completed
// pending state should be reset oyherwise, it's still playing even though it's resumed after bufferging.
if ((MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_PLAYING) ||
(MMPLAYER_PENDING_STATE(player) == MM_PLAYER_STATE_PLAYING))
- {
MMPLAYER_SET_STATE(player, MM_PLAYER_STATE_PLAYING);
- }
}
- if (player->gapless.stream_changed)
- {
+ if (player->gapless.stream_changed) {
_mmplayer_update_content_attrs(player, ATTR_ALL);
player->gapless.stream_changed = FALSE;
}
- if (player->doing_seek && async_done)
- {
+ if (player->doing_seek && async_done) {
player->doing_seek = FALSE;
async_done = FALSE;
MMPLAYER_POST_MSG(player, MM_MESSAGE_SEEK_COMPLETED, NULL);
}
break;
- default:
+ default:
break;
}
}
break;
- case GST_MESSAGE_CLOCK_LOST:
+ case GST_MESSAGE_CLOCK_LOST:
{
GstClock *clock = NULL;
gboolean need_new_clock = FALSE;
LOGD("GST_MESSAGE_CLOCK_LOST : %s\n", (clock ? GST_OBJECT_NAME(clock) : "NULL"));
if (!player->videodec_linked)
- {
need_new_clock = TRUE;
- }
else if (!player->ini.use_system_clock)
- {
need_new_clock = TRUE;
- }
if (need_new_clock) {
LOGD("Provide clock is TRUE, do pause->resume\n");
}
break;
- case GST_MESSAGE_NEW_CLOCK:
+ case GST_MESSAGE_NEW_CLOCK:
{
GstClock *clock = NULL;
gst_message_parse_new_clock(msg, &clock);
}
break;
- case GST_MESSAGE_ELEMENT:
+ case GST_MESSAGE_ELEMENT:
{
const gchar *structure_name;
gint count = 0;
MMHandleType attrs = 0;
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("cannot get content attribute");
ret = FALSE;
break;
if (!structure_name)
break;
- if (!strcmp(structure_name, "prepare-decode-buffers"))
- {
+ if (!strcmp(structure_name, "prepare-decode-buffers")) {
gint num_buffers = 0;
gint extra_num_buffers = 0;
break;
}
- if (!strcmp(structure_name, "Language_list"))
- {
+ if (!strcmp(structure_name, "Language_list")) {
const GValue *lang_list = NULL;
lang_list = gst_structure_get_value(gst_message_get_structure(msg), "lang_list");
- if (lang_list != NULL)
- {
+ if (lang_list != NULL) {
count = g_list_length((GList *)g_value_get_pointer(lang_list));
if (count > 1)
- LOGD("Total audio tracks(from parser) = %d \n",count);
+ LOGD("Total audio tracks(from parser) = %d \n", count);
}
}
- if (!strcmp(structure_name, "Ext_Sub_Language_List"))
- {
+ if (!strcmp(structure_name, "Ext_Sub_Language_List")) {
const GValue *lang_list = NULL;
MMPlayerLangStruct *temp = NULL;
lang_list = gst_structure_get_value(gst_message_get_structure(msg), "lang_list");
- if (lang_list != NULL)
- {
+ if (lang_list != NULL) {
count = g_list_length((GList *)g_value_get_pointer(lang_list));
- if (count)
- {
+ if (count) {
player->subtitle_language_list = (GList *)g_value_get_pointer(lang_list);
mm_attrs_set_int_by_name(attrs, "content_text_track_num", (gint)count);
if (mmf_attrs_commit(attrs))
LOGE("failed to commit.\n");
LOGD("Total subtitle tracks = %d \n", count);
}
- while (count)
- {
+ while (count) {
temp = g_list_nth_data(player->subtitle_language_list, count - 1);
if (temp)
- {
LOGD("value of lang_key is %s and lang_code is %s",
temp->language_key, temp->language_code);
- }
count--;
}
}
}
break;
- case GST_MESSAGE_DURATION_CHANGED:
+ case GST_MESSAGE_DURATION_CHANGED:
{
LOGD("GST_MESSAGE_DURATION_CHANGED\n");
ret = __mmplayer_gst_handle_duration(player, msg);
if (!ret)
- {
LOGW("failed to update duration");
- }
}
break;
- case GST_MESSAGE_ASYNC_START:
- {
+ case GST_MESSAGE_ASYNC_START:
LOGD("GST_MESSAGE_ASYNC_START : %s\n", GST_ELEMENT_NAME(GST_MESSAGE_SRC(msg)));
- }
break;
- case GST_MESSAGE_ASYNC_DONE:
+ case GST_MESSAGE_ASYNC_DONE:
{
LOGD("GST_MESSAGE_ASYNC_DONE : %s\n", GST_ELEMENT_NAME(GST_MESSAGE_SRC(msg)));
if (msg->src != (GstObject *)player->pipeline->mainbin[MMPLAYER_M_PIPE].gst)
break;
- if (player->doing_seek)
- {
- if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PAUSED)
- {
+ if (player->doing_seek) {
+ if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PAUSED) {
player->doing_seek = FALSE;
MMPLAYER_POST_MSG(player, MM_MESSAGE_SEEK_COMPLETED, NULL);
- }
- else if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PLAYING)
- {
+ } else if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PLAYING) {
if ((MMPLAYER_IS_HTTP_STREAMING(player)) &&
(player->streamer) &&
(player->streamer->streaming_buffer_type == BUFFER_TYPE_MUXED) &&
- (player->streamer->is_buffering == FALSE))
- {
+ (player->streamer->is_buffering == FALSE)) {
GstQuery *query = NULL;
gboolean busy = FALSE;
gint percent = 0;
- if (player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer)
- {
+ if (player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer) {
query = gst_query_new_buffering(GST_FORMAT_PERCENT);
if (gst_element_query(player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer, query))
- {
gst_query_parse_buffering_percent(query, &busy, &percent);
- }
gst_query_unref(query);
LOGD("buffered percent(%s): %d\n",
GST_ELEMENT_NAME(player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer), percent);
}
- if (percent >= 100)
- {
+ if (percent >= 100) {
player->streamer->is_buffering = FALSE;
__mmplayer_handle_buffering_message(player);
}
}
break;
- #if 0 /* delete unnecessary logs */
- case GST_MESSAGE_REQUEST_STATE: LOGD("GST_MESSAGE_REQUEST_STATE\n"); break;
- case GST_MESSAGE_STEP_START: LOGD("GST_MESSAGE_STEP_START\n"); break;
- case GST_MESSAGE_QOS: LOGD("GST_MESSAGE_QOS\n"); break;
- case GST_MESSAGE_PROGRESS: LOGD("GST_MESSAGE_PROGRESS\n"); break;
- case GST_MESSAGE_ANY: LOGD("GST_MESSAGE_ANY\n"); break;
- case GST_MESSAGE_INFO: LOGD("GST_MESSAGE_STATE_DIRTY\n"); break;
- case GST_MESSAGE_STATE_DIRTY: LOGD("GST_MESSAGE_STATE_DIRTY\n"); break;
- case GST_MESSAGE_STEP_DONE: LOGD("GST_MESSAGE_STEP_DONE\n"); break;
- case GST_MESSAGE_CLOCK_PROVIDE: LOGD("GST_MESSAGE_CLOCK_PROVIDE\n"); break;
- case GST_MESSAGE_STRUCTURE_CHANGE: LOGD("GST_MESSAGE_STRUCTURE_CHANGE\n"); break;
- case GST_MESSAGE_STREAM_STATUS: LOGD("GST_MESSAGE_STREAM_STATUS\n"); break;
- case GST_MESSAGE_APPLICATION: LOGD("GST_MESSAGE_APPLICATION\n"); break;
- case GST_MESSAGE_SEGMENT_START: LOGD("GST_MESSAGE_SEGMENT_START\n"); break;
- case GST_MESSAGE_SEGMENT_DONE: LOGD("GST_MESSAGE_SEGMENT_DONE\n"); break;
- case GST_MESSAGE_LATENCY: LOGD("GST_MESSAGE_LATENCY\n"); break;
- #endif
+ #if 0 /* delete unnecessary logs */
+ case GST_MESSAGE_REQUEST_STATE: LOGD("GST_MESSAGE_REQUEST_STATE\n"); break;
+ case GST_MESSAGE_STEP_START: LOGD("GST_MESSAGE_STEP_START\n"); break;
+ case GST_MESSAGE_QOS: LOGD("GST_MESSAGE_QOS\n"); break;
+ case GST_MESSAGE_PROGRESS: LOGD("GST_MESSAGE_PROGRESS\n"); break;
+ case GST_MESSAGE_ANY: LOGD("GST_MESSAGE_ANY\n"); break;
+ case GST_MESSAGE_INFO: LOGD("GST_MESSAGE_STATE_DIRTY\n"); break;
+ case GST_MESSAGE_STATE_DIRTY: LOGD("GST_MESSAGE_STATE_DIRTY\n"); break;
+ case GST_MESSAGE_STEP_DONE: LOGD("GST_MESSAGE_STEP_DONE\n"); break;
+ case GST_MESSAGE_CLOCK_PROVIDE: LOGD("GST_MESSAGE_CLOCK_PROVIDE\n"); break;
+ case GST_MESSAGE_STRUCTURE_CHANGE: LOGD("GST_MESSAGE_STRUCTURE_CHANGE\n"); break;
+ case GST_MESSAGE_STREAM_STATUS: LOGD("GST_MESSAGE_STREAM_STATUS\n"); break;
+ case GST_MESSAGE_APPLICATION: LOGD("GST_MESSAGE_APPLICATION\n"); break;
+ case GST_MESSAGE_SEGMENT_START: LOGD("GST_MESSAGE_SEGMENT_START\n"); break;
+ case GST_MESSAGE_SEGMENT_DONE: LOGD("GST_MESSAGE_SEGMENT_DONE\n"); break;
+ case GST_MESSAGE_LATENCY: LOGD("GST_MESSAGE_LATENCY\n"); break;
+ #endif
- default:
+ default:
break;
}
MMPLAYER_RETURN_VAL_IF_FAIL(msg, FALSE);
if ((MMPLAYER_IS_HTTP_STREAMING(player)) &&
- (msg->src) && (msg->src == (GstObject *)player->pipeline->mainbin[MMPLAYER_M_SRC].gst))
- {
+ (msg->src) && (msg->src == (GstObject *)player->pipeline->mainbin[MMPLAYER_M_SRC].gst)) {
LOGD("msg src : [%s]", GST_ELEMENT_NAME(GST_ELEMENT_CAST(msg->src)));
- if (gst_element_query_duration(GST_ELEMENT_CAST(msg->src), GST_FORMAT_BYTES, &bytes))
- {
+ if (gst_element_query_duration(GST_ELEMENT_CAST(msg->src), GST_FORMAT_BYTES, &bytes)) {
LOGD("data total size of http content: %lld", bytes);
- player->http_content_size = (bytes > 0)?(bytes):(0);
+ player->http_content_size = (bytes > 0) ? (bytes) : (0);
}
- }
- else
- {
+ } else
/* handling audio clip which has vbr. means duration is keep changing */
_mmplayer_update_content_attrs(player, ATTR_DURATION);
- }
MMPLAYER_FLEAVE();
/* macro for better code readability */
#define MMPLAYER_UPDATE_TAG_STRING(gsttag, attribute, playertag) \
-if (gst_tag_list_get_string(tag_list, gsttag, &string)) \
-{\
- if (string != NULL)\
- {\
+if (gst_tag_list_get_string(tag_list, gsttag, &string)) {\
+ if (string != NULL) {\
SECURE_LOGD("update tag string : %s\n", string); \
mm_attrs_set_string_by_name(attribute, playertag, string); \
g_free(string);\
string = NULL;\
- }\
+ } \
}
#define MMPLAYER_UPDATE_TAG_IMAGE(gsttag, attribute, playertag) \
GstSample *sample = NULL;\
-if (gst_tag_list_get_sample_index(tag_list, gsttag, index, &sample))\
-{\
+if (gst_tag_list_get_sample_index(tag_list, gsttag, index, &sample)) {\
GstMapInfo info = GST_MAP_INFO_INIT;\
buffer = gst_sample_get_buffer(sample);\
- if (!gst_buffer_map(buffer, &info, GST_MAP_READ)){\
+ if (!gst_buffer_map(buffer, &info, GST_MAP_READ)) {\
LOGD("failed to get image data from tag");\
return FALSE;\
- }\
+ } \
SECURE_LOGD("update album cover data : %p, size : %d\n", info.data, info.size);\
- MMPLAYER_FREEIF(player->album_art); \
- player->album_art = (gchar *)g_malloc(info.size); \
- if (player->album_art) \
- { \
- memcpy(player->album_art, info.data, info.size); \
- mm_attrs_set_data_by_name(attribute, playertag, (void *)player->album_art, info.size); \
- if (MMPLAYER_IS_HTTP_LIVE_STREAMING(player)) \
- { \
- msg_param.data = (void *)player->album_art; \
- msg_param.size = info.size; \
- MMPLAYER_POST_MSG(player, MM_MESSAGE_IMAGE_BUFFER, &msg_param); \
- SECURE_LOGD("post message image buffer data : %p, size : %d\n", info.data, info.size); \
+ MMPLAYER_FREEIF(player->album_art);\
+ player->album_art = (gchar *)g_malloc(info.size);\
+ if (player->album_art) {\
+ memcpy(player->album_art, info.data, info.size);\
+ mm_attrs_set_data_by_name(attribute, playertag, (void *)player->album_art, info.size);\
+ if (MMPLAYER_IS_HTTP_LIVE_STREAMING(player)) {\
+ msg_param.data = (void *)player->album_art;\
+ msg_param.size = info.size;\
+ MMPLAYER_POST_MSG(player, MM_MESSAGE_IMAGE_BUFFER, &msg_param);\
+ SECURE_LOGD("post message image buffer data : %p, size : %d\n", info.data, info.size);\
} \
} \
- gst_buffer_unmap(buffer, &info); \
+ gst_buffer_unmap(buffer, &info);\
}
#define MMPLAYER_UPDATE_TAG_UINT(gsttag, attribute, playertag) \
-if (gst_tag_list_get_uint(tag_list, gsttag, &v_uint))\
-{\
- if (v_uint)\
- {\
- if (!strncmp(gsttag, GST_TAG_BITRATE, strlen(GST_TAG_BITRATE))) \
- {\
+if (gst_tag_list_get_uint(tag_list, gsttag, &v_uint)) {\
+ if (v_uint) {\
+ if (!strncmp(gsttag, GST_TAG_BITRATE, strlen(GST_TAG_BITRATE))) {\
if (player->updated_bitrate_count == 0) \
mm_attrs_set_int_by_name(attribute, "content_audio_bitrate", v_uint); \
- if (player->updated_bitrate_count<MM_PLAYER_STREAM_COUNT_MAX) \
- {\
+ if (player->updated_bitrate_count < MM_PLAYER_STREAM_COUNT_MAX) {\
player->bitrate[player->updated_bitrate_count] = v_uint;\
player->total_bitrate += player->bitrate[player->updated_maximum_bitrate_count]; \
player->updated_bitrate_count++; \
mm_attrs_set_int_by_name(attribute, playertag, player->total_bitrate);\
SECURE_LOGD("update bitrate %d[bps] of stream #%d.\n", v_uint, player->updated_bitrate_count);\
- }\
- }\
- else if (!strncmp(gsttag, GST_TAG_MAXIMUM_BITRATE, strlen(GST_TAG_MAXIMUM_BITRATE))) \
- {\
- if (player->updated_maximum_bitrate_count<MM_PLAYER_STREAM_COUNT_MAX) \
- {\
+ } \
+ } \
+ else if (!strncmp(gsttag, GST_TAG_MAXIMUM_BITRATE, strlen(GST_TAG_MAXIMUM_BITRATE))) {\
+ if (player->updated_maximum_bitrate_count < MM_PLAYER_STREAM_COUNT_MAX) {\
player->maximum_bitrate[player->updated_maximum_bitrate_count] = v_uint;\
player->total_maximum_bitrate += player->maximum_bitrate[player->updated_maximum_bitrate_count]; \
player->updated_maximum_bitrate_count++; \
mm_attrs_set_int_by_name(attribute, playertag, player->total_maximum_bitrate); \
SECURE_LOGD("update maximum bitrate %d[bps] of stream #%d\n", v_uint, player->updated_maximum_bitrate_count);\
- }\
- }\
- else\
- {\
+ } \
+ } else\
mm_attrs_set_int_by_name(attribute, playertag, v_uint); \
- }\
v_uint = 0;\
- }\
+ } \
}
#define MMPLAYER_UPDATE_TAG_DATE(gsttag, attribute, playertag) \
-if (gst_tag_list_get_date(tag_list, gsttag, &date))\
-{\
- if (date != NULL)\
- {\
+if (gst_tag_list_get_date(tag_list, gsttag, &date)) {\
+ if (date != NULL) {\
string = g_strdup_printf("%d", g_date_get_year(date));\
mm_attrs_set_string_by_name(attribute, playertag, string);\
SECURE_LOGD("metainfo year : %s\n", string);\
MMPLAYER_FREEIF(string);\
g_date_free(date);\
- }\
+ } \
}
#define MMPLAYER_UPDATE_TAG_UINT64(gsttag, attribute, playertag) \
-if (gst_tag_list_get_uint64(tag_list, gsttag, &v_uint64))\
-{\
- if (v_uint64)\
- {\
+if (gst_tag_list_get_uint64(tag_list, gsttag, &v_uint64)) {\
+ if (v_uint64) {\
/* FIXIT : don't know how to store date */\
g_assert(1);\
v_uint64 = 0;\
- }\
+ } \
}
#define MMPLAYER_UPDATE_TAG_DOUBLE(gsttag, attribute, playertag) \
-if (gst_tag_list_get_double(tag_list, gsttag, &v_double))\
-{\
- if (v_double)\
- {\
+if (gst_tag_list_get_double(tag_list, gsttag, &v_double)) {\
+ if (v_double) {\
/* FIXIT : don't know how to store date */\
g_assert(1);\
v_double = 0;\
- }\
+ } \
}
/* function start */
* [3] typefinding has happend in audio but audiosink is created already before no-more-pad signal
* and the video will be dumped via filesink.
*/
- if (player->num_dynamic_pad == 0)
- {
+ if (player->num_dynamic_pad == 0) {
LOGD("it seems pad caps is directely used for autoplugging. removing fakesink now\n");
if (!__mmplayer_gst_remove_fakesink(player,
&player->pipeline->mainbin[MMPLAYER_M_SRC_FAKESINK]))
- {
/* NOTE : __mmplayer_pipeline_complete() can be called several time. because
* signaling mechanism(pad-added, no-more-pad, new-decoded-pad) from various
* source element are not same. To overcome this situation, this function will called
* several places and several times. Therefore, this is not an error case.
*/
return;
- }
}
/* create dot before error-return. for debugging */
g_mutex_lock(&player->fsink_lock);
if (!fakesink->gst)
- {
goto ERROR;
- }
/* get parent of fakesink */
parent = (GstElement*)gst_object_get_parent((GstObject*)fakesink->gst);
- if (!parent)
- {
+ if (!parent) {
LOGD("fakesink already removed\n");
goto ERROR;
}
* so no need to wait for completion of state transiton
*/
if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(fakesink->gst, GST_STATE_NULL))
- {
LOGE("fakesink state change failure!\n");
-
/* FIXIT : should I return here? or try to proceed to next? */
/* return FALSE; */
- }
/* remove fakesink from it's parent */
- if (!gst_bin_remove(GST_BIN(parent), fakesink->gst))
- {
+ if (!gst_bin_remove(GST_BIN(parent), fakesink->gst)) {
LOGE("failed to remove fakesink\n");
gst_object_unref(parent);
ERROR:
if (fakesink->gst)
- {
gst_element_set_locked_state(fakesink->gst, FALSE);
- }
g_mutex_unlock(&player->fsink_lock);
return FALSE;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(element && pad);
- MMPLAYER_RETURN_IF_FAIL( player &&
+ MMPLAYER_RETURN_IF_FAIL(player &&
player->pipeline &&
player->pipeline->mainbin);
str = gst_caps_get_structure(caps, 0);
- if (!str)
- {
+ if (!str) {
LOGE("cannot get structure from caps.\n");
goto ERROR;
}
name = gst_structure_get_name(str);
- if (!name)
- {
+ if (!name) {
LOGE("cannot get mimetype from structure.\n");
goto ERROR;
}
- if (strstr(name, "video"))
- {
+ if (strstr(name, "video")) {
gint stype = 0;
mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &stype);
- if (stype == MM_DISPLAY_SURFACE_NULL || stype == MM_DISPLAY_SURFACE_REMOTE)
- {
- if (player->v_stream_caps)
- {
+ if (stype == MM_DISPLAY_SURFACE_NULL || stype == MM_DISPLAY_SURFACE_REMOTE) {
+ if (player->v_stream_caps) {
gst_caps_unref(player->v_stream_caps);
player->v_stream_caps = NULL;
}
/* clear previous result*/
player->have_dynamic_pad = FALSE;
- if (!__mmplayer_try_to_plug_decodebin(player, pad, caps))
- {
+ if (!__mmplayer_try_to_plug_decodebin(player, pad, caps)) {
LOGE("failed to autoplug for caps");
goto ERROR;
}
/* check if there's dynamic pad*/
- if (player->have_dynamic_pad)
- {
+ if (player->have_dynamic_pad) {
LOGE("using pad caps assums there's no dynamic pad !\n");
goto ERROR;
}
NEW_ELEMENT:
/* excute new_element if created*/
- if (new_element)
- {
+ if (new_element) {
LOGD("adding new element to pipeline\n");
/* set state to READY before add to bin */
MMPLAYER_ELEMENT_SET_STATE(new_element, GST_STATE_READY);
/* add new element to the pipeline */
- if (FALSE == gst_bin_add(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst), new_element) )
- {
+ if (FALSE == gst_bin_add(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst), new_element)) {
LOGE("failed to add autoplug element to bin\n");
goto ERROR;
}
/* get pad from element */
sinkpad = gst_element_get_static_pad(GST_ELEMENT(new_element), "sink");
- if (!sinkpad)
- {
+ if (!sinkpad) {
LOGE("failed to get sinkpad from autoplug element\n");
goto ERROR;
}
/* link it */
- if (GST_PAD_LINK_OK != GST_PAD_LINK(pad, sinkpad))
- {
+ if (GST_PAD_LINK_OK != GST_PAD_LINK(pad, sinkpad)) {
LOGE("failed to link autoplug element\n");
goto ERROR;
}
static void
__mmplayer_gst_wfd_dynamic_pad(GstElement *element, GstPad *pad, gpointer data) // @
{
- GstPad *sinkpad = NULL;
- GstCaps* caps = NULL;
- GstElement* new_element = NULL;
- enum MainElementID element_id = MMPLAYER_M_NUM;
-
- mm_player_t* player = (mm_player_t*) data;
-
- MMPLAYER_FENTER();
-
- MMPLAYER_RETURN_IF_FAIL(element && pad);
- MMPLAYER_RETURN_IF_FAIL( player &&
- player->pipeline &&
- player->pipeline->mainbin);
-
- LOGD("stream count inc : %d\n", player->num_dynamic_pad);
-
- {
- LOGD("using pad caps to autopluging instead of doing typefind\n");
- caps = gst_pad_query_caps(pad);
- MMPLAYER_CHECK_NULL(caps);
- /* clear previous result*/
- player->have_dynamic_pad = FALSE;
- new_element = gst_element_factory_make("rtpmp2tdepay", "wfd_rtp_depay");
- if (!new_element)
- {
- LOGE("failed to create wfd rtp depay element\n");
- goto ERROR;
- }
- MMPLAYER_ELEMENT_SET_STATE(new_element, GST_STATE_READY);
- /* add new element to the pipeline */
- if (FALSE == gst_bin_add(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst), new_element) )
- {
- LOGD("failed to add autoplug element to bin\n");
- goto ERROR;
- }
- /* get pad from element */
- sinkpad = gst_element_get_static_pad(GST_ELEMENT(new_element), "sink");
- if (!sinkpad)
- {
- LOGD("failed to get sinkpad from autoplug element\n");
- goto ERROR;
- }
- /* link it */
- if (GST_PAD_LINK_OK != GST_PAD_LINK(pad, sinkpad))
- {
- LOGD("failed to link autoplug element\n");
- goto ERROR;
- }
- gst_object_unref(sinkpad);
- sinkpad = NULL;
- pad = gst_element_get_static_pad(GST_ELEMENT(new_element), "src");
- caps = gst_pad_query_caps(pad);
- MMPLAYER_CHECK_NULL(caps);
- MMPLAYER_ELEMENT_SET_STATE(new_element, GST_STATE_PLAYING);
- /* create typefind */
- new_element = gst_element_factory_make("typefind", NULL);
- if (!new_element)
- {
- LOGD("failed to create typefind\n");
- goto ERROR;
- }
-
- MMPLAYER_SIGNAL_CONNECT( player,
- G_OBJECT(new_element),
- MM_PLAYER_SIGNAL_TYPE_AUTOPLUG,
- "have-type",
- G_CALLBACK(__mmplayer_typefind_have_type),
- (gpointer)player);
-
- player->have_dynamic_pad = FALSE;
- }
-
- /* excute new_element if created*/
- if (new_element)
- {
- LOGD("adding new element to pipeline\n");
-
- /* set state to READY before add to bin */
- MMPLAYER_ELEMENT_SET_STATE(new_element, GST_STATE_READY);
-
- /* add new element to the pipeline */
- if (FALSE == gst_bin_add(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst), new_element) )
- {
- LOGD("failed to add autoplug element to bin\n");
- goto ERROR;
- }
-
- /* get pad from element */
- sinkpad = gst_element_get_static_pad(GST_ELEMENT(new_element), "sink");
- if (!sinkpad)
- {
- LOGD("failed to get sinkpad from autoplug element\n");
- goto ERROR;
- }
-
- /* link it */
- if (GST_PAD_LINK_OK != GST_PAD_LINK(pad, sinkpad))
- {
- LOGD("failed to link autoplug element\n");
- goto ERROR;
- }
-
- gst_object_unref(sinkpad);
- sinkpad = NULL;
-
- /* run. setting PLAYING here since streamming source is live source */
- MMPLAYER_ELEMENT_SET_STATE(new_element, GST_STATE_PLAYING);
- }
-
- /* store handle to futher manipulation */
- player->pipeline->mainbin[element_id].id = element_id;
- player->pipeline->mainbin[element_id].gst = new_element;
-
- MMPLAYER_FLEAVE();
-
- return;
+ GstPad *sinkpad = NULL;
+ GstCaps* caps = NULL;
+ GstElement* new_element = NULL;
+ enum MainElementID element_id = MMPLAYER_M_NUM;
+
+ mm_player_t* player = (mm_player_t*) data;
+
+ MMPLAYER_FENTER();
+
+ MMPLAYER_RETURN_IF_FAIL(element && pad);
+ MMPLAYER_RETURN_IF_FAIL(player &&
+ player->pipeline &&
+ player->pipeline->mainbin);
+
+ LOGD("stream count inc : %d\n", player->num_dynamic_pad);
+
+ {
+ LOGD("using pad caps to autopluging instead of doing typefind\n");
+ caps = gst_pad_query_caps(pad);
+ MMPLAYER_CHECK_NULL(caps);
+ /* clear previous result*/
+ player->have_dynamic_pad = FALSE;
+ new_element = gst_element_factory_make("rtpmp2tdepay", "wfd_rtp_depay");
+ if (!new_element) {
+ LOGE("failed to create wfd rtp depay element\n");
+ goto ERROR;
+ }
+ MMPLAYER_ELEMENT_SET_STATE(new_element, GST_STATE_READY);
+ /* add new element to the pipeline */
+ if (FALSE == gst_bin_add(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst), new_element)) {
+ LOGD("failed to add autoplug element to bin\n");
+ goto ERROR;
+ }
+ /* get pad from element */
+ sinkpad = gst_element_get_static_pad(GST_ELEMENT(new_element), "sink");
+ if (!sinkpad) {
+ LOGD("failed to get sinkpad from autoplug element\n");
+ goto ERROR;
+ }
+ /* link it */
+ if (GST_PAD_LINK_OK != GST_PAD_LINK(pad, sinkpad)) {
+ LOGD("failed to link autoplug element\n");
+ goto ERROR;
+ }
+ gst_object_unref(sinkpad);
+ sinkpad = NULL;
+ pad = gst_element_get_static_pad(GST_ELEMENT(new_element), "src");
+ caps = gst_pad_query_caps(pad);
+ MMPLAYER_CHECK_NULL(caps);
+ MMPLAYER_ELEMENT_SET_STATE(new_element, GST_STATE_PLAYING);
+ /* create typefind */
+ new_element = gst_element_factory_make("typefind", NULL);
+ if (!new_element) {
+ LOGD("failed to create typefind\n");
+ goto ERROR;
+ }
+
+ MMPLAYER_SIGNAL_CONNECT(player,
+ G_OBJECT(new_element),
+ MM_PLAYER_SIGNAL_TYPE_AUTOPLUG,
+ "have-type",
+ G_CALLBACK(__mmplayer_typefind_have_type),
+ (gpointer)player);
+
+ player->have_dynamic_pad = FALSE;
+ }
+
+ /* excute new_element if created*/
+ if (new_element) {
+ LOGD("adding new element to pipeline\n");
+
+ /* set state to READY before add to bin */
+ MMPLAYER_ELEMENT_SET_STATE(new_element, GST_STATE_READY);
+
+ /* add new element to the pipeline */
+ if (FALSE == gst_bin_add(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst), new_element)) {
+ LOGD("failed to add autoplug element to bin\n");
+ goto ERROR;
+ }
+
+ /* get pad from element */
+ sinkpad = gst_element_get_static_pad(GST_ELEMENT(new_element), "sink");
+ if (!sinkpad) {
+ LOGD("failed to get sinkpad from autoplug element\n");
+ goto ERROR;
+ }
+
+ /* link it */
+ if (GST_PAD_LINK_OK != GST_PAD_LINK(pad, sinkpad)) {
+ LOGD("failed to link autoplug element\n");
+ goto ERROR;
+ }
+
+ gst_object_unref(sinkpad);
+ sinkpad = NULL;
+
+ /* run. setting PLAYING here since streamming source is live source */
+ MMPLAYER_ELEMENT_SET_STATE(new_element, GST_STATE_PLAYING);
+ }
+
+ /* store handle to futher manipulation */
+ player->pipeline->mainbin[element_id].id = element_id;
+ player->pipeline->mainbin[element_id].gst = new_element;
+
+ MMPLAYER_FLEAVE();
+
+ return;
STATE_CHANGE_FAILED:
ERROR:
- /* FIXIT : take care if new_element has already added to pipeline */
- if (new_element)
- gst_object_unref(GST_OBJECT(new_element));
+ /* FIXIT : take care if new_element has already added to pipeline */
+ if (new_element)
+ gst_object_unref(GST_OBJECT(new_element));
- if (sinkpad)
- gst_object_unref(GST_OBJECT(sinkpad));
+ if (sinkpad)
+ gst_object_unref(GST_OBJECT(sinkpad));
- if (caps)
- gst_object_unref(GST_OBJECT(caps));
+ if (caps)
+ gst_object_unref(GST_OBJECT(caps));
- /* FIXIT : how to inform this error to MSL ????? */
- /* FIXIT : I think we'd better to use g_idle_add() to destroy pipeline and
- * then post an error to application
- */
+ /* FIXIT : how to inform this error to MSL ????? */
+ /* FIXIT : I think we'd better to use g_idle_add() to destroy pipeline and
+ * then post an error to application
+ */
}
#endif
LOGD("stream type is %d", stream_type);
switch (GST_EVENT_TYPE(event)) {
- case GST_EVENT_STREAM_START:
+ case GST_EVENT_STREAM_START:
{
gint64 stop_running_time = 0;
gint64 position_running_time = 0;
LOGD("[%d] GST_EVENT_STREAM_START", stream_type);
- for (idx=MM_PLAYER_TRACK_TYPE_AUDIO;idx<MM_PLAYER_TRACK_TYPE_TEXT;idx++)
- {
+ for (idx = MM_PLAYER_TRACK_TYPE_AUDIO; idx < MM_PLAYER_TRACK_TYPE_TEXT; idx++) {
if ((player->gapless.update_segment[idx] == TRUE) ||
- !(player->selector[idx].event_probe_id))
- {
+ !(player->selector[idx].event_probe_id)) {
LOGW("[%d] skip", idx);
continue;
}
if (player->gapless.segment[idx].stop != -1)
- {
stop_running_time =
gst_segment_to_running_time(&player->gapless.segment[idx],
GST_FORMAT_TIME, player->gapless.segment[idx].stop);
- }
else
- {
stop_running_time =
gst_segment_to_running_time(&player->gapless.segment[idx],
GST_FORMAT_TIME, player->gapless.segment[idx].duration);
- }
position_running_time =
gst_segment_to_running_time(&player->gapless.segment[idx],
player->gapless.start_time[stream_type] += position;
break;
}
- case GST_EVENT_FLUSH_STOP:
+ case GST_EVENT_FLUSH_STOP:
{
LOGD("[%d] GST_EVENT_FLUSH_STOP", stream_type);
gst_segment_init(&player->gapless.segment[stream_type], GST_FORMAT_UNDEFINED);
player->gapless.start_time[stream_type] = 0;
break;
}
- case GST_EVENT_SEGMENT: {
+ case GST_EVENT_SEGMENT:
+ {
GstSegment segment;
GstEvent *tmpev;
LOGD("[%d] GST_EVENT_SEGMENT", stream_type);
gst_event_copy_segment(event, &segment);
- if (segment.format == GST_FORMAT_TIME)
- {
+ if (segment.format == GST_FORMAT_TIME) {
LOGD("segment base:%" GST_TIME_FORMAT ", offset:%" GST_TIME_FORMAT
", start:%" GST_TIME_FORMAT ", stop: %" GST_TIME_FORMAT
", time: %" GST_TIME_FORMAT ", pos: %" GST_TIME_FORMAT ", dur: %" GST_TIME_FORMAT,
}
break;
}
- default:
+ default:
break;
}
/* get mimetype from caps */
caps = gst_pad_query_caps(pad, NULL);
- if (!caps)
- {
+ if (!caps) {
LOGE("cannot get caps from pad.\n");
goto ERROR;
}
str = gst_caps_get_structure(caps, 0);
- if (!str)
- {
+ if (!str) {
LOGE("cannot get structure from caps.\n");
goto ERROR;
}
name = gst_structure_get_name(str);
- if (!name)
- {
+ if (!name) {
LOGE("cannot get mimetype from structure.\n");
goto ERROR;
}
MMPLAYER_LOG_GST_CAPS_TYPE(caps);
//LOGD("detected mimetype : %s\n", name);
- if (strstr(name, "video"))
- {
+ if (strstr(name, "video")) {
gint stype = 0;
mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &stype);
/* don't make video because of not required, and not support multiple track */
- if (stype == MM_DISPLAY_SURFACE_NULL)
- {
+ if (stype == MM_DISPLAY_SURFACE_NULL) {
LOGD("no video sink by null surface");
MMPlayerResourceState resource_state = RESOURCE_STATE_NONE;
if (_mmplayer_resource_manager_get_state(&player->resource_manager, &resource_state)
- == MM_ERROR_NONE)
- {
+ == MM_ERROR_NONE) {
/* acquire resources for video playing */
- if (resource_state == RESOURCE_STATE_PREPARED)
- {
+ if (resource_state == RESOURCE_STATE_PREPARED) {
if (_mmplayer_resource_manager_acquire(&player->resource_manager)
- != MM_ERROR_NONE)
- {
+ != MM_ERROR_NONE) {
LOGE("could not acquire resources for video playing\n");
_mmplayer_resource_manager_unprepare(&player->resource_manager);
goto ERROR;
gchar *caps_str = gst_caps_to_string(caps);
if (strstr(caps_str, "ST12") || strstr(caps_str, "SN12"))
- {
player->set_mode.video_zc = TRUE;
- }
+
MMPLAYER_FREEIF(caps_str);
- if (player->v_stream_caps)
- {
+ if (player->v_stream_caps) {
gst_caps_unref(player->v_stream_caps);
player->v_stream_caps = NULL;
}
/* fake sink */
fakesink = gst_element_factory_make("fakesink", NULL);
- if (fakesink == NULL)
- {
+ if (fakesink == NULL) {
LOGE("ERROR : fakesink create error\n");
goto ERROR;
}
// link
sinkpad = gst_element_get_static_pad(fakesink, "sink");
- if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad)) {
LOGW("failed to link fakesink\n");
gst_object_unref(GST_OBJECT(fakesink));
goto ERROR;
goto DONE;
}
- if (MMPLAYER_IS_MS_BUFF_SRC(player))
- {
+ if (MMPLAYER_IS_MS_BUFF_SRC(player)) {
__mmplayer_gst_decode_callback(elem, pad, player);
return;
}
LOGD("video selector \n");
elemId = MMPLAYER_M_V_INPUT_SELECTOR;
stream_type = MM_PLAYER_TRACK_TYPE_VIDEO;
- }
- else
- {
- if (strstr(name, "audio"))
- {
+ } else {
+ if (strstr(name, "audio")) {
gint samplerate = 0;
gint channels = 0;
- if (MMPLAYER_IS_MS_BUFF_SRC(player))
- {
+ if (MMPLAYER_IS_MS_BUFF_SRC(player)) {
__mmplayer_gst_decode_callback(elem, pad, player);
return;
}
gst_structure_get_int(str, "channels", &channels);
if ((channels > 0 && samplerate == 0)) {//exclude audio decoding
- /* fake sink */
- fakesink = gst_element_factory_make("fakesink", NULL);
- if (fakesink == NULL)
- {
- LOGE("ERROR : fakesink create error\n");
- goto ERROR;
- }
+ /* fake sink */
+ fakesink = gst_element_factory_make("fakesink", NULL);
+ if (fakesink == NULL) {
+ LOGE("ERROR : fakesink create error\n");
+ goto ERROR;
+ }
gst_bin_add(GST_BIN(pipeline), fakesink);
/* link */
sinkpad = gst_element_get_static_pad(fakesink, "sink");
- if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad)) {
LOGW("failed to link fakesink\n");
gst_object_unref(GST_OBJECT(fakesink));
goto ERROR;
goto DONE;
}
- }
- else if (strstr(name, "text"))
- {
+ } else if (strstr(name, "text")) {
LOGD("text selector \n");
elemId = MMPLAYER_M_T_INPUT_SELECTOR;
stream_type = MM_PLAYER_TRACK_TYPE_TEXT;
- }
- else
- {
+ } else {
LOGE("wrong elem id \n");
goto ERROR;
}
}
selector = player->pipeline->mainbin[elemId].gst;
- if (selector == NULL)
- {
+ if (selector == NULL) {
selector = gst_element_factory_make("input-selector", NULL);
LOGD("Creating input-selector\n");
- if (selector == NULL)
- {
+ if (selector == NULL) {
LOGE("ERROR : input-selector create error\n");
goto ERROR;
}
LOGD("got pad %s:%s from selector", GST_DEBUG_PAD_NAME(sinkpad));
- if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad)) {
LOGW("failed to link selector\n");
gst_object_unref(GST_OBJECT(selector));
goto ERROR;
}
- if (first_track)
- {
+ if (first_track) {
LOGD("this is first track --> active track \n");
g_object_set(selector, "active-pad", sinkpad, NULL);
}
ERROR:
if (caps)
- {
gst_caps_unref(caps);
- }
- if (sinkpad)
- {
+ if (sinkpad) {
gst_object_unref(GST_OBJECT(sinkpad));
sinkpad = NULL;
}
- if (srcpad)
- {
+ if (srcpad) {
gst_object_unref(GST_OBJECT(srcpad));
srcpad = NULL;
}
// [link] input-selector :: textbin
srcpad = gst_element_get_static_pad(text_selector, "src");
- if (!srcpad)
- {
+ if (!srcpad) {
LOGE("failed to get srcpad from selector\n");
return;
}
active_index = player->selector[MM_PLAYER_TRACK_TYPE_TEXT].active_pad_index;
if ((active_index != DEFAULT_TRACK) &&
- (__mmplayer_change_selector_pad(player, MM_PLAYER_TRACK_TYPE_TEXT, active_index) != MM_ERROR_NONE))
- {
+ (__mmplayer_change_selector_pad(player, MM_PLAYER_TRACK_TYPE_TEXT, active_index) != MM_ERROR_NONE)) {
LOGW("failed to change text track\n");
player->selector[MM_PLAYER_TRACK_TYPE_TEXT].active_pad_index = DEFAULT_TRACK;
}
__mmplayer_gst_decode_callback(text_selector, srcpad, player);
LOGD("unblocking %s:%s", GST_DEBUG_PAD_NAME(srcpad));
- if (player->selector[MM_PLAYER_TRACK_TYPE_TEXT].block_id)
- {
+ if (player->selector[MM_PLAYER_TRACK_TYPE_TEXT].block_id) {
gst_pad_remove_probe(srcpad, player->selector[MM_PLAYER_TRACK_TYPE_TEXT].block_id);
player->selector[MM_PLAYER_TRACK_TYPE_TEXT].block_id = 0;
}
player->has_closed_caption = TRUE;
attrs = MMPLAYER_GET_ATTRS(player);
- if (attrs)
- {
+ if (attrs) {
mm_attrs_set_int_by_name(attrs, "content_text_track_num", (gint)player->selector[MM_PLAYER_TRACK_TYPE_TEXT].total_track_num);
if (mmf_attrs_commit(attrs))
LOGE("failed to commit.\n");
- }
- else
- {
+ } else
LOGE("cannot get content attribute");
- }
- if (srcpad)
- {
+ if (srcpad) {
gst_object_unref(GST_OBJECT(srcpad));
srcpad = NULL;
}
LOGD("Change Audio mode to %d\n", ch_idx);
player->use_deinterleave = TRUE;
- if ((!player->pipeline) || (!player->pipeline->mainbin))
- {
+ if ((!player->pipeline) || (!player->pipeline->mainbin)) {
LOGD("pre setting : %d\n", ch_idx);
player->audio_mode.active_pad_index = ch_idx;
mainbin = player->pipeline->mainbin;
- if (mainbin[MMPLAYER_M_A_SELECTOR].gst == NULL)
- {
- if (player->max_audio_channels < 2)
- {
+ if (mainbin[MMPLAYER_M_A_SELECTOR].gst == NULL) {
+ if (player->max_audio_channels < 2) {
LOGD("mono channel track only\n");
return result;
}
LOGD("total_ch_num : %d\n", player->audio_mode.total_track_num);
- if (player->audio_mode.total_track_num < 2)
- {
+ if (player->audio_mode.total_track_num < 2) {
LOGW("there is no another audio path\n");
return result; /* keep playing */
}
- if ((ch_idx < 0) || (ch_idx >= player->audio_mode.total_track_num))
- {
+ if ((ch_idx < 0) || (ch_idx >= player->audio_mode.total_track_num)) {
LOGW("Not a proper ch_idx : %d \n", ch_idx);
return result; /* keep playing */
}
/*To get the new pad from the selector*/
change_pad_name = g_strdup_printf("sink%d", ch_idx);
- if (change_pad_name == NULL)
- {
+ if (change_pad_name == NULL) {
LOGW("Pad does not exists\n");
goto ERROR; /* keep playing */
}
sinkpad = gst_element_get_static_pad(mainbin[MMPLAYER_M_A_SELECTOR].gst, change_pad_name);
if (sinkpad == NULL)
- {
//result = MM_ERROR_PLAYER_INTERNAL;
goto ERROR; /* keep playing */
- }
LOGD("Set Active Pad - %s:%s\n", GST_DEBUG_PAD_NAME(sinkpad));
g_object_set(mainbin[MMPLAYER_M_A_SELECTOR].gst, "active-pad", sinkpad, NULL);
GstPad* srcpad = NULL;
GstPad* sinkpad = NULL;
- gchar* caps_str= NULL;
+ gchar* caps_str = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && player->pipeline->mainbin);
LOGD("deinterleave new caps : %s\n", caps_str);
MMPLAYER_FREEIF(caps_str);
- if ((queue = __mmplayer_element_create_and_link(player, pad, "queue")) == NULL)
- {
+ if ((queue = __mmplayer_element_create_and_link(player, pad, "queue")) == NULL) {
LOGE("ERROR : queue create error\n");
goto ERROR;
}
selector = player->pipeline->mainbin[MMPLAYER_M_A_SELECTOR].gst;
- if (!selector)
- {
+ if (!selector) {
LOGE("there is no audio channel selector.\n");
goto ERROR;
}
LOGD("link(%s:%s - %s:%s)\n", GST_DEBUG_PAD_NAME(srcpad), GST_DEBUG_PAD_NAME(sinkpad));
- if (GST_PAD_LINK_OK != gst_pad_link(srcpad, sinkpad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(srcpad, sinkpad)) {
LOGW("failed to link deinterleave - selector\n");
goto ERROR;
}
ERROR:
- if (srcpad)
- {
+ if (srcpad) {
gst_object_unref(GST_OBJECT(srcpad));
srcpad = NULL;
}
- if (sinkpad)
- {
+ if (sinkpad) {
gst_object_unref(GST_OBJECT(sinkpad));
sinkpad = NULL;
}
selector = player->pipeline->mainbin[MMPLAYER_M_A_SELECTOR].gst;
- if (!selector)
- {
+ if (!selector) {
LOGE("there is no audio channel selector.\n");
goto ERROR;
}
active_index = player->audio_mode.active_pad_index;
- if (active_index != default_audio_ch)
- {
+ if (active_index != default_audio_ch) {
gint audio_ch = default_audio_ch;
/*To get the new pad from the selector*/
change_pad_name = g_strdup_printf("sink%d", active_index);
- if (change_pad_name != NULL)
- {
+ if (change_pad_name != NULL) {
sinkpad = gst_element_get_static_pad(selector, change_pad_name);
- if (sinkpad != NULL)
- {
+ if (sinkpad != NULL) {
LOGD("Set Active Pad - %s:%s\n", GST_DEBUG_PAD_NAME(sinkpad));
g_object_set(selector, "active-pad", sinkpad, NULL);
mainbin = player->pipeline->mainbin;
/* tee */
- if ((tee = __mmplayer_element_create_and_link(player, pad, "tee")) == NULL)
- {
+ if ((tee = __mmplayer_element_create_and_link(player, pad, "tee")) == NULL) {
LOGE("ERROR : tee create error\n");
goto ERROR;
}
/* queue */
srcpad = gst_element_get_request_pad(tee, "src_%u");
- if ((stereo_queue = __mmplayer_element_create_and_link(player, srcpad, "queue")) == NULL)
- {
+ if ((stereo_queue = __mmplayer_element_create_and_link(player, srcpad, "queue")) == NULL) {
LOGE("ERROR : stereo queue create error\n");
goto ERROR;
}
player->pipeline->mainbin[MMPLAYER_M_A_Q1].id = MMPLAYER_M_A_Q1;
player->pipeline->mainbin[MMPLAYER_M_A_Q1].gst = stereo_queue;
- if (srcpad)
- {
+ if (srcpad) {
gst_object_unref(GST_OBJECT(srcpad));
srcpad = NULL;
}
srcpad = gst_element_get_request_pad(tee, "src_%u");
- if ((mono_queue = __mmplayer_element_create_and_link(player, srcpad, "queue")) == NULL)
- {
+ if ((mono_queue = __mmplayer_element_create_and_link(player, srcpad, "queue")) == NULL) {
LOGE("ERROR : mono queue create error\n");
goto ERROR;
}
/* audioconvert */
srcpad = gst_element_get_static_pad(mono_queue, "src");
- if ((conv = __mmplayer_element_create_and_link(player, srcpad, "audioconvert")) == NULL)
- {
+ if ((conv = __mmplayer_element_create_and_link(player, srcpad, "audioconvert")) == NULL) {
LOGE("ERROR : audioconvert create error\n");
goto ERROR;
}
player->pipeline->mainbin[MMPLAYER_M_A_CONV].gst = conv;
/* caps filter */
- if (srcpad)
- {
+ if (srcpad) {
gst_object_unref(GST_OBJECT(srcpad));
srcpad = NULL;
}
srcpad = gst_element_get_static_pad(conv, "src");
- if ((filter = __mmplayer_element_create_and_link(player, srcpad, "capsfilter")) == NULL)
- {
+ if ((filter = __mmplayer_element_create_and_link(player, srcpad, "capsfilter")) == NULL) {
LOGE("ERROR : capsfilter create error\n");
goto ERROR;
}
gst_element_set_state(filter, GST_STATE_PAUSED);
/* deinterleave */
- if (srcpad)
- {
+ if (srcpad) {
gst_object_unref(GST_OBJECT(srcpad));
srcpad = NULL;
}
srcpad = gst_element_get_static_pad(filter, "src");
- if ((deinterleave = __mmplayer_element_create_and_link(player, srcpad, "deinterleave")) == NULL)
- {
+ if ((deinterleave = __mmplayer_element_create_and_link(player, srcpad, "deinterleave")) == NULL) {
LOGE("ERROR : deinterleave create error\n");
goto ERROR;
}
/* selector */
selector = gst_element_factory_make("input-selector", "audio-channel-selector");
- if (selector == NULL)
- {
+ if (selector == NULL) {
LOGE("ERROR : audio-selector create error\n");
goto ERROR;
}
gst_pad_add_probe(selector_srcpad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
__mmplayer_gst_selector_blocked, NULL, NULL);
- if (srcpad)
- {
+ if (srcpad) {
gst_object_unref(GST_OBJECT(srcpad));
srcpad = NULL;
}
srcpad = gst_element_get_static_pad(stereo_queue, "src");
sinkpad = gst_element_get_request_pad(selector, "sink_%u");
- if (GST_PAD_LINK_OK != gst_pad_link(srcpad, sinkpad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(srcpad, sinkpad)) {
LOGW("failed to link queue_stereo - selector\n");
goto ERROR;
}
ERROR:
LOGD("unblocking %s:%s", GST_DEBUG_PAD_NAME(selector_srcpad));
- if (block_id != 0)
- {
+ if (block_id != 0) {
gst_pad_remove_probe(selector_srcpad, block_id);
block_id = 0;
}
- if (sinkpad)
- {
+ if (sinkpad) {
gst_object_unref(GST_OBJECT(sinkpad));
sinkpad = NULL;
}
- if (srcpad)
- {
+ if (srcpad) {
gst_object_unref(GST_OBJECT(srcpad));
srcpad = NULL;
}
- if (selector_srcpad)
- {
+ if (selector_srcpad) {
gst_object_unref(GST_OBJECT(selector_srcpad));
selector_srcpad = NULL;
}
LOGD("no-more-pad signal handling\n");
if ((player->cmd == MMPLAYER_COMMAND_DESTROY) ||
- (player->cmd == MMPLAYER_COMMAND_UNREALIZE))
- {
+ (player->cmd == MMPLAYER_COMMAND_UNREALIZE)) {
LOGW("no need to go more");
- if (player->gapless.reconfigure)
- {
+ if (player->gapless.reconfigure) {
player->gapless.reconfigure = FALSE;
MMPLAYER_PLAYBACK_UNLOCK(player);
}
if ((!MMPLAYER_IS_HTTP_PD(player)) &&
(MMPLAYER_IS_HTTP_STREAMING(player)) &&
(!player->pipeline->mainbin[MMPLAYER_M_DEMUXED_S_BUFFER].gst) &&
- (player->pipeline->mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst))
- {
+ (player->pipeline->mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst)) {
#define ESTIMATED_BUFFER_UNIT (1*1024*1024)
- if (NULL == player->streamer)
- {
+ if (NULL == player->streamer) {
LOGW("invalid state for buffering");
goto ERROR;
}
buffer_bytes = MAX(buffer_bytes, player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffering_bytes);
LOGD("[Decodebin2] set use-buffering on Q2(pre buffer time: %d sec, buffer size : %d)\n", (gint)init_buffering_time, buffer_bytes);
- init_buffering_time = (init_buffering_time != 0)?(init_buffering_time):(player->ini.http_buffering_time);
+ init_buffering_time = (init_buffering_time != 0) ? (init_buffering_time) : (player->ini.http_buffering_time);
if (!gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_SRC].gst, GST_FORMAT_BYTES, &dur_bytes))
LOGE("fail to get duration.\n");
player->ini.http_buffering_limit, // high percent
MUXED_BUFFER_TYPE_MEM_QUEUE,
NULL,
- ((dur_bytes>0)?((guint64)dur_bytes):0));
+ ((dur_bytes > 0) ? ((guint64)dur_bytes) : 0));
}
video_selector = player->pipeline->mainbin[MMPLAYER_M_V_INPUT_SELECTOR].gst;
audio_selector = player->pipeline->mainbin[MMPLAYER_M_A_INPUT_SELECTOR].gst;
text_selector = player->pipeline->mainbin[MMPLAYER_M_T_INPUT_SELECTOR].gst;
- if (video_selector)
- {
+ if (video_selector) {
// [link] input-selector :: videobin
srcpad = gst_element_get_static_pad(video_selector, "src");
- if (!srcpad)
- {
+ if (!srcpad) {
LOGE("failed to get srcpad from video selector\n");
goto ERROR;
}
__mmplayer_gst_decode_callback(video_selector, srcpad, player);
LOGD("unblocking %s:%s", GST_DEBUG_PAD_NAME(srcpad));
- if (player->selector[MM_PLAYER_TRACK_TYPE_VIDEO].block_id)
- {
+ if (player->selector[MM_PLAYER_TRACK_TYPE_VIDEO].block_id) {
gst_pad_remove_probe(srcpad, player->selector[MM_PLAYER_TRACK_TYPE_VIDEO].block_id);
player->selector[MM_PLAYER_TRACK_TYPE_VIDEO].block_id = 0;
}
}
- if (audio_selector)
- {
+ if (audio_selector) {
active_index = player->selector[MM_PLAYER_TRACK_TYPE_AUDIO].active_pad_index;
if ((active_index != DEFAULT_TRACK) &&
- (__mmplayer_change_selector_pad(player, MM_PLAYER_TRACK_TYPE_AUDIO, active_index) != MM_ERROR_NONE))
- {
+ (__mmplayer_change_selector_pad(player, MM_PLAYER_TRACK_TYPE_AUDIO, active_index) != MM_ERROR_NONE)) {
LOGW("failed to change audio track\n");
player->selector[MM_PLAYER_TRACK_TYPE_AUDIO].active_pad_index = DEFAULT_TRACK;
}
// [link] input-selector :: audiobin
srcpad = gst_element_get_static_pad(audio_selector, "src");
- if (!srcpad)
- {
+ if (!srcpad) {
LOGE("failed to get srcpad from selector\n");
goto ERROR;
}
if (!text_selector)
player->no_more_pad = TRUE;
- if ((player->use_deinterleave == TRUE) && (player->max_audio_channels >= 2))
- {
+ if ((player->use_deinterleave == TRUE) && (player->max_audio_channels >= 2)) {
LOGD("unblocking %s:%s", GST_DEBUG_PAD_NAME(srcpad));
- if (player->selector[MM_PLAYER_TRACK_TYPE_AUDIO].block_id)
- {
+ if (player->selector[MM_PLAYER_TRACK_TYPE_AUDIO].block_id) {
gst_pad_remove_probe(srcpad, player->selector[MM_PLAYER_TRACK_TYPE_AUDIO].block_id);
player->selector[MM_PLAYER_TRACK_TYPE_AUDIO].block_id = 0;
}
__mmplayer_gst_build_deinterleave_path(audio_selector, srcpad, player);
- }
- else
- {
+ } else {
__mmplayer_gst_decode_callback(audio_selector, srcpad, player);
LOGD("unblocking %s:%s", GST_DEBUG_PAD_NAME(srcpad));
- if (player->selector[MM_PLAYER_TRACK_TYPE_AUDIO].block_id)
- {
+ if (player->selector[MM_PLAYER_TRACK_TYPE_AUDIO].block_id) {
gst_pad_remove_probe(srcpad, player->selector[MM_PLAYER_TRACK_TYPE_AUDIO].block_id);
player->selector[MM_PLAYER_TRACK_TYPE_AUDIO].block_id = 0;
}
LOGD("Total audio tracks = %d \n", player->selector[MM_PLAYER_TRACK_TYPE_AUDIO].total_track_num);
attrs = MMPLAYER_GET_ATTRS(player);
- if (attrs)
- {
+ if (attrs) {
mm_attrs_set_int_by_name(attrs, "content_audio_track_num", (gint)player->selector[MM_PLAYER_TRACK_TYPE_AUDIO].total_track_num);
if (mmf_attrs_commit(attrs))
LOGE("failed to commit.\n");
- }
- else
- {
+ } else
LOGE("cannot get content attribute");
- }
- }
- else
- {
- if ((player->pipeline->audiobin) && (player->pipeline->audiobin[MMPLAYER_A_BIN].gst))
- {
+ } else {
+ if ((player->pipeline->audiobin) && (player->pipeline->audiobin[MMPLAYER_A_BIN].gst)) {
LOGD("There is no audio track : remove audiobin");
__mmplayer_release_signal_connection(player, MM_PLAYER_SIGNAL_TYPE_AUDIOBIN);
}
if (player->num_dynamic_pad == 0)
- {
__mmplayer_pipeline_complete(NULL, player);
- }
}
- if (!MMPLAYER_IS_MS_BUFF_SRC(player))
- {
+ if (!MMPLAYER_IS_MS_BUFF_SRC(player)) {
if (text_selector)
- {
__mmplayer_handle_text_decode_path(player, text_selector);
- }
}
MMPLAYER_FLEAVE();
ERROR:
- if (srcpad)
- {
+ if (srcpad) {
gst_object_unref(GST_OBJECT(srcpad));
srcpad = NULL;
}
- if (player->gapless.reconfigure)
- {
+ if (player->gapless.reconfigure) {
player->gapless.reconfigure = FALSE;
MMPLAYER_PLAYBACK_UNLOCK(player);
}
pipeline = player->pipeline->mainbin[MMPLAYER_M_PIPE].gst;
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("cannot get content attribute\n");
goto ERROR;
}
/* get mimetype from caps */
caps = gst_pad_query_caps(pad, NULL);
- if (!caps)
- {
+ if (!caps) {
LOGE("cannot get caps from pad.\n");
goto ERROR;
}
caps_str = gst_caps_to_string(caps);
str = gst_caps_get_structure(caps, 0);
- if (!str)
- {
+ if (!str) {
LOGE("cannot get structure from caps.\n");
goto ERROR;
}
name = gst_structure_get_name(str);
- if (!name)
- {
+ if (!name) {
LOGE("cannot get mimetype from structure.\n");
goto ERROR;
}
//LOGD("detected mimetype : %s\n", name);
- if (strstr(name, "audio"))
- {
- if (player->pipeline->audiobin == NULL)
- {
- if (MM_ERROR_NONE != __mmplayer_gst_create_audio_pipeline(player))
- {
+ if (strstr(name, "audio")) {
+ if (player->pipeline->audiobin == NULL) {
+ if (MM_ERROR_NONE != __mmplayer_gst_create_audio_pipeline(player)) {
LOGE("failed to create audiobin. continuing without audio\n");
goto ERROR;
}
sinkbin = player->pipeline->audiobin[MMPLAYER_A_BIN].gst;
LOGD("creating audiosink bin success\n");
- }
- else
- {
+ } else {
reusing = TRUE;
sinkbin = player->pipeline->audiobin[MMPLAYER_A_BIN].gst;
LOGD("reusing audiobin\n");
player->audiosink_linked = 1;
sinkpad = gst_element_get_static_pad(GST_ELEMENT(sinkbin), "sink");
- if (!sinkpad)
- {
+ if (!sinkpad) {
LOGE("failed to get pad from sinkbin\n");
goto ERROR;
}
- }
- else if (strstr(name, "video"))
- {
+ } else if (strstr(name, "video")) {
if (strstr(caps_str, "ST12") || strstr(caps_str, "SN12"))
- {
player->set_mode.video_zc = TRUE;
- }
- if (player->pipeline->videobin == NULL)
- {
+ if (player->pipeline->videobin == NULL) {
/* NOTE : not make videobin because application dose not want to play it even though file has video stream. */
/* get video surface type */
int surface_type = 0;
goto ERROR;
}
- if (surface_type == MM_DISPLAY_SURFACE_OVERLAY)
- {
- if (_mmplayer_resource_manager_get_state(&player->resource_manager, &resource_state) == MM_ERROR_NONE)
- {
+ if (surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
+ if (_mmplayer_resource_manager_get_state(&player->resource_manager, &resource_state) == MM_ERROR_NONE) {
/* prepare resource manager for video overlay */
- if (resource_state >= RESOURCE_STATE_INITIALIZED)
- {
+ if (resource_state >= RESOURCE_STATE_INITIALIZED) {
if (_mmplayer_resource_manager_prepare(&player->resource_manager, RESOURCE_TYPE_VIDEO_OVERLAY)
- != MM_ERROR_NONE)
- {
+ != MM_ERROR_NONE) {
LOGE("could not prepare for video_overlay resource\n");
goto ERROR;
}
}
if (_mmplayer_resource_manager_get_state(&player->resource_manager, &resource_state)
- == MM_ERROR_NONE)
- {
+ == MM_ERROR_NONE) {
/* acquire resources for video playing */
- if (resource_state == RESOURCE_STATE_PREPARED)
- {
+ if (resource_state == RESOURCE_STATE_PREPARED) {
if (_mmplayer_resource_manager_acquire(&player->resource_manager)
- != MM_ERROR_NONE)
- {
+ != MM_ERROR_NONE) {
LOGE("could not acquire resources for video playing\n");
_mmplayer_resource_manager_unprepare(&player->resource_manager);
goto ERROR;
}
}
- if (MM_ERROR_NONE != __mmplayer_gst_create_video_pipeline(player, caps, surface_type))
- {
+ if (MM_ERROR_NONE != __mmplayer_gst_create_video_pipeline(player, caps, surface_type)) {
LOGE("failed to create videobin. continuing without video\n");
goto ERROR;
}
sinkbin = player->pipeline->videobin[MMPLAYER_V_BIN].gst;
LOGD("creating videosink bin success\n");
- }
- else
- {
+ } else {
reusing = TRUE;
sinkbin = player->pipeline->videobin[MMPLAYER_V_BIN].gst;
LOGD("re-using videobin\n");
player->videosink_linked = 1;
/* NOTE : intermediate code before doing H/W subtitle compositon */
- if (player->use_textoverlay && player->play_subtitle)
- {
+ if (player->use_textoverlay && player->play_subtitle) {
LOGD("using textoverlay for external subtitle");
/* check text bin has created well */
- if (player->pipeline && player->pipeline->textbin)
- {
+ if (player->pipeline && player->pipeline->textbin) {
/* get sinkpad from textoverlay */
sinkpad = gst_element_get_static_pad(
GST_ELEMENT(player->pipeline->textbin[MMPLAYER_T_BIN].gst),
"video_sink");
- if (!sinkpad)
- {
+ if (!sinkpad) {
LOGE("failed to get sink pad from textoverlay");
goto ERROR;
}
/* link new pad with textoverlay first */
- if (GST_PAD_LINK_OK != GST_PAD_LINK(pad, sinkpad))
- {
+ if (GST_PAD_LINK_OK != GST_PAD_LINK(pad, sinkpad)) {
LOGE("failed to get pad from sinkbin\n");
goto ERROR;
}
pad = gst_element_get_static_pad(
GST_ELEMENT(player->pipeline->textbin[MMPLAYER_T_BIN].gst),
"src");
- if (!pad)
- {
+ if (!pad) {
LOGE("failed to get sink pad from textoverlay");
goto ERROR;
}
- }
- else
- {
+ } else {
LOGE("should not reach here.");
goto ERROR;
}
}
sinkpad = gst_element_get_static_pad(GST_ELEMENT(sinkbin), "sink");
- if (!sinkpad)
- {
+ if (!sinkpad) {
LOGE("failed to get pad from sinkbin\n");
goto ERROR;
}
- }
- else if (strstr(name, "text"))
- {
- if (player->pipeline->textbin == NULL)
- {
+ } else if (strstr(name, "text")) {
+ if (player->pipeline->textbin == NULL) {
MMPlayerGstElement* mainbin = NULL;
- if (MM_ERROR_NONE != __mmplayer_gst_create_text_pipeline(player))
- {
+ if (MM_ERROR_NONE != __mmplayer_gst_create_text_pipeline(player)) {
LOGE("failed to create textbin. continuing without text\n");
goto ERROR;
}
LOGI("player->textsink_linked set to 1\n");
sinkpad = gst_element_get_static_pad(GST_ELEMENT(sinkbin), "text_sink");
- if (!sinkpad)
- {
+ if (!sinkpad) {
LOGE("failed to get pad from sinkbin\n");
goto ERROR;
}
mainbin = player->pipeline->mainbin;
- if (!mainbin[MMPLAYER_M_T_INPUT_SELECTOR].gst)
- {
- /* input selector */
- text_selector = gst_element_factory_make("input-selector", "subtitle_inselector");
- if (!text_selector)
- {
- LOGE("failed to create subtitle input selector element\n");
- goto ERROR;
- }
- g_object_set(text_selector, "sync-streams", TRUE, NULL);
-
- mainbin[MMPLAYER_M_T_INPUT_SELECTOR].id = MMPLAYER_M_T_INPUT_SELECTOR;
- mainbin[MMPLAYER_M_T_INPUT_SELECTOR].gst = text_selector;
-
- /* warm up */
- if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(text_selector, GST_STATE_READY))
- {
- LOGE("failed to set state(READY) to sinkbin\n");
- goto ERROR;
- }
-
- if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), text_selector))
- {
- LOGW("failed to add subtitle input selector\n");
- goto ERROR;
- }
-
- LOGD("created element input-selector");
+ if (!mainbin[MMPLAYER_M_T_INPUT_SELECTOR].gst) {
+ /* input selector */
+ text_selector = gst_element_factory_make("input-selector", "subtitle_inselector");
+ if (!text_selector) {
+ LOGE("failed to create subtitle input selector element\n");
+ goto ERROR;
+ }
+ g_object_set(text_selector, "sync-streams", TRUE, NULL);
- }
- else
- {
- LOGD("already having subtitle input selector");
- text_selector = mainbin[MMPLAYER_M_T_INPUT_SELECTOR].gst;
- }
- }
+ mainbin[MMPLAYER_M_T_INPUT_SELECTOR].id = MMPLAYER_M_T_INPUT_SELECTOR;
+ mainbin[MMPLAYER_M_T_INPUT_SELECTOR].gst = text_selector;
- else
- {
- if (!player->textsink_linked)
- {
+ /* warm up */
+ if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(text_selector, GST_STATE_READY)) {
+ LOGE("failed to set state(READY) to sinkbin\n");
+ goto ERROR;
+ }
+
+ if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), text_selector)) {
+ LOGW("failed to add subtitle input selector\n");
+ goto ERROR;
+ }
+
+ LOGD("created element input-selector");
+
+ } else {
+ LOGD("already having subtitle input selector");
+ text_selector = mainbin[MMPLAYER_M_T_INPUT_SELECTOR].gst;
+ }
+ } else {
+ if (!player->textsink_linked) {
LOGD("re-using textbin\n");
reusing = TRUE;
player->textsink_linked = 1;
LOGI("player->textsink_linked set to 1\n");
- }
- else
- {
+ } else
LOGD("ignoring internal subtutle since external subtitle is available");
- }
}
- }
- else
- {
+ } else {
LOGW("unknown type of elementary stream!ignoring it...\n");
goto ERROR;
}
- if (sinkbin)
- {
- if (!reusing)
- {
+ if (sinkbin) {
+ if (!reusing) {
/* warm up */
- if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(sinkbin, GST_STATE_READY))
- {
+ if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(sinkbin, GST_STATE_READY)) {
LOGE("failed to set state(READY) to sinkbin\n");
goto ERROR;
}
/* Added for multi audio support to avoid adding audio bin again*/
/* add */
- if (FALSE == gst_bin_add(GST_BIN(pipeline), sinkbin))
- {
+ if (FALSE == gst_bin_add(GST_BIN(pipeline), sinkbin)) {
LOGE("failed to add sinkbin to pipeline\n");
goto ERROR;
}
}
/* link */
- if (GST_PAD_LINK_OK != GST_PAD_LINK(pad, sinkpad))
- {
+ if (GST_PAD_LINK_OK != GST_PAD_LINK(pad, sinkpad)) {
LOGE("failed to get pad from sinkbin\n");
goto ERROR;
}
- if (!reusing)
- {
+ if (!reusing) {
/* run */
- if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(sinkbin, GST_STATE_PAUSED))
- {
+ if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(sinkbin, GST_STATE_PAUSED)) {
LOGE("failed to set state(PAUSED) to sinkbin\n");
goto ERROR;
}
- if (text_selector)
- {
- if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(text_selector, GST_STATE_PAUSED))
- {
- LOGE("failed to set state(PAUSED) to sinkbin\n");
- goto ERROR;
- }
+ if (text_selector) {
+ if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(text_selector, GST_STATE_PAUSED)) {
+ LOGE("failed to set state(PAUSED) to sinkbin\n");
+ goto ERROR;
+ }
}
}
LOGD("linking sink bin success\n");
/* FIXIT : we cannot hold callback for 'no-more-pad' signal because signal was emitted in
- * streaming task. if the task blocked, then buffer will not flow to the next element
- *(autoplugging element). so this is special hack for streaming. please try to remove it
- */
+ * streaming task. if the task blocked, then buffer will not flow to the next element
+ *(autoplugging element). so this is special hack for streaming. please try to remove it
+ */
/* dec stream count. we can remove fakesink if it's zero */
if (player->num_dynamic_pad)
player->num_dynamic_pad--;
LOGD("no more pads: %d stream count dec : %d(num of dynamic pad)\n", player->no_more_pad, player->num_dynamic_pad);
if ((player->no_more_pad) && (player->num_dynamic_pad == 0))
- {
__mmplayer_pipeline_complete(NULL, player);
- }
/* FIXIT : please leave a note why this code is needed */
if (MMPLAYER_IS_WFD_STREAMING(player))
- {
player->no_more_pad = TRUE;
- }
ERROR:
gst_object_unref(GST_OBJECT(sinkpad));
/* flusing out new attributes */
- if ( mmf_attrs_commit(attrs))
- {
+ if (mmf_attrs_commit(attrs))
LOGE("failed to comit attributes\n");
- }
return;
}
MMPLAYER_RETURN_VAL_IF_FAIL(rotation_angle >= 0, FALSE);
if (rotation_angle >= 360)
- {
dest_angle = rotation_angle - 360;
- }
/* chech if supported or not */
- if (dest_angle % 90)
- {
+ if (dest_angle % 90) {
LOGD("not supported rotation angle = %d", rotation_angle);
return FALSE;
}
/*
- * xvimagesink only (A)
+ * xvimagesink only (A)
* custom_convert - no xv(e.g. memsink, evasimagesink (B)
* videoflip - avsysmemsink(C)
*/
- if (player->set_mode.video_zc)
- {
+ if (player->set_mode.video_zc) {
if (player->pipeline->videobin[MMPLAYER_V_CONV].gst) // B
- {
rotation_type = ROTATION_USING_CUSTOM;
- }
else // A
- {
rotation_type = ROTATION_USING_SINK;
- }
- }
- else
- {
+ } else {
int surface_type = 0;
rotation_type = ROTATION_USING_FLIP;
if ((surface_type == MM_DISPLAY_SURFACE_OVERLAY) ||
(surface_type == MM_DISPLAY_SURFACE_EVAS && !strcmp(player->ini.videosink_element_evas, "evaspixmapsink")))
- {
rotation_type = ROTATION_USING_SINK;
- }
else
- {
rotation_type = ROTATION_USING_FLIP; //C
- }
LOGD("using %d type for rotation", rotation_type);
}
/* get property value for setting */
- switch (rotation_type)
- {
- case ROTATION_USING_SINK: // xvimagesink, pixmap
- {
- switch (dest_angle)
- {
- case 0:
- break;
- case 90:
- pro_value = 3; // clockwise 90
- break;
- case 180:
- pro_value = 2;
- break;
- case 270:
- pro_value = 1; // counter-clockwise 90
- break;
- }
+ switch (rotation_type) {
+ case ROTATION_USING_SINK: // xvimagesink, pixmap
+ {
+ switch (dest_angle) {
+ case 0:
+ break;
+ case 90:
+ pro_value = 3; // clockwise 90
+ break;
+ case 180:
+ pro_value = 2;
+ break;
+ case 270:
+ pro_value = 1; // counter-clockwise 90
+ break;
}
- break;
- case ROTATION_USING_CUSTOM:
- {
- gchar *ename = NULL;
- ename = GST_OBJECT_NAME(gst_element_get_factory(player->pipeline->videobin[MMPLAYER_V_CONV].gst));
+ }
+ break;
+ case ROTATION_USING_CUSTOM:
+ {
+ gchar *ename = NULL;
+ ename = GST_OBJECT_NAME(gst_element_get_factory(player->pipeline->videobin[MMPLAYER_V_CONV].gst));
- if (g_strrstr(ename, "fimcconvert"))
- {
- switch (dest_angle)
- {
- case 0:
- break;
- case 90:
- pro_value = 90; // clockwise 90
- break;
- case 180:
- pro_value = 180;
- break;
- case 270:
- pro_value = 270; // counter-clockwise 90
- break;
- }
+ if (g_strrstr(ename, "fimcconvert")) {
+ switch (dest_angle) {
+ case 0:
+ break;
+ case 90:
+ pro_value = 90; // clockwise 90
+ break;
+ case 180:
+ pro_value = 180;
+ break;
+ case 270:
+ pro_value = 270; // counter-clockwise 90
+ break;
}
}
- break;
- case ROTATION_USING_FLIP: // videoflip
- {
- switch (dest_angle)
- {
-
- case 0:
- break;
- case 90:
- pro_value = 1; // clockwise 90
- break;
- case 180:
- pro_value = 2;
- break;
- case 270:
- pro_value = 3; // counter-clockwise 90
- break;
- }
- }
- break;
+ }
+ break;
+ case ROTATION_USING_FLIP: // videoflip
+ {
+ switch (dest_angle) {
+ case 0:
+ break;
+ case 90:
+ pro_value = 1; // clockwise 90
+ break;
+ case 180:
+ pro_value = 2;
+ break;
+ case 270:
+ pro_value = 3; // counter-clockwise 90
+ break;
+ }
+ }
+ break;
}
LOGD("setting rotation property value : %d, used rotation type : %d", pro_value, rotation_type);
mm_attrs_get_data_by_name(attrs, "display_overlay", &handle);
- if (handle)
- {
+ if (handle) {
/*It should be set after setting window*/
mm_attrs_get_int_by_name(attrs, "wl_window_render_x", &wl_window_x);
mm_attrs_get_int_by_name(attrs, "wl_window_render_y", &wl_window_y);
mm_attrs_get_data_by_name(attrs, "display_overlay", &handle);
mm_attrs_get_int_by_name(attrs, "use_wl_surface", &use_wl_surface);
- if (handle && !use_wl_surface) { /* default is using wl_surface_id */
+ if (handle && !use_wl_surface) {
+ /* default is using wl_surface_id */
unsigned int wl_surface_id = 0;
wl_surface_id = *(int*)handle;
LOGD("set video param : wl_surface_id %d %p", wl_surface_id, *(int*)handle);
gst_video_overlay_set_wl_window_wl_surface_id(
GST_VIDEO_OVERLAY(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
*(int*)handle);
- }
- else if (handle && use_wl_surface) /* use wl_surface for legacy_player_test */
- {
+ } else if (handle && use_wl_surface) {
+ /* use wl_surface for legacy_player_test */
mm_attrs_get_data_by_name(attrs, "wl_display", &wl_display);
if (wl_display)
context = gst_wayland_display_handle_context_new(wl_display);
gst_video_overlay_set_window_handle(
GST_VIDEO_OVERLAY(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
wl_surface);
- }
- else
- {
+ } else
/* FIXIT : is it error case? */
LOGW("still we don't have a window handle on player attribute. create it's own surface.");
- }
}
if (MM_ERROR_NONE != __mmplayer_video_param_check_video_sink_bin(player))
return MM_ERROR_PLAYER_NOT_INITIALIZED;
- if (strcmp(player->ini.videosink_element_overlay, "waylandsink"))
- {
+ if (strcmp(player->ini.videosink_element_overlay, "waylandsink")) {
LOGE("can not find waylandsink");
return MM_ERROR_PLAYER_INTERNAL;
}
LOGD("param_name : %s", param_name);
if (!g_strcmp0(param_name, "update_all_param"))
- {
update_all_param = TRUE;
- }
if (update_all_param || !g_strcmp0(param_name, "display_overlay"))
- {
__mmplayer_video_param_set_display_overlay(player);
- }
if (update_all_param || !g_strcmp0(param_name, "wl_window_render_x") || !g_strcmp0(param_name, "display_overlay"))
- {
__mmplayer_video_param_set_render_rectangle(player);
- }
if (update_all_param || !g_strcmp0(param_name, "display_method"))
- {
__mmplayer_video_param_set_display_method(player);
- }
if (update_all_param || !g_strcmp0(param_name, "display_visible"))
- {
__mmplayer_video_param_set_display_visible(player);
- }
if (update_all_param || !g_strcmp0(param_name, "display_rotation"))
- {
__mmplayer_video_param_set_display_rotation(player);
- }
return MM_ERROR_NONE;
}
mm_attrs_get_int_by_name(attrs, "display_method", &display_method);
/* if evasimagesink */
- if (!strcmp(player->ini.videosink_element_evas,"evasimagesink"))
- {
- if (object)
- {
+ if (!strcmp(player->ini.videosink_element_evas, "evasimagesink")) {
+ if (object) {
/* if it is evasimagesink, we are not supporting rotation */
- if (user_angle != 0)
- {
+ if (user_angle != 0) {
mm_attrs_set_int_by_name(attrs, "display_rotation", MM_DISPLAY_ROTATION_NONE);
if (mmf_attrs_commit(attrs)) /* return -1 if error */
LOGE("failed to commit\n");
LOGD("set video param : method %d", display_method);
LOGD("set video param : evas-object %x, visible %d", object, visible);
LOGD("set video param : evas-object %x, rotate %d", object, rotation_value);
- }
- else
- {
+ } else {
LOGE("no evas object");
return MM_ERROR_PLAYER_INTERNAL;
}
/* if evasimagesink using converter */
- if (player->set_mode.video_zc && player->pipeline->videobin[MMPLAYER_V_CONV].gst)
- {
+ if (player->set_mode.video_zc && player->pipeline->videobin[MMPLAYER_V_CONV].gst) {
int width = 0;
int height = 0;
int no_scaling = !scaling;
g_object_set(player->pipeline->videobin[MMPLAYER_V_CONV].gst, "src-rand-idx", TRUE, NULL);
g_object_set(player->pipeline->videobin[MMPLAYER_V_CONV].gst, "dst-buffer-num", 5, NULL);
- if (no_scaling)
- {
+ if (no_scaling) {
/* no-scaling order to fimcconvert, original width, height size of media src will be passed to sink plugin */
g_object_set(player->pipeline->videobin[MMPLAYER_V_CONV].gst,
"dst-width", 0, /* setting 0, output video width will be media src's width */
"dst-height", 0, /* setting 0, output video height will be media src's height */
NULL);
- }
- else
- {
+ } else {
/* scaling order to fimcconvert */
if (width)
- {
g_object_set(player->pipeline->videobin[MMPLAYER_V_CONV].gst, "dst-width", width, NULL);
- }
if (height)
- {
g_object_set(player->pipeline->videobin[MMPLAYER_V_CONV].gst, "dst-height", height, NULL);
- }
LOGD("set video param : video frame scaling down to width(%d) height(%d)", width, height);
}
LOGD("set video param : display_evas_do_scaling %d", scaling);
return MM_ERROR_PLAYER_NOT_INITIALIZED;
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("cannot get content attribute");
return MM_ERROR_PLAYER_INTERNAL;
}
LOGD("check display surface type attribute: %d", surface_type);
/* configuring display */
- switch (surface_type)
- {
- case MM_DISPLAY_SURFACE_OVERLAY:
+ switch (surface_type) {
+ case MM_DISPLAY_SURFACE_OVERLAY:
{
ret = __mmplayer_update_wayland_videosink_video_param(player, param_name);
if (ret != MM_ERROR_NONE)
return ret;
}
break;
- case MM_DISPLAY_SURFACE_EVAS:
+ case MM_DISPLAY_SURFACE_EVAS:
{
ret = __mmplayer_update_evas_videosink_video_param(player);
if (ret != MM_ERROR_NONE)
return ret;
}
break;
- case MM_DISPLAY_SURFACE_NULL:
+ case MM_DISPLAY_SURFACE_NULL:
{
/* do nothing */
}
break;
- case MM_DISPLAY_SURFACE_REMOTE:
+ case MM_DISPLAY_SURFACE_REMOTE:
{
/* do nothing */
}
prv_element = (MMPlayerGstElement*)bucket->data;
bucket = bucket->next;
- for (; bucket; bucket = bucket->next)
- {
+ for (; bucket; bucket = bucket->next) {
element = (MMPlayerGstElement*)bucket->data;
- if (element && element->gst)
- {
+ if (element && element->gst) {
/* If next element is audio appsrc then make a separate audio pipeline */
- if (!strcmp(GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),"audio_appsrc") ||
- !strcmp(GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),"subtitle_appsrc"))
- {
+ if (!strcmp(GST_ELEMENT_NAME(GST_ELEMENT(element->gst)), "audio_appsrc") ||
+ !strcmp(GST_ELEMENT_NAME(GST_ELEMENT(element->gst)), "subtitle_appsrc")) {
prv_element = element;
continue;
}
if (prv_element && prv_element->gst) {
- if (GST_ELEMENT_LINK(GST_ELEMENT(prv_element->gst), GST_ELEMENT(element->gst)))
- {
+ if (GST_ELEMENT_LINK(GST_ELEMENT(prv_element->gst), GST_ELEMENT(element->gst))) {
LOGD("linking [%s] to [%s] success\n",
GST_ELEMENT_NAME(GST_ELEMENT(prv_element->gst)),
GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
- successful_link_count ++;
- }
- else
- {
+ successful_link_count++;
+ } else {
LOGD("linking [%s] to [%s] failed\n",
GST_ELEMENT_NAME(GST_ELEMENT(prv_element->gst)),
GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
MMPLAYER_RETURN_VAL_IF_FAIL(element_bucket, 0);
MMPLAYER_RETURN_VAL_IF_FAIL(bin, 0);
- for (; bucket; bucket = bucket->next)
- {
+ for (; bucket; bucket = bucket->next) {
element = (MMPlayerGstElement*)bucket->data;
- if (element && element->gst)
- {
- if (!gst_bin_add(bin, GST_ELEMENT(element->gst)))
- {
+ if (element && element->gst) {
+ if (!gst_bin_add(bin, GST_ELEMENT(element->gst))) {
LOGD("__mmplayer_gst_element_link_bucket : Adding element [%s] to bin [%s] failed\n",
GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
GST_ELEMENT_NAME(GST_ELEMENT(bin)));
return 0;
}
- successful_add_count ++;
+ successful_add_count++;
}
}
caps = gst_pad_get_current_caps(pad);
if (!caps)
- {
return;
- }
str = gst_caps_get_structure(caps, 0);
if (!str)
- {
goto ERROR;
- }
name = gst_structure_get_name(str);
if (!name)
- {
goto ERROR;
- }
LOGD("name = %s\n", name);
- if (strstr(name, "audio"))
- {
+ if (strstr(name, "audio")) {
_mmplayer_update_content_attrs(player, ATTR_AUDIO);
- if (player->audio_stream_changed_cb)
- {
+ if (player->audio_stream_changed_cb) {
LOGE("call the audio stream changed cb\n");
player->audio_stream_changed_cb(player->audio_stream_changed_cb_user_param);
}
- }
- else if (strstr(name, "video"))
- {
+ } else if (strstr(name, "video")) {
_mmplayer_update_content_attrs(player, ATTR_VIDEO);
- if (player->video_stream_changed_cb)
- {
+ if (player->video_stream_changed_cb) {
LOGE("call the video stream changed cb\n");
player->video_stream_changed_cb(player->video_stream_changed_cb_user_param);
}
- }
- else
- {
+ } else
goto ERROR;
- }
ERROR:
#define MMPLAYER_CREATEONLY_ELEMENT(x_bin, x_id, x_factory, x_name) \
x_bin[x_id].id = x_id;\
x_bin[x_id].gst = gst_element_factory_make(x_factory, x_name);\
-if (!x_bin[x_id].gst)\
-{\
+if (!x_bin[x_id].gst) {\
LOGE("failed to create %s \n", x_factory);\
goto ERROR;\
-}\
+} \
#define MMPLAYER_CREATE_ELEMENT_ADD_BIN(x_bin, x_id, x_factory, x_name, y_bin, x_player) \
x_bin[x_id].id = x_id;\
x_bin[x_id].gst = gst_element_factory_make(x_factory, x_name);\
-if (!x_bin[x_id].gst)\
-{\
+if (!x_bin[x_id].gst) {\
LOGE("failed to create %s \n", x_factory);\
goto ERROR;\
-}\
-else\
-{\
+} else {\
if (x_player->ini.set_dump_element_flag)\
__mmplayer_add_dump_buffer_probe(x_player, x_bin[x_id].gst);\
-}\
-if (!gst_bin_add(GST_BIN(y_bin), GST_ELEMENT(x_bin[x_id].gst)))\
-{\
+} \
+if (!gst_bin_add(GST_BIN(y_bin), GST_ELEMENT(x_bin[x_id].gst))) { \
LOGD("__mmplayer_gst_element_link_bucket : Adding element [%s] to bin [%s] failed\n",\
GST_ELEMENT_NAME(GST_ELEMENT(x_bin[x_id].gst)),\
GST_ELEMENT_NAME(GST_ELEMENT(y_bin)));\
goto ERROR;\
-}\
+} \
/* macro for code readability. just for sinkbin-creation functions */
#define MMPLAYER_CREATE_ELEMENT(x_bin, x_id, x_factory, x_name, x_add_bucket, x_player) \
-do \
-{ \
+do {\
x_bin[x_id].id = x_id;\
x_bin[x_id].gst = gst_element_factory_make(x_factory, x_name);\
- if (!x_bin[x_id].gst)\
- {\
+ if (!x_bin[x_id].gst) {\
LOGE("failed to create %s \n", x_factory);\
goto ERROR;\
- }\
- else\
- {\
+ } else {\
if (x_player->ini.set_dump_element_flag)\
__mmplayer_add_dump_buffer_probe(x_player, x_bin[x_id].gst);\
- }\
+ } \
if (x_add_bucket)\
element_bucket = g_list_append(element_bucket, &x_bin[x_id]);\
} while (0);
LOGD("[%lld] total: %d, data: %d, buffer: %d", channel_mask, tmp->data_size, a_size, tmp->buff_size);
if (tmp->data_size + a_size < tmp->buff_size) {
- memcpy(tmp->pcm_data+tmp->data_size, a_data, a_size);
+ memcpy(tmp->pcm_data + tmp->data_size, a_data, a_size);
tmp->data_size += a_size;
} else {
/* send data to client */
if (!player->audio_stream_sink_sync) {
/* If sync is FALSE, use buffer list to reduce the IPC. */
- a_buffer->buff_size = (a_size>player->ini.pcm_buffer_size)?(a_size):(player->ini.pcm_buffer_size);
+ a_buffer->buff_size = (a_size > player->ini.pcm_buffer_size) ? (a_size) : (player->ini.pcm_buffer_size);
a_buffer->pcm_data = g_malloc(a_buffer->buff_size);
if (a_buffer->pcm_data == NULL) {
LOGE("failed to alloc data.");
MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && player->pipeline->mainbin);
queue = gst_element_factory_make("queue", NULL);
- if (queue == NULL)
- {
+ if (queue == NULL) {
LOGD("fail make queue\n");
goto ERROR;
}
sink = gst_element_factory_make("fakesink", NULL);
- if (sink == NULL)
- {
+ if (sink == NULL) {
LOGD("fail make fakesink\n");
goto ERROR;
}
gst_bin_add_many(GST_BIN(audiobin[MMPLAYER_A_BIN].gst), queue, sink, NULL);
- if (!gst_element_link_pads_full(queue, "src", sink, "sink", GST_PAD_LINK_CHECK_NOTHING))
- {
+ if (!gst_element_link_pads_full(queue, "src", sink, "sink", GST_PAD_LINK_CHECK_NOTHING)) {
LOGW("failed to link queue & sink\n");
goto ERROR;
}
sinkpad = gst_element_get_static_pad(queue, "sink");
- if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad)) {
LOGW("failed to link [%s:%s] to queue\n", GST_DEBUG_PAD_NAME(pad));
goto ERROR;
}
ERROR:
LOGE("__mmplayer_gst_audio_deinterleave_pad_added ERROR\n");
- if (queue)
- {
+ if (queue) {
gst_object_unref(GST_OBJECT(queue));
queue = NULL;
}
- if (sink)
- {
+ if (sink) {
gst_object_unref(GST_OBJECT(sink));
sink = NULL;
}
- if (sinkpad)
- {
+ if (sinkpad) {
gst_object_unref(GST_OBJECT(sinkpad));
sinkpad = NULL;
}
mm_attrs_get_int_by_name(attrs, "sound_stream_index", &stream_id);
mm_attrs_get_string_by_name(attrs, "sound_stream_type", &stream_type);
- if (!stream_type)
- {
+ if (!stream_type) {
LOGE("stream_type is null.\n");
- }
- else
- {
+ } else {
snprintf(stream_props, sizeof(stream_props)-1, "props,media.role=%s, media.parent_id=%d", stream_type, stream_id);
props = gst_structure_from_string(stream_props, NULL);
g_object_set(player->pipeline->audiobin[MMPLAYER_A_SINK].gst, "stream-properties", props, NULL);
mm_attrs_get_int_by_name(attrs, "sound_latency_mode", &latency_mode);
- switch (latency_mode)
- {
- case AUDIO_LATENCY_MODE_LOW:
- latency = g_strndup("low", 3);
- break;
- case AUDIO_LATENCY_MODE_MID:
- latency = g_strndup("mid", 3);
- break;
- case AUDIO_LATENCY_MODE_HIGH:
- latency = g_strndup("high", 4);
- break;
+ switch (latency_mode) {
+ case AUDIO_LATENCY_MODE_LOW:
+ latency = g_strndup("low", 3);
+ break;
+ case AUDIO_LATENCY_MODE_MID:
+ latency = g_strndup("mid", 3);
+ break;
+ case AUDIO_LATENCY_MODE_HIGH:
+ latency = g_strndup("high", 4);
+ break;
};
#if 0 //need to check
if (player->sound_focus.user_route_policy != 0)
- {
route_path = player->sound_focus.user_route_policy;
- }
g_object_set(player->pipeline->audiobin[MMPLAYER_A_SINK].gst,
"latency", latency_mode,
GstPad *ghostpad = NULL;
GList* element_bucket = NULL;
gboolean link_audio_sink_now = TRUE;
- int i =0;
+ int i = 0;
MMPLAYER_FENTER();
/* alloc handles */
audiobin = (MMPlayerGstElement*)g_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_A_NUM);
- if (!audiobin)
- {
+ if (!audiobin) {
LOGE("failed to allocate memory for audiobin\n");
return MM_ERROR_PLAYER_NO_FREE_SPACE;
}
/* create bin */
audiobin[MMPLAYER_A_BIN].id = MMPLAYER_A_BIN;
audiobin[MMPLAYER_A_BIN].gst = gst_bin_new("audiobin");
- if (!audiobin[MMPLAYER_A_BIN].gst)
- {
+ if (!audiobin[MMPLAYER_A_BIN].gst) {
LOGE("failed to create audiobin\n");
goto ERROR;
}
/* resampler */
MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_RESAMPLER, player->ini.audioresampler_element, "audio resampler", TRUE, player);
- if (player->set_mode.pcm_extraction) // pcm extraction only and no sound output
- {
- if (player->audio_stream_render_cb_ex)
- {
+ if (player->set_mode.pcm_extraction) {
+ // pcm extraction only and no sound output
+ if (player->audio_stream_render_cb_ex) {
char *caps_str = NULL;
GstCaps* caps = NULL;
gchar *format = NULL;
(audiobin[MMPLAYER_A_DEINTERLEAVE].gst),
MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "pad-added",
G_CALLBACK(__mmplayer_gst_audio_deinterleave_pad_added), player);
- }
- else
- {
+ } else {
int dst_samplerate = 0;
int dst_channels = 0;
int dst_depth = 0;
/* set sync */
g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "sync", FALSE, NULL);
}
- }
- else // normal playback
- {
+ } else {
+ // normal playback
//GstCaps* caps = NULL;
gint channels = 0;
MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_VOL, "volume", "volume", TRUE, player);
g_object_set(G_OBJECT(audiobin[MMPLAYER_A_VOL].gst), "volume", player->sound.volume, NULL);
- if (player->sound.mute)
- {
+ if (player->sound.mute) {
LOGD("mute enabled\n");
g_object_set(G_OBJECT(audiobin[MMPLAYER_A_VOL].gst), "mute", player->sound.mute, NULL);
}
#endif
/* chech if multi-chennels */
- if (player->pipeline->mainbin && player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst)
- {
+ if (player->pipeline->mainbin && player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst) {
GstPad *srcpad = NULL;
GstCaps *caps = NULL;
- if ((srcpad = gst_element_get_static_pad(player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst, "src")))
- {
- if ((caps = gst_pad_query_caps(srcpad, NULL)))
- {
+ if ((srcpad = gst_element_get_static_pad(player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst, "src"))) {
+ if ((caps = gst_pad_query_caps(srcpad, NULL))) {
//MMPLAYER_LOG_GST_CAPS_TYPE(caps);
GstStructure *str = gst_caps_get_structure(caps, 0);
if (str)
/* audio effect element. if audio effect is enabled */
if ((strcmp(player->ini.audioeffect_element, ""))
&& (channels <= 2)
- && (player->ini.use_audio_effect_preset || player->ini.use_audio_effect_custom))
- {
+ && (player->ini.use_audio_effect_preset || player->ini.use_audio_effect_custom)) {
MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_FILTER, player->ini.audioeffect_element, "audio effect filter", TRUE, player);
LOGD("audio effect config. bypass = %d, effect type = %d", player->bypass_audio_effect, player->audio_effect_info.effect_type);
if ((!player->bypass_audio_effect)
- && (player->ini.use_audio_effect_preset || player->ini.use_audio_effect_custom))
- {
- if (MM_AUDIO_EFFECT_TYPE_CUSTOM == player->audio_effect_info.effect_type)
- {
+ && (player->ini.use_audio_effect_preset || player->ini.use_audio_effect_custom)) {
+ if (MM_AUDIO_EFFECT_TYPE_CUSTOM == player->audio_effect_info.effect_type) {
if (!_mmplayer_audio_effect_custom_apply(player))
- {
LOGI("apply audio effect(custom) setting success\n");
- }
}
}
if ((strcmp(player->ini.audioeffect_element_custom, ""))
&& (player->set_mode.rich_audio))
- {
MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_FILTER_SEC, player->ini.audioeffect_element_custom, "audio effect filter custom", TRUE, player);
- }
}
- if (!MMPLAYER_IS_RTSP_STREAMING(player))
- {
+ if (!MMPLAYER_IS_RTSP_STREAMING(player)) {
if (player->set_mode.rich_audio && channels <= 2)
MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_VSP, "audiovsp", "x-speed", TRUE, player);
}
MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_SINK, player->ini.audiosink_element, "audiosink", link_audio_sink_now, player);
/* qos on */
- g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "qos", TRUE, NULL); /* qos on */
+ g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "qos", TRUE, NULL); /* qos on */
g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "slave-method", GST_AUDIO_BASE_SINK_SLAVE_NONE, NULL);
- if (player->videodec_linked && player->ini.use_system_clock)
- {
+ if (player->videodec_linked && player->ini.use_system_clock) {
LOGD("system clock will be used.\n");
g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "provide-clock", FALSE, NULL);
}
__mmplayer_gst_set_audiosink_property(player, attrs);
}
- if (audiobin[MMPLAYER_A_SINK].gst)
- {
+ if (audiobin[MMPLAYER_A_SINK].gst) {
GstPad *sink_pad = NULL;
sink_pad = gst_element_get_static_pad(audiobin[MMPLAYER_A_SINK].gst, "sink");
MMPLAYER_SIGNAL_CONNECT(player, sink_pad, MM_PLAYER_SIGNAL_TYPE_AUDIOBIN,
/* adding created elements to bin */
LOGD("adding created elements to bin\n");
- if (!__mmplayer_gst_element_add_bucket_to_bin(GST_BIN(audiobin[MMPLAYER_A_BIN].gst), element_bucket))
- {
+ if (!__mmplayer_gst_element_add_bucket_to_bin(GST_BIN(audiobin[MMPLAYER_A_BIN].gst), element_bucket)) {
LOGE("failed to add elements\n");
goto ERROR;
}
/* linking elements in the bucket by added order. */
LOGD("Linking elements in the bucket by added order.\n");
- if (__mmplayer_gst_element_link_bucket(element_bucket) == -1)
- {
+ if (__mmplayer_gst_element_link_bucket(element_bucket) == -1) {
LOGE("failed to link elements\n");
goto ERROR;
}
/* get first element's sinkpad for creating ghostpad */
first_element = (MMPlayerGstElement *)element_bucket->data;
- if (!first_element)
- {
+ if (!first_element) {
LOGE("failed to get first elem\n");
goto ERROR;
}
pad = gst_element_get_static_pad(GST_ELEMENT(first_element->gst), "sink");
- if (!pad)
- {
+ if (!pad) {
LOGE("failed to get pad from first element of audiobin\n");
goto ERROR;
}
ghostpad = gst_ghost_pad_new("sink", pad);
- if (!ghostpad)
- {
+ if (!ghostpad) {
LOGE("failed to create ghostpad\n");
goto ERROR;
}
- if (FALSE == gst_element_add_pad(audiobin[MMPLAYER_A_BIN].gst, ghostpad))
- {
+ if (FALSE == gst_element_add_pad(audiobin[MMPLAYER_A_BIN].gst, ghostpad)) {
LOGE("failed to add ghostpad to audiobin\n");
goto ERROR;
}
g_list_free(element_bucket);
/* release element which are not added to bin */
- for (i = 1; i < MMPLAYER_A_NUM; i++) /* NOTE : skip bin */
- {
- if (audiobin[i].gst)
- {
+ for (i = 1; i < MMPLAYER_A_NUM; i++) {
+ /* NOTE : skip bin */
+ if (audiobin[i].gst) {
GstObject* parent = NULL;
parent = gst_element_get_parent(audiobin[i].gst);
- if (!parent)
- {
+ if (!parent) {
gst_object_unref(GST_OBJECT(audiobin[i].gst));
audiobin[i].gst = NULL;
- }
- else
- {
+ } else
gst_object_unref(GST_OBJECT(parent));
- }
}
}
/* release audiobin with it's childs */
if (audiobin[MMPLAYER_A_BIN].gst)
- {
gst_object_unref(GST_OBJECT(audiobin[MMPLAYER_A_BIN].gst));
- }
MMPLAYER_FREEIF(audiobin);
static guint32 _mmplayer_convert_fourcc_string_to_value(const gchar* format_name)
{
- return format_name[0] | (format_name[1] << 8) | (format_name[2] << 16) | (format_name[3] << 24);
+ return format_name[0] | (format_name[1] << 8) | (format_name[2] << 16) | (format_name[3] << 24);
}
int _mmplayer_video_stream_release_bo(mm_player_t* player, void* bo)
g_mutex_lock(&player->video_bo_mutex);
if (player->video_bo_list) {
- for (l=g_list_first(player->video_bo_list);l;l=g_list_next(l)) {
+ for (l = g_list_first(player->video_bo_list); l; l = g_list_next(l)) {
mm_player_video_bo_info_t* tmp = (mm_player_video_bo_info_t *)l->data;
if (tmp && tmp->bo == bo) {
tmp->using = FALSE;
g_mutex_lock(&player->video_bo_mutex);
if (player->video_bo_list) {
LOGD("destroy video_bo_list : %d", g_list_length(player->video_bo_list));
- for (l=g_list_first(player->video_bo_list);l;l=g_list_next(l)) {
+ for (l = g_list_first(player->video_bo_list); l; l = g_list_next(l)) {
mm_player_video_bo_info_t* tmp = (mm_player_video_bo_info_t *)l->data;
if (tmp) {
if (tmp->bo)
LOGD("bo list exist(len: %d)", idx);
}
- for (; idx<player->ini.num_of_video_bo ; idx++) {
+ for (; idx < player->ini.num_of_video_bo; idx++) {
mm_player_video_bo_info_t* bo_info = g_new(mm_player_video_bo_info_t, 1);
if (!bo_info) {
LOGE("Fail to alloc bo_info.");
while (TRUE) {
/* get bo from list*/
- for (l=g_list_first(player->video_bo_list);l;l=g_list_next(l)){
+ for (l = g_list_first(player->video_bo_list); l; l = g_list_next(l)) {
mm_player_video_bo_info_t* tmp = (mm_player_video_bo_info_t *)l->data;
if (tmp && (tmp->using == FALSE)) {
LOGD("found bo %p to use", tmp->bo);
gst_structure_get_int(structure, "width", & (stream.width));
gst_structure_get_int(structure, "height", & (stream.height));
string_format = gst_structure_get_string(structure, "format");
- if (string_format) {
+ if (string_format)
fourcc = _mmplayer_convert_fourcc_string_to_value(string_format);
- }
stream.format = util_get_pixtype(fourcc);
gst_caps_unref(caps);
caps = NULL;
/*
LOGD("Call video steramCb, data[%p], Width[%d],Height[%d], Format[%d]",
- GST_BUFFER_DATA(buffer), stream.width, stream.height, stream.format);
+ GST_BUFFER_DATA(buffer), stream.width, stream.height, stream.format);
*/
if (stream.width == 0 || stream.height == 0 || stream.format == MM_PIXEL_FORMAT_INVALID) {
tbm_bo_unmap(stream.bo[0]);
}
- if (player->video_stream_cb) {
+ if (player->video_stream_cb)
player->video_stream_cb(&stream, player->video_stream_cb_user_param);
- }
- if (metaBlock) {
+ if (metaBlock)
gst_memory_unmap(metaBlock, &mapinfo);
- } else {
+ else
gst_memory_unmap(dataBlock, &mapinfo);
- }
return;
}
mm_attrs_get_int_by_name(player->attrs, "display_surface_type", (int *)&surface_type);
- if (player->set_mode.video_zc) /* ST12 or SN12 , if player use omx, evasimagesink doesn't use videoconvert */
- {
+ if (player->set_mode.video_zc) {
+ /* ST12 or SN12 , if player use omx, evasimagesink doesn't use videoconvert */
if ((surface_type == MM_DISPLAY_SURFACE_EVAS) && (!strcmp(player->ini.videosink_element_evas, "evasimagesink")))
- {
video_csc = player->ini.videoconverter_element;
- }
else
- {
video_csc = ""; /* Videosinks don't use videoconvert except evasimagesink which use normal video formats */
- }
- }
- else /* sw codec, if player use libav, waylandsink need videoconvert to render shm wl-buffer which support RGB only */
- {
+ } else {
+ /* sw codec, if player use libav, waylandsink need videoconvert to render shm wl-buffer which support RGB only */
if ((surface_type == MM_DISPLAY_SURFACE_OVERLAY) && (!strncmp(player->ini.videosink_element_overlay, "waylandsink", strlen(player->ini.videosink_element_overlay))))
- {
video_csc = "videoconvert";
- }
}
- if (video_csc && (strcmp(video_csc, "")))
- {
+ if (video_csc && (strcmp(video_csc, ""))) {
MMPLAYER_CREATE_ELEMENT(player->pipeline->videobin, MMPLAYER_V_CONV, video_csc, "video converter", TRUE, player);
LOGD("using video converter: %s", video_csc);
}
* This function is to create video pipeline.
*
* @param player [in] handle of player
- * caps [in] src caps of decoder
+ * caps [in] src caps of decoder
* surface_type [in] surface type for video rendering
*
* @return This function returns zero on success.
/* alloc handles */
videobin = (MMPlayerGstElement*)g_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_V_NUM);
if (!videobin)
- {
return MM_ERROR_PLAYER_NO_FREE_SPACE;
- }
player->pipeline->videobin = videobin;
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("cannot get content attribute");
return MM_ERROR_PLAYER_INTERNAL;
}
/* create bin */
videobin[MMPLAYER_V_BIN].id = MMPLAYER_V_BIN;
videobin[MMPLAYER_V_BIN].gst = gst_bin_new("videobin");
- if (!videobin[MMPLAYER_V_BIN].gst)
- {
+ if (!videobin[MMPLAYER_V_BIN].gst) {
LOGE("failed to create videobin");
goto ERROR;
}
}
/* set video sink */
- switch (surface_type)
- {
- case MM_DISPLAY_SURFACE_OVERLAY:
- if (strlen(player->ini.videosink_element_overlay) > 0)
- videosink_element = player->ini.videosink_element_overlay;
- else
- goto ERROR;
- break;
- case MM_DISPLAY_SURFACE_EVAS:
- if (strlen(player->ini.videosink_element_evas) > 0)
- videosink_element = player->ini.videosink_element_evas;
- else
- goto ERROR;
- break;
- case MM_DISPLAY_SURFACE_NULL:
- if (strlen(player->ini.videosink_element_fake) > 0)
- videosink_element = player->ini.videosink_element_fake;
- else
- goto ERROR;
- break;
- case MM_DISPLAY_SURFACE_REMOTE:
- if (strlen(player->ini.videosink_element_fake) > 0)
- videosink_element = player->ini.videosink_element_fake;
- else
- goto ERROR;
- break;
- default:
- LOGE("unidentified surface type");
+ switch (surface_type) {
+ case MM_DISPLAY_SURFACE_OVERLAY:
+ if (strlen(player->ini.videosink_element_overlay) > 0)
+ videosink_element = player->ini.videosink_element_overlay;
+ else
+ goto ERROR;
+ break;
+ case MM_DISPLAY_SURFACE_EVAS:
+ if (strlen(player->ini.videosink_element_evas) > 0)
+ videosink_element = player->ini.videosink_element_evas;
+ else
+ goto ERROR;
+ break;
+ case MM_DISPLAY_SURFACE_NULL:
+ if (strlen(player->ini.videosink_element_fake) > 0)
+ videosink_element = player->ini.videosink_element_fake;
+ else
+ goto ERROR;
+ break;
+ case MM_DISPLAY_SURFACE_REMOTE:
+ if (strlen(player->ini.videosink_element_fake) > 0)
+ videosink_element = player->ini.videosink_element_fake;
+ else
goto ERROR;
+ break;
+ default:
+ LOGE("unidentified surface type");
+ goto ERROR;
}
LOGD("selected videosink name: %s", videosink_element);
/* additional setting for sink plug-in */
switch (surface_type) {
- case MM_DISPLAY_SURFACE_OVERLAY:
- {
- bool use_tbm = player->set_mode.video_zc;
- if (!use_tbm)
- {
- LOGD("selected videosink name: %s", videosink_element);
+ case MM_DISPLAY_SURFACE_OVERLAY:
+ {
+ bool use_tbm = player->set_mode.video_zc;
+ if (!use_tbm) {
+ LOGD("selected videosink name: %s", videosink_element);
- /* support shard memory with S/W codec on HawkP */
- if (strncmp(videosink_element, "waylandsink", strlen(videosink_element)) == 0)
- {
- g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst,
- "use-tbm", use_tbm, NULL);
- }
+ /* support shard memory with S/W codec on HawkP */
+ if (strncmp(videosink_element, "waylandsink", strlen(videosink_element)) == 0) {
+ g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst,
+ "use-tbm", use_tbm, NULL);
}
- else
- {
- if (attrs)
- {
- int gapless = 0;
+ } else {
+ if (attrs) {
+ int gapless = 0;
- mm_attrs_get_int_by_name(attrs, "gapless_mode", &gapless);
+ mm_attrs_get_int_by_name(attrs, "gapless_mode", &gapless);
- if (gapless > 0) {
- LOGD("disable last-sample");
- g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "enable-last-sample", FALSE, NULL);
- }
+ if (gapless > 0) {
+ LOGD("disable last-sample");
+ g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "enable-last-sample", FALSE, NULL);
}
}
- break;
- }
- case MM_DISPLAY_SURFACE_REMOTE:
- {
- if (player->set_mode.media_packet_video_stream) {
- LOGE("add data probe at videosink");
- g_object_set(G_OBJECT(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
- "sync", TRUE, "signal-handoffs", TRUE, NULL);
+ }
+ break;
+ }
+ case MM_DISPLAY_SURFACE_REMOTE:
+ {
+ if (player->set_mode.media_packet_video_stream) {
+ LOGE("add data probe at videosink");
+ g_object_set(G_OBJECT(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
+ "sync", TRUE, "signal-handoffs", TRUE, NULL);
- MMPLAYER_SIGNAL_CONNECT(player,
- G_OBJECT(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
- MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
- "handoff",
- G_CALLBACK(__mmplayer_video_stream_decoded_render_cb),
- (gpointer)player);
+ MMPLAYER_SIGNAL_CONNECT(player,
+ G_OBJECT(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
+ MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
+ "handoff",
+ G_CALLBACK(__mmplayer_video_stream_decoded_render_cb),
+ (gpointer)player);
- MMPLAYER_SIGNAL_CONNECT(player,
- G_OBJECT(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
- MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
- "preroll-handoff",
- G_CALLBACK(__mmplayer_video_stream_decoded_preroll_cb),
- (gpointer)player);
- }
- break;
+ MMPLAYER_SIGNAL_CONNECT(player,
+ G_OBJECT(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
+ MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
+ "preroll-handoff",
+ G_CALLBACK(__mmplayer_video_stream_decoded_preroll_cb),
+ (gpointer)player);
}
- default:
- break;
+ break;
+ }
+ default:
+ break;
}
if (_mmplayer_update_video_param(player, "update_all_param") != MM_ERROR_NONE)
goto ERROR;
- if (videobin[MMPLAYER_V_SINK].gst)
- {
+ if (videobin[MMPLAYER_V_SINK].gst) {
GstPad *sink_pad = NULL;
sink_pad = gst_element_get_static_pad(videobin[MMPLAYER_V_SINK].gst, "sink");
- if (sink_pad)
- {
+ if (sink_pad) {
MMPLAYER_SIGNAL_CONNECT(player, sink_pad, MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
"notify::caps", G_CALLBACK(__mmplayer_gst_caps_notify_cb), player);
gst_object_unref(GST_OBJECT(sink_pad));
- }
- else
- {
+ } else
LOGW("failed to get sink pad from videosink\n");
- }
}
/* store it as it's sink element */
__mmplayer_add_sink(player, videobin[MMPLAYER_V_SINK].gst);
/* adding created elements to bin */
- if (!__mmplayer_gst_element_add_bucket_to_bin(GST_BIN(videobin[MMPLAYER_V_BIN].gst), element_bucket))
- {
+ if (!__mmplayer_gst_element_add_bucket_to_bin(GST_BIN(videobin[MMPLAYER_V_BIN].gst), element_bucket)) {
LOGE("failed to add elements\n");
goto ERROR;
}
/* Linking elements in the bucket by added order */
- if (__mmplayer_gst_element_link_bucket(element_bucket) == -1)
- {
+ if (__mmplayer_gst_element_link_bucket(element_bucket) == -1) {
LOGE("failed to link elements\n");
goto ERROR;
}
/* get first element's sinkpad for creating ghostpad */
if (element_bucket)
first_element = (MMPlayerGstElement *)element_bucket->data;
- if (!first_element)
- {
+ if (!first_element) {
LOGE("failed to get first element from bucket\n");
goto ERROR;
}
pad = gst_element_get_static_pad(GST_ELEMENT(first_element->gst), "sink");
- if (!pad)
- {
+ if (!pad) {
LOGE("failed to get pad from first element\n");
goto ERROR;
}
/* create ghostpad */
player->ghost_pad_for_videobin = gst_ghost_pad_new("sink", pad);
- if (FALSE == gst_element_add_pad(videobin[MMPLAYER_V_BIN].gst, player->ghost_pad_for_videobin))
- {
+ if (FALSE == gst_element_add_pad(videobin[MMPLAYER_V_BIN].gst, player->ghost_pad_for_videobin)) {
LOGE("failed to add ghostpad to videobin\n");
goto ERROR;
}
/* release videobin with it's childs */
if (videobin[MMPLAYER_V_BIN].gst)
- {
gst_object_unref(GST_OBJECT(videobin[MMPLAYER_V_BIN].gst));
- }
MMPLAYER_FREEIF(videobin);
g_object_set(G_OBJECT(textbin[MMPLAYER_T_FAKE_SINK].gst), "sync", TRUE, NULL);
g_object_set(G_OBJECT(textbin[MMPLAYER_T_FAKE_SINK].gst), "signal-handoffs", TRUE, NULL);
- if (!player->play_subtitle)
- {
+ if (!player->play_subtitle) {
LOGD("add textbin sink as sink element of whole pipeline.\n");
__mmplayer_add_sink(player, GST_ELEMENT(textbin[MMPLAYER_T_FAKE_SINK].gst));
}
/* adding created elements to bin */
LOGD("adding created elements to bin\n");
- if (!__mmplayer_gst_element_add_bucket_to_bin(GST_BIN(textbin[MMPLAYER_T_BIN].gst), element_bucket))
- {
+ if (!__mmplayer_gst_element_add_bucket_to_bin(GST_BIN(textbin[MMPLAYER_T_BIN].gst), element_bucket)) {
LOGE("failed to add elements\n");
goto ERROR;
}
/* linking elements in the bucket by added order. */
LOGD("Linking elements in the bucket by added order.\n");
- if (__mmplayer_gst_element_link_bucket(element_bucket) == -1)
- {
+ if (__mmplayer_gst_element_link_bucket(element_bucket) == -1) {
LOGE("failed to link elements\n");
goto ERROR;
}
/* done. free allocated variables */
g_list_free(element_bucket);
- if (textbin[MMPLAYER_T_QUEUE].gst)
- {
+ if (textbin[MMPLAYER_T_QUEUE].gst) {
GstPad *pad = NULL;
GstPad *ghostpad = NULL;
pad = gst_element_get_static_pad(GST_ELEMENT(textbin[MMPLAYER_T_QUEUE].gst), "sink");
- if (!pad)
- {
+ if (!pad) {
LOGE("failed to get video pad of textbin\n");
return MM_ERROR_PLAYER_INTERNAL;
}
ghostpad = gst_ghost_pad_new("text_sink", pad);
gst_object_unref(pad);
- if (!ghostpad)
- {
+ if (!ghostpad) {
LOGE("failed to create ghostpad of textbin\n");
goto ERROR;
}
- if (!gst_element_add_pad(textbin[MMPLAYER_T_BIN].gst, ghostpad))
- {
+ if (!gst_element_add_pad(textbin[MMPLAYER_T_BIN].gst, ghostpad)) {
LOGE("failed to add ghostpad to textbin\n");
goto ERROR;
}
/* alloc handles */
textbin = (MMPlayerGstElement*)g_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_T_NUM);
- if (!textbin)
- {
+ if (!textbin) {
LOGE("failed to allocate memory for textbin\n");
return MM_ERROR_PLAYER_NO_FREE_SPACE;
}
/* create bin */
textbin[MMPLAYER_T_BIN].id = MMPLAYER_T_BIN;
textbin[MMPLAYER_T_BIN].gst = gst_bin_new("textbin");
- if (!textbin[MMPLAYER_T_BIN].gst)
- {
+ if (!textbin[MMPLAYER_T_BIN].gst) {
LOGE("failed to create textbin\n");
goto ERROR;
}
player->pipeline->textbin = textbin;
/* fakesink */
- if (player->use_textoverlay)
- {
+ if (player->use_textoverlay) {
LOGD("use textoverlay for displaying \n");
MMPLAYER_CREATE_ELEMENT_ADD_BIN(textbin, MMPLAYER_T_QUEUE, "queue", "text_t_queue", textbin[MMPLAYER_T_BIN].gst, player);
MMPLAYER_CREATE_ELEMENT_ADD_BIN(textbin, MMPLAYER_T_OVERLAY, "textoverlay", "text_overlay", textbin[MMPLAYER_T_BIN].gst, player);
- if (!gst_element_link_pads(textbin[MMPLAYER_T_VIDEO_QUEUE].gst, "src", textbin[MMPLAYER_T_VIDEO_CONVERTER].gst, "sink"))
- {
+ if (!gst_element_link_pads(textbin[MMPLAYER_T_VIDEO_QUEUE].gst, "src", textbin[MMPLAYER_T_VIDEO_CONVERTER].gst, "sink")) {
LOGE("failed to link queue and converter\n");
goto ERROR;
}
- if (!gst_element_link_pads(textbin[MMPLAYER_T_VIDEO_CONVERTER].gst, "src", textbin[MMPLAYER_T_OVERLAY].gst, "video_sink"))
- {
+ if (!gst_element_link_pads(textbin[MMPLAYER_T_VIDEO_CONVERTER].gst, "src", textbin[MMPLAYER_T_OVERLAY].gst, "video_sink")) {
LOGE("failed to link queue and textoverlay\n");
goto ERROR;
}
- if (!gst_element_link_pads(textbin[MMPLAYER_T_QUEUE].gst, "src", textbin[MMPLAYER_T_OVERLAY].gst, "text_sink"))
- {
+ if (!gst_element_link_pads(textbin[MMPLAYER_T_QUEUE].gst, "src", textbin[MMPLAYER_T_OVERLAY].gst, "text_sink")) {
LOGE("failed to link queue and textoverlay\n");
goto ERROR;
}
- }
- else
- {
+ } else {
int surface_type = 0;
LOGD("use subtitle message for displaying \n");
mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &surface_type);
- switch (surface_type)
- {
- case MM_DISPLAY_SURFACE_OVERLAY:
- case MM_DISPLAY_SURFACE_EVAS:
- case MM_DISPLAY_SURFACE_GL:
- case MM_DISPLAY_SURFACE_NULL:
- case MM_DISPLAY_SURFACE_REMOTE:
- if (__mmplayer_gst_create_plain_text_elements(player) != MM_ERROR_NONE)
- {
- LOGE("failed to make plain text elements\n");
- goto ERROR;
- }
- break;
+ switch (surface_type) {
+ case MM_DISPLAY_SURFACE_OVERLAY:
+ case MM_DISPLAY_SURFACE_EVAS:
+ case MM_DISPLAY_SURFACE_GL:
+ case MM_DISPLAY_SURFACE_NULL:
+ case MM_DISPLAY_SURFACE_REMOTE:
+ if (__mmplayer_gst_create_plain_text_elements(player) != MM_ERROR_NONE) {
+ LOGE("failed to make plain text elements\n");
+ goto ERROR;
+ }
+ break;
- default:
- break;
+ default:
+ break;
}
}
g_list_free(element_bucket);
/* release element which are not added to bin */
- for (i = 1; i < MMPLAYER_T_NUM; i++) /* NOTE : skip bin */
- {
- if (textbin[i].gst)
- {
+ for (i = 1; i < MMPLAYER_T_NUM; i++) {
+ /* NOTE : skip bin */
+ if (textbin[i].gst) {
GstObject* parent = NULL;
parent = gst_element_get_parent(textbin[i].gst);
- if (!parent)
- {
+ if (!parent) {
gst_object_unref(GST_OBJECT(textbin[i].gst));
textbin[i].gst = NULL;
- }
- else
- {
+ } else
gst_object_unref(GST_OBJECT(parent));
- }
}
}
/* release textbin with it's childs */
if (textbin[MMPLAYER_T_BIN].gst)
- {
gst_object_unref(GST_OBJECT(textbin[MMPLAYER_T_BIN].gst));
- }
MMPLAYER_FREEIF(textbin);
MMHandleType attrs = 0;
GstElement *subsrc = NULL;
GstElement *subparse = NULL;
- gchar *subtitle_uri =NULL;
+ gchar *subtitle_uri = NULL;
const gchar *charset = NULL;
GstPad *pad = NULL;
mainbin = player->pipeline->mainbin;
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("cannot get content attribute\n");
return MM_ERROR_PLAYER_INTERNAL;
}
mm_attrs_get_string_by_name(attrs, "subtitle_uri", &subtitle_uri);
- if (!subtitle_uri || strlen(subtitle_uri) < 1)
- {
+ if (!subtitle_uri || strlen(subtitle_uri) < 1) {
LOGE("subtitle uri is not proper filepath.\n");
return MM_ERROR_PLAYER_INVALID_URI;
}
/* create the subtitle source */
subsrc = gst_element_factory_make("filesrc", "subtitle_source");
- if (!subsrc)
- {
+ if (!subsrc) {
LOGE("failed to create filesrc element\n");
goto ERROR;
}
mainbin[MMPLAYER_M_SUBSRC].id = MMPLAYER_M_SUBSRC;
mainbin[MMPLAYER_M_SUBSRC].gst = subsrc;
- if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), subsrc))
- {
+ if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), subsrc)) {
LOGW("failed to add queue\n");
goto ERROR;
}
/* subparse */
subparse = gst_element_factory_make("subparse", "subtitle_parser");
- if (!subparse)
- {
+ if (!subparse) {
LOGE("failed to create subparse element\n");
goto ERROR;
}
charset = util_get_charset(subtitle_uri);
- if (charset)
- {
+ if (charset) {
LOGD("detected charset is %s\n", charset);
g_object_set(G_OBJECT(subparse), "subtitle-encoding", charset, NULL);
}
mainbin[MMPLAYER_M_SUBPARSE].id = MMPLAYER_M_SUBPARSE;
mainbin[MMPLAYER_M_SUBPARSE].gst = subparse;
- if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), subparse))
- {
+ if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), subparse)) {
LOGW("failed to add subparse\n");
goto ERROR;
}
- if (!gst_element_link_pads(subsrc, "src", subparse, "sink"))
- {
+ if (!gst_element_link_pads(subsrc, "src", subparse, "sink")) {
LOGW("failed to link subsrc and subparse\n");
goto ERROR;
}
LOGD("play subtitle using subtitle file\n");
- if (player->pipeline->textbin == NULL)
- {
- if (MM_ERROR_NONE != __mmplayer_gst_create_text_pipeline(player))
- {
+ if (player->pipeline->textbin == NULL) {
+ if (MM_ERROR_NONE != __mmplayer_gst_create_text_pipeline(player)) {
LOGE("failed to create textbin. continuing without text\n");
goto ERROR;
}
- if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), GST_ELEMENT(player->pipeline->textbin[MMPLAYER_T_BIN].gst)))
- {
+ if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), GST_ELEMENT(player->pipeline->textbin[MMPLAYER_T_BIN].gst))) {
LOGW("failed to add textbin\n");
goto ERROR;
}
player->textsink_linked = 1;
player->external_text_idx = 0;
LOGI("player->textsink_linked set to 1\n");
- }
- else
- {
+ } else {
LOGD("text bin has been created. reuse it.");
player->external_text_idx = 1;
}
- if (!gst_element_link_pads(subparse, "src", player->pipeline->textbin[MMPLAYER_T_BIN].gst, "text_sink"))
- {
+ if (!gst_element_link_pads(subparse, "src", player->pipeline->textbin[MMPLAYER_T_BIN].gst, "text_sink")) {
LOGW("failed to link subparse and textbin\n");
goto ERROR;
}
pad = gst_element_get_static_pad(player->pipeline->textbin[MMPLAYER_T_FAKE_SINK].gst, "sink");
- if (!pad)
- {
+ if (!pad) {
LOGE("failed to get sink pad from textsink to probe data");
return MM_ERROR_PLAYER_INTERNAL;
}
__mmplayer_subtitle_adjust_position_probe, player, NULL);
gst_object_unref(pad);
- pad=NULL;
+ pad = NULL;
/* create dot. for debugging */
MMPLAYER_GENERATE_DOT_IF_ENABLED(player, "pipeline-with-subtitle");
text_size = mapinfo.size;
duration = GST_BUFFER_DURATION(buffer);
- if (player->set_mode.subtitle_off)
- {
+ if (player->set_mode.subtitle_off) {
LOGD("subtitle is OFF.\n");
return TRUE;
}
- if (!text || (text_size == 0))
- {
+ if (!text || (text_size == 0)) {
LOGD("There is no subtitle to be displayed.\n");
return TRUE;
}
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- if (player->set_mode.subtitle_off)
- {
+ if (player->set_mode.subtitle_off) {
LOGD("subtitle is OFF.\n");
return TRUE;
}
- if (player->adjust_subtitle_pos == 0)
- {
+ if (player->adjust_subtitle_pos == 0) {
LOGD("nothing to do");
return TRUE;
}
cur_timestamp = GST_BUFFER_TIMESTAMP(buffer);
adjusted_timestamp = (gint64) cur_timestamp +((gint64) player->adjust_subtitle_pos * G_GINT64_CONSTANT(1000000));
- if (adjusted_timestamp < 0)
- {
+ if (adjusted_timestamp < 0) {
LOGD("adjusted_timestamp under zero");
MMPLAYER_FLEAVE();
return FALSE;
return GST_PAD_PROBE_OK;
}
-static int __gst_adjust_subtitle_position(mm_player_t* player, int format, int position)
+static int __gst_adjust_subtitle_position(mm_player_t* player, int format, int position)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
MMPLAYER_RETURN_VAL_IF_FAIL(player->play_subtitle, MM_ERROR_NOT_SUPPORT_API);
- if (position == 0)
- {
+ if (position == 0) {
LOGD("nothing to do\n");
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
- switch (format)
- {
- case MM_PLAYER_POS_FORMAT_TIME:
+ switch (format) {
+ case MM_PLAYER_POS_FORMAT_TIME:
{
/* check current postion */
player->adjust_subtitle_pos = position;
}
break;
- default:
+ default:
{
LOGW("invalid format.\n");
MMPLAYER_FLEAVE();
/* check player and videobin are created */
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
if (!player->pipeline->videobin ||
- !player->pipeline->videobin[MMPLAYER_V_SINK].gst)
- {
+ !player->pipeline->videobin[MMPLAYER_V_SINK].gst) {
LOGD("no video pipeline or sink is there");
return MM_ERROR_PLAYER_INVALID_STATE ;
}
- if (offset == 0)
- {
+ if (offset == 0) {
LOGD("nothing to do\n");
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
- if (__gst_get_position(player, MM_PLAYER_POS_FORMAT_TIME, (unsigned long*)¤t_pos) != MM_ERROR_NONE)
- {
+ if (__gst_get_position(player, MM_PLAYER_POS_FORMAT_TIME, (unsigned long*)¤t_pos) != MM_ERROR_NONE) {
LOGD("failed to get current position");
return MM_ERROR_PLAYER_INTERNAL;
}
- if ((current_pos - offset) < GST_TIME_AS_MSECONDS(player->duration))
- {
+ if ((current_pos - offset) < GST_TIME_AS_MSECONDS(player->duration)) {
LOGD("enter video delay is valid");
- }
- else {
+ } else {
LOGD("enter video delay is crossing content boundary");
return MM_ERROR_INVALID_ARGUMENT ;
}
- g_object_set(G_OBJECT(player->pipeline->videobin[MMPLAYER_V_SINK].gst),"ts-offset", ((gint64) offset * G_GINT64_CONSTANT(1000000)),NULL);
+ g_object_set(G_OBJECT(player->pipeline->videobin[MMPLAYER_V_SINK].gst), "ts-offset", ((gint64) offset * G_GINT64_CONSTANT(1000000)), NULL);
LOGD("video delay has been done");
MMPLAYER_FLEAVE();
buffer = gst_buffer_new();
- if (buf->offset >= buf->len)
- {
+ if (buf->offset >= buf->len) {
LOGD("call eos appsrc\n");
g_signal_emit_by_name(appsrc, "end-of-stream", &ret);
return;
}
if (buf->len - buf->offset < size)
- {
len = buf->len - buf->offset + buf->offset;
- }
gst_buffer_insert_memory(buffer, -1, gst_memory_new_wrapped(0, (guint8 *)(buf->buf + buf->offset), len, 0, len, (guint8*)(buf->buf + buf->offset), g_free));
GST_BUFFER_OFFSET(buffer) = (guint64)buf->offset;
buf->offset = (int)size;
- return TRUE;
+ return TRUE;
}
static void
{
mm_player_t *player = (mm_player_t*)user_data;
MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_DEFAULT;
- guint64 current_level_bytes=0;
+ guint64 current_level_bytes = 0;
MMPLAYER_RETURN_IF_FAIL(player);
LOGI("app-src: feed data\n");
{
mm_player_t *player = (mm_player_t*)user_data;
MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_DEFAULT;
- guint64 current_level_bytes=0;
+ guint64 current_level_bytes = 0;
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
_mmplayer_push_buffer(MMHandleType hplayer, unsigned char *buf, int size) // @
{
mm_player_t* player = (mm_player_t*)hplayer;
- GstBuffer *buffer = NULL;
- GstFlowReturn gst_ret = GST_FLOW_OK;
+ GstBuffer *buffer = NULL;
+ GstFlowReturn gst_ret = GST_FLOW_OK;
int ret = MM_ERROR_NONE;
// gint len = size;
/* NOTE : we should check and create pipeline again if not created as we destroy
* whole pipeline when stopping in streamming playback
*/
- if (!player->pipeline)
- {
- if (MM_ERROR_NONE != __gst_realize(player))
- {
+ if (!player->pipeline) {
+ if (MM_ERROR_NONE != __gst_realize(player)) {
LOGE("failed to realize before starting. only in streamming\n");
return MM_ERROR_PLAYER_INTERNAL;
}
LOGI("app-src: pushing data\n");
- if (buf == NULL)
- {
+ if (buf == NULL) {
LOGE("buf is null\n");
return MM_ERROR_NONE;
}
buffer = gst_buffer_new();
- if (size <= 0)
- {
+ if (size <= 0) {
LOGD("call eos appsrc\n");
g_signal_emit_by_name(player->pipeline->mainbin[MMPLAYER_M_SRC].gst, "end-of-stream", &gst_ret);
return MM_ERROR_NONE;
mm_player_t *player = (mm_player_t *)data;
GstBusSyncReply reply = GST_BUS_DROP;
- if (!(player->pipeline && player->pipeline->mainbin))
- {
+ if (!(player->pipeline && player->pipeline->mainbin)) {
LOGE("player pipeline handle is null");
return GST_BUS_PASS;
}
- if (!__mmplayer_check_useful_message(player, message))
- {
+ if (!__mmplayer_check_useful_message(player, message)) {
gst_message_unref(message);
return GST_BUS_DROP;
}
- switch (GST_MESSAGE_TYPE(message))
- {
- case GST_MESSAGE_STATE_CHANGED:
- /* post directly for fast launch */
- if (player->sync_handler) {
- __mmplayer_gst_callback(NULL, message, player);
- reply = GST_BUS_DROP;
- }
- else {
- reply = GST_BUS_PASS;
- }
- break;
- case GST_MESSAGE_TAG:
- __mmplayer_gst_extract_tag_from_msg(player, message);
-
- #if 0 // debug
- {
- GstTagList *tags = NULL;
+ switch (GST_MESSAGE_TYPE(message)) {
+ case GST_MESSAGE_STATE_CHANGED:
+ /* post directly for fast launch */
+ if (player->sync_handler) {
+ __mmplayer_gst_callback(NULL, message, player);
+ reply = GST_BUS_DROP;
+ } else
+ reply = GST_BUS_PASS;
+ break;
+ case GST_MESSAGE_TAG:
+ __mmplayer_gst_extract_tag_from_msg(player, message);
+
+ #if 0 // debug
+ {
+ GstTagList *tags = NULL;
- gst_message_parse_tag(message, &tags);
- if (tags) {
- LOGE("TAGS received from element \"%s\".\n",
- GST_STR_NULL(GST_ELEMENT_NAME(GST_MESSAGE_SRC(message))));
+ gst_message_parse_tag(message, &tags);
+ if (tags) {
+ LOGE("TAGS received from element \"%s\".\n",
+ GST_STR_NULL(GST_ELEMENT_NAME(GST_MESSAGE_SRC(message))));
- gst_tag_list_foreach(tags, print_tag, NULL);
- gst_tag_list_free(tags);
- tags = NULL;
- }
- break;
+ gst_tag_list_foreach(tags, print_tag, NULL);
+ gst_tag_list_free(tags);
+ tags = NULL;
}
- #endif
break;
+ }
+ #endif
+ break;
- case GST_MESSAGE_DURATION_CHANGED:
- __mmplayer_gst_handle_duration(player, message);
- break;
- case GST_MESSAGE_ASYNC_DONE:
- /* NOTE:Don't call gst_callback directly
- * because previous frame can be showed even though this message is received for seek.
- */
- default:
- reply = GST_BUS_PASS;
- break;
+ case GST_MESSAGE_DURATION_CHANGED:
+ __mmplayer_gst_handle_duration(player, message);
+ break;
+ case GST_MESSAGE_ASYNC_DONE:
+ /* NOTE:Don't call gst_callback directly
+ * because previous frame can be showed even though this message is received for seek.
+ */
+ default:
+ reply = GST_BUS_PASS;
+ break;
}
if (reply == GST_BUS_DROP)
/* create decodebin */
decodebin = gst_element_factory_make("decodebin", name);
- if (!decodebin)
- {
+ if (!decodebin) {
LOGE("error : fail to create decodebin for %d decoder\n", track);
ret = FALSE;
goto ERROR;
MMPLAYER_SIGNAL_CONNECT(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "element-added",
G_CALLBACK(__mmplayer_gst_element_added), player);
- if (!gst_bin_add(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst), decodebin))
- {
+ if (!gst_bin_add(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst), decodebin)) {
LOGE("failed to add new decodebin\n");
ret = FALSE;
goto ERROR;
}
dec_caps = gst_pad_query_caps(srcpad, NULL);
- if (dec_caps)
- {
+ if (dec_caps) {
//LOGD("got pad %s:%s , dec_caps %" GST_PTR_FORMAT, GST_DEBUG_PAD_NAME(srcpad), dec_caps);
g_object_set(G_OBJECT(decodebin), "sink-caps", dec_caps, NULL);
gst_caps_unref(dec_caps);
sinkpad = gst_element_get_static_pad(decodebin, "sink");
- if (GST_PAD_LINK_OK != gst_pad_link(srcpad, sinkpad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(srcpad, sinkpad)) {
LOGW("failed to link [%s:%s] to decoder\n", GST_DEBUG_PAD_NAME(srcpad));
gst_object_unref(GST_OBJECT(decodebin));
}
if (GST_STATE_CHANGE_FAILURE == gst_element_sync_state_with_parent(decodebin))
- {
LOGE("failed to sync second level decodebin state with parent\n");
- }
LOGD("Total num of %d tracks = %d \n", track, player->selector[track].total_track_num);
ERROR:
- if (sinkpad)
- {
+ if (sinkpad) {
gst_object_unref(GST_OBJECT(sinkpad));
sinkpad = NULL;
}
/* get profile attribute */
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("cannot get content attribute\n");
goto INIT_ERROR;
}
/* create pipeline handles */
- if (player->pipeline)
- {
+ if (player->pipeline) {
LOGW("pipeline should be released before create new one\n");
goto INIT_ERROR;
}
/* create pipeline */
mainbin[MMPLAYER_M_PIPE].id = MMPLAYER_M_PIPE;
mainbin[MMPLAYER_M_PIPE].gst = gst_pipeline_new("player");
- if (!mainbin[MMPLAYER_M_PIPE].gst)
- {
+ if (!mainbin[MMPLAYER_M_PIPE].gst) {
LOGE("failed to create pipeline\n");
goto INIT_ERROR;
}
_mmplayer_track_initialize(player);
/* create source element */
- switch (player->profile.uri_type)
- {
- /* rtsp streamming */
- case MM_PLAYER_URI_TYPE_URL_RTSP:
+ switch (player->profile.uri_type) {
+ /* rtsp streamming */
+ case MM_PLAYER_URI_TYPE_URL_RTSP:
{
gint network_bandwidth;
gchar *user_agent, *wap_profile;
element = gst_element_factory_make("rtspsrc", "rtsp source");
- if (!element)
- {
+ if (!element) {
LOGE("failed to create streaming source element\n");
break;
}
/* get attribute */
mm_attrs_get_string_by_name(attrs, "streaming_user_agent", &user_agent);
- mm_attrs_get_string_by_name(attrs,"streaming_wap_profile", &wap_profile);
+ mm_attrs_get_string_by_name(attrs, "streaming_wap_profile", &wap_profile);
mm_attrs_get_int_by_name(attrs, "streaming_network_bandwidth", &network_bandwidth);
SECURE_LOGD("user_agent : %s\n", user_agent);
}
break;
- /* http streaming*/
- case MM_PLAYER_URI_TYPE_URL_HTTP:
+ /* http streaming*/
+ case MM_PLAYER_URI_TYPE_URL_HTTP:
{
gchar *user_agent, *proxy, *cookies, **cookie_list;
gint http_timeout = DEFAULT_HTTP_TIMEOUT;
LOGD("http playback, PD mode : %d\n", player->pd_mode);
- if (!MMPLAYER_IS_HTTP_PD(player))
- {
+ if (!MMPLAYER_IS_HTTP_PD(player)) {
element = gst_element_factory_make(player->ini.httpsrc_element, "http_streaming_source");
- if (!element)
- {
+ if (!element) {
LOGE("failed to create http streaming source element[%s].\n", player->ini.httpsrc_element);
break;
}
mm_attrs_get_int_by_name(attrs, "streaming_timeout", &http_timeout);
if ((http_timeout == DEFAULT_HTTP_TIMEOUT) &&
- (player->ini.http_timeout != DEFAULT_HTTP_TIMEOUT))
- {
+ (player->ini.http_timeout != DEFAULT_HTTP_TIMEOUT)) {
LOGD("get timeout from ini\n");
http_timeout = player->ini.http_timeout;
}
g_object_set(G_OBJECT(element), "user-agent", user_agent, NULL);
if (MMPLAYER_URL_HAS_DASH_SUFFIX(player))
- {
LOGW("it's dash. and it's still experimental feature.");
- }
- }
- else // progressive download
- {
+ } else {
+ // progressive download
gchar* location = NULL;
- if (player->pd_mode == MM_PLAYER_PD_MODE_URI)
- {
+ if (player->pd_mode == MM_PLAYER_PD_MODE_URI) {
gchar *path = NULL;
mm_attrs_get_string_by_name(attrs, "pd_location", &path);
LOGD("PD Location : %s\n", path);
- if (path)
- {
+ if (path) {
player->pd_file_save_path = g_strdup(path);
- }
- else
- {
+ } else {
LOGE("can't find pd location so, it should be set \n");
break;
}
}
element = gst_element_factory_make("pdpushsrc", "PD pushsrc");
- if (!element)
- {
+ if (!element) {
LOGE("failed to create PD push source element[%s].\n", "pdpushsrc");
break;
}
}
break;
- /* file source */
- case MM_PLAYER_URI_TYPE_FILE:
+ /* file source */
+ case MM_PLAYER_URI_TYPE_FILE:
{
LOGD("using filesrc for 'file://' handler.\n");
element = gst_element_factory_make("filesrc", "source");
- if (!element)
- {
+ if (!element) {
LOGE("failed to create filesrc\n");
break;
}
}
break;
- case MM_PLAYER_URI_TYPE_SS:
+ case MM_PLAYER_URI_TYPE_SS:
{
gint http_timeout = DEFAULT_HTTP_TIMEOUT;
element = gst_element_factory_make("souphttpsrc", "http streaming source");
- if (!element)
- {
+ if (!element) {
LOGE("failed to create http streaming source element[%s]", player->ini.httpsrc_element);
break;
}
mm_attrs_get_int_by_name(attrs, "streaming_timeout", &http_timeout);
if ((http_timeout == DEFAULT_HTTP_TIMEOUT) &&
- (player->ini.http_timeout != DEFAULT_HTTP_TIMEOUT))
- {
+ (player->ini.http_timeout != DEFAULT_HTTP_TIMEOUT)) {
LOGD("get timeout from ini\n");
http_timeout = player->ini.http_timeout;
}
}
break;
- /* appsrc */
- case MM_PLAYER_URI_TYPE_BUFF:
+ /* appsrc */
+ case MM_PLAYER_URI_TYPE_BUFF:
{
guint64 stream_type = GST_APP_STREAM_TYPE_STREAM;
LOGD("mem src is selected\n");
element = gst_element_factory_make("appsrc", "buff-source");
- if (!element)
- {
+ if (!element) {
LOGE("failed to create appsrc element\n");
break;
}
G_CALLBACK(__gst_appsrc_enough_data), player);
}
break;
- case MM_PLAYER_URI_TYPE_MS_BUFF:
+ case MM_PLAYER_URI_TYPE_MS_BUFF:
{
LOGD("MS buff src is selected\n");
- if (player->v_stream_caps)
- {
+ if (player->v_stream_caps) {
element = gst_element_factory_make("appsrc", "video_appsrc");
- if (!element)
- {
+ if (!element) {
LOGF("failed to create video app source element[appsrc].\n");
break;
}
- if (player->a_stream_caps)
- {
+ if (player->a_stream_caps) {
elem_src_audio = gst_element_factory_make("appsrc", "audio_appsrc");
- if (!elem_src_audio)
- {
+ if (!elem_src_audio) {
LOGF("failed to create audio app source element[appsrc].\n");
break;
}
}
- }
- else if (player->a_stream_caps)
- {
+ } else if (player->a_stream_caps) {
/* no video, only audio pipeline*/
element = gst_element_factory_make("appsrc", "audio_appsrc");
- if (!element)
- {
+ if (!element) {
LOGF("failed to create audio app source element[appsrc].\n");
break;
}
}
- if (player->s_stream_caps)
- {
+ if (player->s_stream_caps) {
elem_src_subtitle = gst_element_factory_make("appsrc", "subtitle_appsrc");
- if (!elem_src_subtitle)
- {
+ if (!elem_src_subtitle) {
LOGF("failed to create subtitle app source element[appsrc].\n");
break;
}
LOGD("setting app sources properties.\n");
LOGD("location : %s\n", player->profile.uri);
- if (player->v_stream_caps && element)
- {
+ if (player->v_stream_caps && element) {
g_object_set(G_OBJECT(element), "format", GST_FORMAT_TIME,
"blocksize", (guint)1048576, /* size of many video frames are larger than default blocksize as 4096 */
"caps", player->v_stream_caps, NULL);
MMPLAYER_SIGNAL_CONNECT(player, element, MM_PLAYER_SIGNAL_TYPE_OTHERS, "seek-data",
G_CALLBACK(__gst_seek_video_data), player);
- if (player->a_stream_caps && elem_src_audio)
- {
+ if (player->a_stream_caps && elem_src_audio) {
g_object_set(G_OBJECT(elem_src_audio), "format", GST_FORMAT_TIME,
"caps", player->a_stream_caps, NULL);
MMPLAYER_SIGNAL_CONNECT(player, elem_src_audio, MM_PLAYER_SIGNAL_TYPE_OTHERS, "seek-data",
G_CALLBACK(__gst_seek_audio_data), player);
}
- }
- else if (player->a_stream_caps && element)
- {
+ } else if (player->a_stream_caps && element) {
g_object_set(G_OBJECT(element), "format", GST_FORMAT_TIME,
"caps", player->a_stream_caps, NULL);
G_CALLBACK(__gst_seek_audio_data), player);
}
- if (player->s_stream_caps && elem_src_subtitle)
- {
+ if (player->s_stream_caps && elem_src_subtitle) {
g_object_set(G_OBJECT(elem_src_subtitle), "format", GST_FORMAT_TIME,
"caps", player->s_stream_caps, NULL);
G_CALLBACK(__gst_seek_subtitle_data), player);
}
- if (player->v_stream_caps && element)
- {
+ if (player->v_stream_caps && element) {
MMPLAYER_SIGNAL_CONNECT(player, element, MM_PLAYER_SIGNAL_TYPE_OTHERS, "need-data",
G_CALLBACK(__gst_appsrc_feed_video_data), player);
MMPLAYER_SIGNAL_CONNECT(player, element, MM_PLAYER_SIGNAL_TYPE_OTHERS, "enough-data",
G_CALLBACK(__gst_appsrc_enough_video_data), player);
- if (player->a_stream_caps && elem_src_audio)
- {
+ if (player->a_stream_caps && elem_src_audio) {
MMPLAYER_SIGNAL_CONNECT(player, elem_src_audio, MM_PLAYER_SIGNAL_TYPE_OTHERS, "need-data",
G_CALLBACK(__gst_appsrc_feed_audio_data), player);
MMPLAYER_SIGNAL_CONNECT(player, elem_src_audio, MM_PLAYER_SIGNAL_TYPE_OTHERS, "enough-data",
G_CALLBACK(__gst_appsrc_enough_audio_data), player);
}
- }
- else if (player->a_stream_caps && element)
- {
+ } else if (player->a_stream_caps && element) {
MMPLAYER_SIGNAL_CONNECT(player, element, MM_PLAYER_SIGNAL_TYPE_OTHERS, "need-data",
G_CALLBACK(__gst_appsrc_feed_audio_data), player);
MMPLAYER_SIGNAL_CONNECT(player, element, MM_PLAYER_SIGNAL_TYPE_OTHERS, "enough-data",
}
if (player->s_stream_caps && elem_src_subtitle)
- {
MMPLAYER_SIGNAL_CONNECT(player, elem_src_subtitle, MM_PLAYER_SIGNAL_TYPE_OTHERS, "need-data",
G_CALLBACK(__gst_appsrc_feed_subtitle_data), player);
- }
need_state_holder = FALSE;
LOGE("failed to commit\n");
}
break;
- /* appsrc */
- case MM_PLAYER_URI_TYPE_MEM:
+ /* appsrc */
+ case MM_PLAYER_URI_TYPE_MEM:
{
guint64 stream_type = GST_APP_STREAM_TYPE_RANDOM_ACCESS;
LOGD("mem src is selected\n");
element = gst_element_factory_make("appsrc", "mem-source");
- if (!element)
- {
+ if (!element) {
LOGE("failed to create appsrc element\n");
break;
}
G_CALLBACK(__gst_appsrc_feed_data_mem), &player->mem_buf);
}
break;
- case MM_PLAYER_URI_TYPE_URL:
+ case MM_PLAYER_URI_TYPE_URL:
break;
- case MM_PLAYER_URI_TYPE_TEMP:
+ case MM_PLAYER_URI_TYPE_TEMP:
break;
- case MM_PLAYER_URI_TYPE_NONE:
- default:
+ case MM_PLAYER_URI_TYPE_NONE:
+ default:
break;
}
/* check source element is OK */
- if (!element)
- {
+ if (!element) {
LOGE("no source element was created.\n");
goto INIT_ERROR;
}
mainbin[MMPLAYER_M_SRC].gst = element;
element_bucket = g_list_append(element_bucket, &mainbin[MMPLAYER_M_SRC]);
- if ((MMPLAYER_IS_STREAMING(player)) && (player->streamer == NULL))
- {
+ if ((MMPLAYER_IS_STREAMING(player)) && (player->streamer == NULL)) {
player->streamer = __mm_player_streaming_create();
__mm_player_streaming_initialize(player->streamer);
}
- if (MMPLAYER_IS_HTTP_PD(player))
- {
+ if (MMPLAYER_IS_HTTP_PD(player)) {
gdouble pre_buffering_time = (gdouble)player->streamer->buffering_req.initial_second;
LOGD("Picked queue2 element(pre buffer : %d sec)....\n", pre_buffering_time);
element = gst_element_factory_make("queue2", "queue2");
- if (!element)
- {
+ if (!element) {
LOGE("failed to create http streaming buffer element\n");
goto INIT_ERROR;
}
mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst = element;
element_bucket = g_list_append(element_bucket, &mainbin[MMPLAYER_M_MUXED_S_BUFFER]);
- pre_buffering_time = (pre_buffering_time > 0)?(pre_buffering_time):(player->ini.http_buffering_time);
+ pre_buffering_time = (pre_buffering_time > 0) ? (pre_buffering_time) : (player->ini.http_buffering_time);
__mm_player_streaming_set_queue2(player->streamer,
element,
NULL,
0);
}
- if (MMPLAYER_IS_MS_BUFF_SRC(player))
- {
- if (player->v_stream_caps)
- {
+ if (MMPLAYER_IS_MS_BUFF_SRC(player)) {
+ if (player->v_stream_caps) {
es_video_queue = gst_element_factory_make("queue2", "video_queue");
- if (!es_video_queue)
- {
+ if (!es_video_queue) {
LOGE("create es_video_queue for es player failed\n");
goto INIT_ERROR;
}
element_bucket = g_list_append(element_bucket, &mainbin[MMPLAYER_M_V_BUFFER]);
/* Adding audio appsrc to bucket */
- if (player->a_stream_caps && elem_src_audio)
- {
+ if (player->a_stream_caps && elem_src_audio) {
mainbin[MMPLAYER_M_2ND_SRC].id = MMPLAYER_M_2ND_SRC;
mainbin[MMPLAYER_M_2ND_SRC].gst = elem_src_audio;
element_bucket = g_list_append(element_bucket, &mainbin[MMPLAYER_M_2ND_SRC]);
es_audio_queue = gst_element_factory_make("queue2", "audio_queue");
- if (!es_audio_queue)
- {
+ if (!es_audio_queue) {
LOGE("create es_audio_queue for es player failed\n");
goto INIT_ERROR;
}
mainbin[MMPLAYER_M_A_BUFFER].gst = es_audio_queue;
element_bucket = g_list_append(element_bucket, &mainbin[MMPLAYER_M_A_BUFFER]);
}
- }
- /* Only audio stream, no video */
- else if (player->a_stream_caps)
- {
+ } else if (player->a_stream_caps) {
+ /* Only audio stream, no video */
es_audio_queue = gst_element_factory_make("queue2", "audio_queue");
- if (!es_audio_queue)
- {
+ if (!es_audio_queue) {
LOGE("create es_audio_queue for es player failed\n");
goto INIT_ERROR;
}
element_bucket = g_list_append(element_bucket, &mainbin[MMPLAYER_M_A_BUFFER]);
}
- if (player->s_stream_caps && elem_src_subtitle)
- {
+ if (player->s_stream_caps && elem_src_subtitle) {
mainbin[MMPLAYER_M_SUBSRC].id = MMPLAYER_M_SUBSRC;
mainbin[MMPLAYER_M_SUBSRC].gst = elem_src_subtitle;
element_bucket = g_list_append(element_bucket, &mainbin[MMPLAYER_M_SUBSRC]);
es_subtitle_queue = gst_element_factory_make("queue2", "subtitle_queue");
- if (!es_subtitle_queue)
- {
+ if (!es_subtitle_queue) {
LOGE("create es_subtitle_queue for es player failed\n");
goto INIT_ERROR;
}
/* create autoplugging element if src element is not a rtsp src */
if ((player->profile.uri_type != MM_PLAYER_URI_TYPE_URL_RTSP) &&
(player->profile.uri_type != MM_PLAYER_URI_TYPE_URL_WFD) &&
- (player->profile.uri_type != MM_PLAYER_URI_TYPE_MS_BUFF))
- {
+ (player->profile.uri_type != MM_PLAYER_URI_TYPE_MS_BUFF)) {
element = NULL;
enum MainElementID elemId = MMPLAYER_M_NUM;
if ((player->use_decodebin) &&
((MMPLAYER_IS_HTTP_PD(player)) ||
- (!MMPLAYER_IS_HTTP_STREAMING(player))))
- {
+ (!MMPLAYER_IS_HTTP_STREAMING(player)))) {
elemId = MMPLAYER_M_AUTOPLUG;
element = __mmplayer_create_decodebin(player);
need_state_holder = FALSE;
- }
- else
- {
+ } else {
elemId = MMPLAYER_M_TYPEFIND;
element = gst_element_factory_make("typefind", "typefinder");
MMPLAYER_SIGNAL_CONNECT(player, element, MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "have-type",
/* check autoplug element is OK */
- if (!element)
- {
+ if (!element) {
LOGE("can not create element(%d)\n", elemId);
goto INIT_ERROR;
}
}
/* add elements to pipeline */
- if (!__mmplayer_gst_element_add_bucket_to_bin(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), element_bucket))
- {
+ if (!__mmplayer_gst_element_add_bucket_to_bin(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), element_bucket)) {
LOGE("Failed to add elements to pipeline\n");
goto INIT_ERROR;
}
/* linking elements in the bucket by added order. */
- if (__mmplayer_gst_element_link_bucket(element_bucket) == -1)
- {
+ if (__mmplayer_gst_element_link_bucket(element_bucket) == -1) {
LOGE("Failed to link some elements\n");
goto INIT_ERROR;
}
/* create fakesink element for keeping the pipeline state PAUSED. if needed */
- if (need_state_holder)
- {
+ if (need_state_holder) {
/* create */
mainbin[MMPLAYER_M_SRC_FAKESINK].id = MMPLAYER_M_SRC_FAKESINK;
mainbin[MMPLAYER_M_SRC_FAKESINK].gst = gst_element_factory_make("fakesink", "state-holder");
- if (!mainbin[MMPLAYER_M_SRC_FAKESINK].gst)
- {
+ if (!mainbin[MMPLAYER_M_SRC_FAKESINK].gst) {
LOGE("fakesink element could not be created\n");
goto INIT_ERROR;
}
/* add */
if (FALSE == gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst),
- mainbin[MMPLAYER_M_SRC_FAKESINK].gst))
- {
+ mainbin[MMPLAYER_M_SRC_FAKESINK].gst)) {
LOGE("failed to add fakesink to bin\n");
goto INIT_ERROR;
}
/* now we have completed mainbin. take it */
player->pipeline->mainbin = mainbin;
- if (MMPLAYER_IS_MS_BUFF_SRC(player))
- {
+ if (MMPLAYER_IS_MS_BUFF_SRC(player)) {
GstPad *srcpad = NULL;
- if (mainbin[MMPLAYER_M_V_BUFFER].gst)
- {
+ if (mainbin[MMPLAYER_M_V_BUFFER].gst) {
srcpad = gst_element_get_static_pad(mainbin[MMPLAYER_M_V_BUFFER].gst, "src");
- if (srcpad)
- {
+ if (srcpad) {
__mmplayer_gst_create_decoder(player,
MM_PLAYER_TRACK_TYPE_VIDEO,
srcpad,
}
}
- if ((player->a_stream_caps) && (mainbin[MMPLAYER_M_A_BUFFER].gst))
- {
+ if ((player->a_stream_caps) && (mainbin[MMPLAYER_M_A_BUFFER].gst)) {
srcpad = gst_element_get_static_pad(mainbin[MMPLAYER_M_A_BUFFER].gst, "src");
- if (srcpad)
- {
+ if (srcpad) {
__mmplayer_gst_create_decoder(player,
MM_PLAYER_TRACK_TYPE_AUDIO,
srcpad,
} // else error
if (mainbin[MMPLAYER_M_S_BUFFER].gst)
- {
__mmplayer_try_to_plug_decodebin(player, gst_element_get_static_pad(mainbin[MMPLAYER_M_S_BUFFER].gst, "src"), player->s_stream_caps);
- }
}
/* connect bus callback */
bus = gst_pipeline_get_bus(GST_PIPELINE(mainbin[MMPLAYER_M_PIPE].gst));
- if (!bus)
- {
+ if (!bus) {
LOGE("cannot get bus from pipeline.\n");
goto INIT_ERROR;
}
player->context.thread_default = g_main_context_get_thread_default();
- if (NULL == player->context.thread_default)
- {
+ if (NULL == player->context.thread_default) {
player->context.thread_default = g_main_context_default();
LOGD("thread-default context is the global default context");
}
LOGW("bus watcher thread context = %p, watcher : %d", player->context.thread_default, player->bus_watcher);
/* Note : check whether subtitle atrribute uri is set. If uri is set, then try to play subtitle file */
- if (__mmplayer_check_subtitle(player))
- {
+ if (__mmplayer_check_subtitle(player)) {
if (MM_ERROR_NONE != __mmplayer_gst_create_subtitle_src(player))
LOGE("fail to create subtitle src\n");
}
__mmplayer_gst_destroy_pipeline(player);
g_list_free(element_bucket);
- if (mainbin)
- {
+ if (mainbin) {
/* release element which are not added to bin */
- for (i = 1; i < MMPLAYER_M_NUM; i++) /* NOTE : skip pipeline */
- {
- if (mainbin[i].gst)
- {
+ for (i = 1; i < MMPLAYER_M_NUM; i++) {
+ /* NOTE : skip pipeline */
+ if (mainbin[i].gst) {
GstObject* parent = NULL;
parent = gst_element_get_parent(mainbin[i].gst);
- if (!parent)
- {
+ if (!parent) {
gst_object_unref(GST_OBJECT(mainbin[i].gst));
mainbin[i].gst = NULL;
- }
- else
- {
+ } else
gst_object_unref(GST_OBJECT(parent));
- }
}
}
/* release pipeline with it's childs */
if (mainbin[MMPLAYER_M_PIPE].gst)
- {
gst_object_unref(GST_OBJECT(mainbin[MMPLAYER_M_PIPE].gst));
- }
MMPLAYER_FREEIF(mainbin);
}
player->video_hub_download_mode = 0;
__mmplayer_reset_gapless_state(player);
- if (player->streamer)
- {
+ if (player->streamer) {
__mm_player_streaming_deinitialize(player->streamer);
__mm_player_streaming_destroy(player->streamer);
player->streamer = NULL;
__mmplayer_cancel_eos_timer(player);
/* cleanup gst stuffs */
- if (player->pipeline)
- {
+ if (player->pipeline) {
MMPlayerGstElement* mainbin = player->pipeline->mainbin;
GstTagList* tag_list = player->pipeline->tag_list;
__mmplayer_remove_g_source_from_context(player->context.thread_default, player->bus_watcher);
player->bus_watcher = 0;
- if (mainbin)
- {
+ if (mainbin) {
MMPlayerGstElement* audiobin = player->pipeline->audiobin;
MMPlayerGstElement* videobin = player->pipeline->videobin;
MMPlayerGstElement* textbin = player->pipeline->textbin;
timeout = MMPLAYER_STATE_CHANGE_TIMEOUT(player);
ret = __mmplayer_gst_set_state(player, mainbin[MMPLAYER_M_PIPE].gst, GST_STATE_NULL, FALSE, timeout);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("fail to change state to NULL\n");
return MM_ERROR_PLAYER_INTERNAL;
}
}
MMPLAYER_FREEIF(player->album_art);
- if (player->v_stream_caps)
- {
+ if (player->v_stream_caps) {
gst_caps_unref(player->v_stream_caps);
player->v_stream_caps = NULL;
}
- if (player->a_stream_caps)
- {
+ if (player->a_stream_caps) {
gst_caps_unref(player->a_stream_caps);
player->a_stream_caps = NULL;
}
- if (player->s_stream_caps)
- {
+ if (player->s_stream_caps) {
gst_caps_unref(player->s_stream_caps);
player->s_stream_caps = NULL;
}
MMPLAYER_PENDING_STATE(player) = MM_PLAYER_STATE_READY;
ret = __mmplayer_gst_create_pipeline(player);
- if (ret)
- {
+ if (ret) {
LOGE("failed to create pipeline\n");
return ret;
}
ret = __mmplayer_gst_set_state(player,
player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_STATE_READY, FALSE, timeout);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
/* return error if failed to set state */
LOGE("failed to set READY state");
return ret;
- }
- else
- {
+ } else
MMPLAYER_SET_STATE(player, MM_PLAYER_STATE_READY);
- }
/* create dot before error-return. for debugging */
MMPLAYER_GENERATE_DOT_IF_ENABLED(player, "pipeline-status-realize");
/* destroy pipeline */
ret = __mmplayer_gst_destroy_pipeline(player);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to destory pipeline\n");
return ret;
}
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
- if (!player->pending_seek.is_pending)
- {
+ if (!player->pending_seek.is_pending) {
LOGD("pending seek is not reserved. nothing to do.\n");
return ret;
}
/* check player state if player could pending seek or not. */
current_state = MMPLAYER_CURRENT_STATE(player);
- if (current_state != MM_PLAYER_STATE_PAUSED && current_state != MM_PLAYER_STATE_PLAYING )
- {
+ if (current_state != MM_PLAYER_STATE_PAUSED && current_state != MM_PLAYER_STATE_PLAYING) {
LOGW("try to pending seek in %s state, try next time. \n",
MMPLAYER_STATE_GET_NAME(current_state));
return ret;
/* NOTE : if SetPosition was called before Start. do it now */
/* streaming doesn't support it. so it should be always sync */
/* !!create one more api to check if there is pending seek rather than checking variables */
- if ((player->pending_seek.is_pending || sound_extraction) && !MMPLAYER_IS_STREAMING(player))
- {
+ if ((player->pending_seek.is_pending || sound_extraction) && !MMPLAYER_IS_STREAMING(player)) {
MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_PAUSED;
ret = __gst_pause(player, FALSE);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to set state to PAUSED for pending seek\n");
return ret;
}
MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_PLAYING;
- if (sound_extraction)
- {
+ if (sound_extraction) {
LOGD("setting pcm extraction\n");
ret = __mmplayer_set_pcm_extraction(player);
- if (MM_ERROR_NONE != ret)
- {
+ if (MM_ERROR_NONE != ret) {
LOGW("failed to set pcm extraction\n");
return ret;
}
- }
- else
- {
+ } else {
if (MM_ERROR_NONE != __gst_pending_seek(player))
- {
LOGW("failed to seek pending postion. starting from the begin of content.\n");
- }
}
}
/* set pipeline state to PLAYING */
if (player->es_player_push_mode)
- {
async = TRUE;
- }
/* set pipeline state to PLAYING */
ret = __mmplayer_gst_set_state(player,
player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_STATE_PLAYING, async, MMPLAYER_STATE_CHANGE_TIMEOUT(player));
- if (ret == MM_ERROR_NONE)
- {
+ if (ret == MM_ERROR_NONE) {
MMPLAYER_SET_STATE(player, MM_PLAYER_STATE_PLAYING);
- }
- else
- {
+ } else {
LOGE("failed to set state to PLAYING");
return ret;
}
MMPLAYER_PRINT_STATE(player);
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("cannot get content attribute\n");
return MM_ERROR_PLAYER_INTERNAL;
}
timeout = MMPLAYER_STATE_CHANGE_TIMEOUT(player);
if (player->profile.uri_type == MM_PLAYER_URI_TYPE_BUFF ||
- player->profile.uri_type == MM_PLAYER_URI_TYPE_HLS)
- {
+ player->profile.uri_type == MM_PLAYER_URI_TYPE_HLS) {
state = GST_STATE_READY;
- }
- else
- {
+ } else {
state = GST_STATE_PAUSED;
if (!MMPLAYER_IS_STREAMING(player) ||
- (player->streaming_type == STREAMING_SERVICE_VOD && player->videodec_linked)) {
+ (player->streaming_type == STREAMING_SERVICE_VOD && player->videodec_linked))
rewind = TRUE;
- }
}
if (player->es_player_push_mode)
- {
async = TRUE;
- }
/* set gst state */
ret = __mmplayer_gst_set_state(player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, state, async, timeout);
__mmplayer_undo_sound_fadedown(player);
/* return if set_state has failed */
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to set state.\n");
return ret;
}
/* rewind */
- if (rewind)
- {
+ if (rewind) {
if (!__gst_seek(player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, player->playback_rate,
GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, GST_SEEK_TYPE_SET, 0,
- GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE))
- {
+ GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE)) {
LOGW("failed to rewind\n");
ret = MM_ERROR_PLAYER_SEEK;
}
player->sent_bos = FALSE;
if (player->es_player_push_mode) //for cloudgame
- {
timeout = 0;
- }
/* wait for seek to complete */
change_ret = gst_element_get_state(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, NULL, NULL, timeout * GST_SECOND);
- if (change_ret == GST_STATE_CHANGE_SUCCESS || change_ret == GST_STATE_CHANGE_NO_PREROLL)
- {
+ if (change_ret == GST_STATE_CHANGE_SUCCESS || change_ret == GST_STATE_CHANGE_NO_PREROLL) {
MMPLAYER_SET_STATE(player, MM_PLAYER_STATE_READY);
- }
- else
- {
+ } else {
LOGE("fail to stop player.\n");
ret = MM_ERROR_PLAYER_INTERNAL;
__mmplayer_dump_pipeline_state(player);
player->ignore_asyncdone = FALSE;
- if (FALSE == async)
- {
- if (ret != MM_ERROR_NONE)
- {
+ if (FALSE == async) {
+ if (ret != MM_ERROR_NONE) {
GstMessage *msg = NULL;
GTimer *timer = NULL;
gdouble MAX_TIMEOUT_SEC = 3;
GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst));
gboolean got_msg = FALSE;
/* check if gst error posted or not */
- do
- {
- msg = gst_bus_timed_pop(bus, GST_SECOND /2);
- if (msg)
- {
- if (GST_MESSAGE_TYPE(msg) == GST_MESSAGE_ERROR)
- {
+ do {
+ msg = gst_bus_timed_pop(bus, GST_SECOND / 2);
+ if (msg) {
+ if (GST_MESSAGE_TYPE(msg) == GST_MESSAGE_ERROR) {
GError *error = NULL;
/* parse error code */
gst_message_parse_error(msg, &error, NULL);
- if (gst_structure_has_name(gst_message_get_structure(msg), "streaming_error"))
- {
+ if (gst_structure_has_name(gst_message_get_structure(msg), "streaming_error")) {
/* Note : the streaming error from the streaming source is handled
* using __mmplayer_handle_streaming_error.
*/
__mmplayer_handle_streaming_error(player, msg);
- }
- else if (error)
- {
+ } else if (error) {
LOGE("paring error posted from bus, domain : %s, code : %d", g_quark_to_string(error->domain), error->code);
if (error->domain == GST_STREAM_ERROR)
- {
ret = __gst_handle_stream_error(player, error, msg);
- }
else if (error->domain == GST_RESOURCE_ERROR)
- {
ret = __gst_handle_resource_error(player, error->code);
- }
else if (error->domain == GST_LIBRARY_ERROR)
- {
ret = __gst_handle_library_error(player, error->code);
- }
else if (error->domain == GST_CORE_ERROR)
- {
ret = __gst_handle_core_error(player, error->code);
- }
}
got_msg = TRUE;
g_timer_destroy(timer);
return ret;
- }
- else if (!player->video_stream_cb && (!player->pipeline->videobin) && (!player->pipeline->audiobin))
- {
+ } else if (!player->video_stream_cb && (!player->pipeline->videobin) && (!player->pipeline->audiobin)) {
if (MMPLAYER_IS_RTSP_STREAMING(player))
return ret;
return MM_ERROR_PLAYER_CODEC_NOT_FOUND;
- }
- else if (ret== MM_ERROR_NONE)
- {
+ } else if (ret == MM_ERROR_NONE)
MMPLAYER_SET_STATE(player, MM_PLAYER_STATE_PAUSED);
- }
}
/* generate dot file before returning error */
ret = __mmplayer_gst_set_state(player,
player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_STATE_PLAYING, async, timeout);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to set state to PLAYING\n");
return ret;
- }
- else
- {
- if (async == FALSE)
- {
+ } else {
+ if (async == FALSE) {
// MMPLAYER_SET_STATE(player, MM_PLAYER_STATE_PLAYING);
LOGD("update state machine to %d\n", MM_PLAYER_STATE_PLAYING);
ret = __mmplayer_set_state(player, MM_PLAYER_STATE_PLAYING);
&& MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_PAUSED)
goto PENDING;
- if (!MMPLAYER_IS_MS_BUFF_SRC(player))
- {
+ if (!MMPLAYER_IS_MS_BUFF_SRC(player)) {
/* check duration */
/* NOTE : duration cannot be zero except live streaming.
- * Since some element could have some timing problemn with quering duration, try again.
+ * Since some element could have some timing problemn with quering duration, try again.
*/
- if (!player->duration)
- {
+ if (!player->duration) {
if (!gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &dur_nsec))
- {
goto SEEK_ERROR;
- }
player->duration = dur_nsec;
}
- if (player->duration)
- {
+ if (player->duration) {
dur_msec = GST_TIME_AS_MSECONDS(player->duration);
- }
- else
- {
+ } else {
LOGE("could not get the duration. fail to seek.\n");
goto SEEK_ERROR;
}
mm_attrs_get_int_by_name(player->attrs, "accurate_seek", &accurated);
if (accurated)
- {
seek_flags |= GST_SEEK_FLAG_ACCURATE;
- }
else
- {
seek_flags |= GST_SEEK_FLAG_KEY_UNIT;
- }
/* do seek */
- switch (format)
+ switch (format) {
+ case MM_PLAYER_POS_FORMAT_TIME:
{
- case MM_PLAYER_POS_FORMAT_TIME:
- {
- if (!MMPLAYER_IS_MS_BUFF_SRC(player))
- {
- /* check position is valid or not */
- if (position > dur_msec)
- goto INVALID_ARGS;
+ if (!MMPLAYER_IS_MS_BUFF_SRC(player)) {
+ /* check position is valid or not */
+ if (position > dur_msec)
+ goto INVALID_ARGS;
- LOGD("seeking to(%lu) msec, duration is %d msec\n", position, dur_msec);
+ LOGD("seeking to(%lu) msec, duration is %d msec\n", position, dur_msec);
- if (player->doing_seek)
- {
- LOGD("not completed seek");
- return MM_ERROR_PLAYER_DOING_SEEK;
- }
+ if (player->doing_seek) {
+ LOGD("not completed seek");
+ return MM_ERROR_PLAYER_DOING_SEEK;
}
+ }
- if (!internal_called)
- player->doing_seek = TRUE;
+ if (!internal_called)
+ player->doing_seek = TRUE;
- pos_nsec = position * G_GINT64_CONSTANT(1000000);
+ pos_nsec = position * G_GINT64_CONSTANT(1000000);
- if ((MMPLAYER_IS_HTTP_STREAMING(player)) && (!player->videodec_linked))
- {
- gint64 cur_time = 0;
-
- /* get current position */
- gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &cur_time);
-
- /* flush */
- GstEvent *event = gst_event_new_seek(1.0,
- GST_FORMAT_TIME,
- (GstSeekFlags)GST_SEEK_FLAG_FLUSH,
- GST_SEEK_TYPE_SET, cur_time,
- GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
- if (event) {
- __gst_send_event_to_sink(player, event);
- }
+ if ((MMPLAYER_IS_HTTP_STREAMING(player)) && (!player->videodec_linked)) {
+ gint64 cur_time = 0;
- __gst_pause(player, FALSE);
- }
+ /* get current position */
+ gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &cur_time);
- ret = __gst_seek(player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, player->playback_rate,
- GST_FORMAT_TIME, seek_flags,
- GST_SEEK_TYPE_SET, pos_nsec, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
- if (!ret )
- {
- LOGE("failed to set position. dur[%lu] pos[%lu] pos_msec[%llu]\n", dur_msec, position, pos_nsec);
- goto SEEK_ERROR;
- }
- }
- break;
+ /* flush */
+ GstEvent *event = gst_event_new_seek(1.0,
+ GST_FORMAT_TIME,
+ (GstSeekFlags)GST_SEEK_FLAG_FLUSH,
+ GST_SEEK_TYPE_SET, cur_time,
+ GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
+ if (event)
+ __gst_send_event_to_sink(player, event);
- case MM_PLAYER_POS_FORMAT_PERCENT:
- {
- LOGD("seeking to(%lu)%% \n", position);
+ __gst_pause(player, FALSE);
+ }
- if (player->doing_seek)
- {
- LOGD("not completed seek");
- return MM_ERROR_PLAYER_DOING_SEEK;
- }
+ ret = __gst_seek(player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, player->playback_rate,
+ GST_FORMAT_TIME, seek_flags,
+ GST_SEEK_TYPE_SET, pos_nsec, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
+ if (!ret) {
+ LOGE("failed to set position. dur[%lu] pos[%lu] pos_msec[%llu]\n", dur_msec, position, pos_nsec);
+ goto SEEK_ERROR;
+ }
+ }
+ break;
- if (!internal_called)
- player->doing_seek = TRUE;
+ case MM_PLAYER_POS_FORMAT_PERCENT:
+ {
+ LOGD("seeking to(%lu)%% \n", position);
- /* FIXIT : why don't we use 'GST_FORMAT_PERCENT' */
- pos_nsec = (gint64)((position * player->duration) / 100);
- ret = __gst_seek(player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, player->playback_rate,
- GST_FORMAT_TIME, seek_flags,
- GST_SEEK_TYPE_SET, pos_nsec, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
- if (!ret )
- {
- LOGE("failed to set position. dur[%lud] pos[%lud] pos_msec[%"G_GUINT64_FORMAT"]\n", dur_msec, position, pos_nsec);
- goto SEEK_ERROR;
- }
+ if (player->doing_seek) {
+ LOGD("not completed seek");
+ return MM_ERROR_PLAYER_DOING_SEEK;
}
- break;
- default:
- goto INVALID_ARGS;
+ if (!internal_called)
+ player->doing_seek = TRUE;
+ /* FIXIT : why don't we use 'GST_FORMAT_PERCENT' */
+ pos_nsec = (gint64)((position * player->duration) / 100);
+ ret = __gst_seek(player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, player->playback_rate,
+ GST_FORMAT_TIME, seek_flags,
+ GST_SEEK_TYPE_SET, pos_nsec, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
+ if (!ret) {
+ LOGE("failed to set position. dur[%lud] pos[%lud] pos_msec[%"G_GUINT64_FORMAT"]\n", dur_msec, position, pos_nsec);
+ goto SEEK_ERROR;
+ }
+ }
+ break;
+
+ default:
+ goto INVALID_ARGS;
}
/* NOTE : store last seeking point to overcome some bad operation
* please refer to below comments in details
*/
if (current_state != MM_PLAYER_STATE_PAUSED)
- {
ret = gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &pos_msec);
- }
/* NOTE : get last point to overcome some bad operation of some elements
*(returning zero when getting current position in paused state
* and when failed to get postion during seeking
*/
if ((current_state == MM_PLAYER_STATE_PAUSED)
- || (!ret))
+ || (!ret)) {
//|| (player->last_position != 0 && pos_msec == 0))
- {
LOGD("pos_msec = %"GST_TIME_FORMAT" and ret = %d and state = %d", GST_TIME_ARGS(pos_msec), ret, current_state);
if (player->playback_rate < 0.0)
LOGD("returning last point : %"GST_TIME_FORMAT, GST_TIME_ARGS(pos_msec));
- }
- else
- {
- if (player->duration > 0 && pos_msec > player->duration) {
+ } else {
+ if (player->duration > 0 && pos_msec > player->duration)
pos_msec = player->duration;
- }
if (player->sound_focus.keep_last_pos) {
LOGD("return last pos as stop by asm, %"GST_TIME_FORMAT, GST_TIME_ARGS(player->last_position));
pos_msec = player->last_position;
- }
- else {
+ } else
player->last_position = pos_msec;
- }
}
switch (format) {
- case MM_PLAYER_POS_FORMAT_TIME:
- *position = GST_TIME_AS_MSECONDS(pos_msec);
- break;
+ case MM_PLAYER_POS_FORMAT_TIME:
+ *position = GST_TIME_AS_MSECONDS(pos_msec);
+ break;
- case MM_PLAYER_POS_FORMAT_PERCENT:
- {
- gint64 dur = 0;
- gint64 pos = 0;
+ case MM_PLAYER_POS_FORMAT_PERCENT:
+ {
+ gint64 dur = 0;
+ gint64 pos = 0;
- dur = player->duration / GST_SECOND;
- if (dur <= 0)
- {
- LOGD("duration is [%d], so returning position 0\n",dur);
- *position = 0;
- }
- else
- {
- pos = pos_msec / GST_SECOND;
- *position = pos * 100 / dur;
- }
- break;
+ dur = player->duration / GST_SECOND;
+ if (dur <= 0) {
+ LOGD("duration is [%d], so returning position 0\n", dur);
+ *position = 0;
+ } else {
+ pos = pos_msec / GST_SECOND;
+ *position = pos * 100 / dur;
}
- default:
- return MM_ERROR_PLAYER_INTERNAL;
+ break;
+ }
+ default:
+ return MM_ERROR_PLAYER_INTERNAL;
}
return MM_ERROR_NONE;
}
-static int __gst_get_buffer_position(mm_player_t* player, int format, unsigned long* start_pos, unsigned long* stop_pos)
+static int __gst_get_buffer_position(mm_player_t* player, int format, unsigned long* start_pos, unsigned long* stop_pos)
{
#define STREAMING_IS_FINISHED 0
#define BUFFERING_MAX_PER 100
#define DEFAULT_PER_VALUE -1
-#define CHECK_PERCENT_VALUE(a,min,max)(((a)>(min))?(((a)<(max))?(a):(max)):(min))
+#define CHECK_PERCENT_VALUE(a, min, max)(((a) > (min)) ? (((a) < (max)) ? (a) : (max)) : (min))
MMPlayerGstElement *mainbin = NULL;
gint start_per = DEFAULT_PER_VALUE, stop_per = DEFAULT_PER_VALUE;
*start_pos = 0;
*stop_pos = 0;
- if (!MMPLAYER_IS_HTTP_STREAMING(player))
- {
+ if (!MMPLAYER_IS_HTTP_STREAMING(player)) {
/* and rtsp is not ready yet. */
LOGW("it's only used for http streaming case.\n");
return MM_ERROR_PLAYER_NO_OP;
}
- if (format != MM_PLAYER_POS_FORMAT_PERCENT)
- {
+ if (format != MM_PLAYER_POS_FORMAT_PERCENT) {
LOGW("Time format is not supported yet.\n");
return MM_ERROR_INVALID_ARGUMENT;
}
- if (content_size_time <= 0 || content_size_bytes <= 0)
- {
+ if (content_size_time <= 0 || content_size_bytes <= 0) {
LOGW("there is no content size.");
return MM_ERROR_NONE;
}
- if (__gst_get_position(player, MM_PLAYER_POS_FORMAT_TIME, &position) != MM_ERROR_NONE)
- {
+ if (__gst_get_position(player, MM_PLAYER_POS_FORMAT_TIME, &position) != MM_ERROR_NONE) {
LOGW("fail to get current position.");
return MM_ERROR_NONE;
}
mainbin = player->pipeline->mainbin;
start_per = ceil(100 *(position*GST_MSECOND) / content_size_time);
- if (mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst)
- {
+ if (mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst) {
GstQuery *query = NULL;
gint byte_in_rate = 0, byte_out_rate = 0;
gint64 estimated_total = 0;
query = gst_query_new_buffering(GST_FORMAT_BYTES);
- if (!query || !gst_element_query(mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst, query))
- {
+ if (!query || !gst_element_query(mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst, query)) {
LOGW("fail to get buffering query from queue2");
if (query)
gst_query_unref(query);
gst_query_parse_buffering_stats(query, &mode, &byte_in_rate, &byte_out_rate, NULL);
LOGD("mode %d, in_rate %d, out_rate %d", mode, byte_in_rate, byte_out_rate);
- if (mode == GST_BUFFERING_STREAM) /* using only queue in case of push mode(ts / mp3) */
- {
+ if (mode == GST_BUFFERING_STREAM) {
+ /* using only queue in case of push mode(ts / mp3) */
if (gst_element_query_position(mainbin[MMPLAYER_M_SRC].gst,
- GST_FORMAT_BYTES, &buffered_total))
- {
+ GST_FORMAT_BYTES, &buffered_total)) {
LOGD("buffered_total %"G_GINT64_FORMAT, buffered_total);
stop_per = 100 * buffered_total / content_size_bytes;
}
- }
- else /* GST_BUFFERING_TIMESHIFT or GST_BUFFERING_DOWNLOAD */
- {
+ } else {
+ /* GST_BUFFERING_TIMESHIFT or GST_BUFFERING_DOWNLOAD */
guint idx = 0;
guint num_of_ranges = 0;
gint64 start_byte = 0, stop_byte = 0;
gst_query_parse_buffering_range(query, NULL, NULL, NULL, &estimated_total);
- if (estimated_total != STREAMING_IS_FINISHED)
- {
+ if (estimated_total != STREAMING_IS_FINISHED) {
/* buffered size info from queue2 */
num_of_ranges = gst_query_get_n_buffering_ranges(query);
- for (idx=0 ; idx<num_of_ranges ; idx++)
- {
+ for (idx = 0; idx < num_of_ranges; idx++) {
gst_query_parse_nth_buffering_range(query, idx, &start_byte, &stop_byte);
LOGD("range %d, %"G_GINT64_FORMAT" ~ %"G_GUINT64_FORMAT, idx, start_byte, stop_byte);
buffered_total += (stop_byte - start_byte);
}
- }
- else
- {
+ } else
stop_per = BUFFERING_MAX_PER;
- }
}
gst_query_unref(query);
}
- if (stop_per == DEFAULT_PER_VALUE)
- {
+ if (stop_per == DEFAULT_PER_VALUE) {
guint dur_sec = (guint)(content_size_time/GST_SECOND);
- if (dur_sec > 0)
- {
+ if (dur_sec > 0) {
guint avg_byterate = (guint)(content_size_bytes/dur_sec);
/* buffered size info from multiqueue */
- if (mainbin[MMPLAYER_M_DEMUXED_S_BUFFER].gst)
- {
+ if (mainbin[MMPLAYER_M_DEMUXED_S_BUFFER].gst) {
guint curr_size_bytes = 0;
g_object_get(G_OBJECT(mainbin[MMPLAYER_M_DEMUXED_S_BUFFER].gst),
"curr-size-bytes", &curr_size_bytes, NULL);
{
MMPLAYER_FENTER();
- if (!player)
- {
+ if (!player) {
LOGW("set_message_callback is called with invalid player handle\n");
return MM_ERROR_PLAYER_NOT_INITIALIZED;
}
memset(data, 0, sizeof(MMPlayerParseProfile));
- if ((path = strstr(uri, "es_buff://")))
- {
- if (strlen(path))
- {
+ if ((path = strstr(uri, "es_buff://"))) {
+ if (strlen(path)) {
strncpy(data->uri, uri, MM_MAX_URL_LEN-1);
data->uri_type = MM_PLAYER_URI_TYPE_MS_BUFF;
ret = MM_ERROR_NONE;
}
- }
- else if ((path = strstr(uri, "buff://")))
- {
+ } else if ((path = strstr(uri, "buff://"))) {
data->uri_type = MM_PLAYER_URI_TYPE_BUFF;
ret = MM_ERROR_NONE;
- }
- else if ((path = strstr(uri, "rtsp://")))
- {
+ } else if ((path = strstr(uri, "rtsp://"))) {
if (strlen(path)) {
if ((path = strstr(uri, "/wfd1.0/"))) {
strncpy(data->uri, uri, MM_MAX_URL_LEN-1);
data->uri_type = MM_PLAYER_URI_TYPE_URL_WFD;
ret = MM_ERROR_NONE;
LOGD("uri is actually a wfd client path. giving it to wfdrtspsrc\n");
- }
- else {
+ } else {
strncpy(data->uri, uri, MM_MAX_URL_LEN-1);
data->uri_type = MM_PLAYER_URI_TYPE_URL_RTSP;
ret = MM_ERROR_NONE;
}
}
- }
- else if ((path = strstr(uri, "http://")))
- {
+ } else if ((path = strstr(uri, "http://"))) {
if (strlen(path)) {
strncpy(data->uri, uri, MM_MAX_URL_LEN-1);
if (g_str_has_suffix(g_ascii_strdown(uri, strlen(uri)), ".ism/manifest") ||
g_str_has_suffix(g_ascii_strdown(uri, strlen(uri)), ".isml/manifest"))
- {
data->uri_type = MM_PLAYER_URI_TYPE_SS;
- }
else
- data->uri_type = MM_PLAYER_URI_TYPE_URL_HTTP;
+ data->uri_type = MM_PLAYER_URI_TYPE_URL_HTTP;
ret = MM_ERROR_NONE;
}
- }
- else if ((path = strstr(uri, "https://")))
- {
+ } else if ((path = strstr(uri, "https://"))) {
if (strlen(path)) {
strncpy(data->uri, uri, MM_MAX_URL_LEN-1);
if (g_str_has_suffix(g_ascii_strdown(uri, strlen(uri)), ".ism/manifest") ||
g_str_has_suffix(g_ascii_strdown(uri, strlen(uri)), ".isml/manifest"))
- {
data->uri_type = MM_PLAYER_URI_TYPE_SS;
- }
data->uri_type = MM_PLAYER_URI_TYPE_URL_HTTP;
ret = MM_ERROR_NONE;
}
- }
- else if ((path = strstr(uri, "rtspu://")))
- {
+ } else if ((path = strstr(uri, "rtspu://"))) {
if (strlen(path)) {
strncpy(data->uri, uri, MM_MAX_URL_LEN-1);
data->uri_type = MM_PLAYER_URI_TYPE_URL_RTSP;
ret = MM_ERROR_NONE;
}
- }
- else if ((path = strstr(uri, "rtspr://")))
- {
+ } else if ((path = strstr(uri, "rtspr://"))) {
strncpy(data->uri, path, MM_MAX_URL_LEN-1);
- char *separater =strstr(path, "*");
+ char *separater = strstr(path, "*");
if (separater) {
int urgent_len = 0;
ret = MM_ERROR_NONE;
}
}
- }
- else if ((path = strstr(uri, "mms://")))
- {
+ } else if ((path = strstr(uri, "mms://"))) {
if (strlen(path)) {
strncpy(data->uri, uri, MM_MAX_URL_LEN-1);
data->uri_type = MM_PLAYER_URI_TYPE_URL_MMS;
ret = MM_ERROR_NONE;
}
- }
- else if ((path = strstr(uri, "mem://")))
- {
+ } else if ((path = strstr(uri, "mem://"))) {
if (strlen(path)) {
int mem_size = 0;
char *buffer = NULL;
}
}
- LOGD("ext: %s, mem_size: %d, mmap(param): %p\n", ext, mem_size, param);
- if (mem_size && param)
- {
+ LOGD("ext: %s, mem_size: %d, mmap(param): %p\n", ext, mem_size, param);
+ if (mem_size && param) {
data->mem = param;
data->mem_size = mem_size;
data->uri_type = MM_PLAYER_URI_TYPE_MEM;
ret = MM_ERROR_NONE;
}
}
- }
- else
- {
+ } else {
gchar *location = NULL;
GError *err = NULL;
LOGD("path from uri: %s", location);
}
- path = (location != NULL)?(location):((char*)uri);
+ path = (location != NULL) ? (location) : ((char*)uri);
int file_stat = MM_ERROR_NONE;
file_stat = util_exist_file_path(path);
/* if no protocol prefix exist. check file existence and then give file:// as it's prefix */
- if (file_stat == MM_ERROR_NONE)
- {
+ if (file_stat == MM_ERROR_NONE) {
g_snprintf(data->uri, MM_MAX_URL_LEN, "file://%s", path);
- if (util_is_sdp_file(path))
- {
+ if (util_is_sdp_file(path)) {
LOGD("uri is actually a file but it's sdp file. giving it to rtspsrc\n");
data->uri_type = MM_PLAYER_URI_TYPE_URL_RTSP;
- }
- else
- {
+ } else
data->uri_type = MM_PLAYER_URI_TYPE_FILE;
- }
ret = MM_ERROR_NONE;
- }
- else if (file_stat == MM_ERROR_PLAYER_PERMISSION_DENIED)
- {
+ } else if (file_stat == MM_ERROR_PLAYER_PERMISSION_DENIED) {
data->uri_type = MM_PLAYER_URI_TYPE_NO_PERMISSION;
- }
- else
- {
+ } else {
LOGE("invalid uri, could not play..\n");
data->uri_type = MM_PLAYER_URI_TYPE_NONE;
}
}
exit:
- if (data->uri_type == MM_PLAYER_URI_TYPE_NONE) {
+ if (data->uri_type == MM_PLAYER_URI_TYPE_NONE)
ret = MM_ERROR_PLAYER_FILE_NOT_FOUND;
- } else if (data->uri_type == MM_PLAYER_URI_TYPE_NO_PERMISSION){
+ else if (data->uri_type == MM_PLAYER_URI_TYPE_NO_PERMISSION)
ret = MM_ERROR_PLAYER_PERMISSION_DENIED;
- }
/* dump parse result */
SECURE_LOGW("incomming uri : %s\n", uri);
LOGW("get notified");
if ((player->cmd == MMPLAYER_COMMAND_DESTROY) ||
- (player->cmd == MMPLAYER_COMMAND_UNREALIZE))
- {
+ (player->cmd == MMPLAYER_COMMAND_UNREALIZE)) {
LOGW("dispatched");
return FALSE;
}
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- if (MMPLAYER_CURRENT_STATE(player) == MM_PLAYER_STATE_PLAYING)
- {
+ if (MMPLAYER_CURRENT_STATE(player) == MM_PLAYER_STATE_PLAYING) {
LOGD("Ready to proceed lazy pause\n");
ret = _mmplayer_pause((MMHandleType)player);
if (MM_ERROR_NONE != ret)
- {
LOGE("MMPlayer pause failed in ASM callback lazy pause\n");
- }
- }
- else
- {
+ } else
LOGD("Invalid state to proceed lazy pause\n");
- }
/* unset mute */
if (player->pipeline && player->pipeline->audiobin)
gboolean
__mmplayer_can_do_interrupt(mm_player_t *player)
{
- if (!player || !player->pipeline || !player->attrs)
- {
+ if (!player || !player->pipeline || !player->attrs) {
LOGW("not initialized");
goto FAILED;
}
- if ((player->sound_focus.exit_cb) || (player->set_mode.pcm_extraction))
- {
+ if ((player->sound_focus.exit_cb) || (player->set_mode.pcm_extraction)) {
LOGW("leave from asm cb right now, %d, %d", player->sound_focus.exit_cb, player->set_mode.pcm_extraction);
goto FAILED;
}
/* check if seeking */
- if (player->doing_seek)
- {
+ if (player->doing_seek) {
MMMessageParamType msg_param;
memset(&msg_param, 0, sizeof(MMMessageParamType));
msg_param.code = MM_ERROR_PLAYER_SEEK;
}
/* check other thread */
- if (!g_mutex_trylock(&player->cmd_lock))
- {
+ if (!g_mutex_trylock(&player->cmd_lock)) {
LOGW("locked already, cmd state : %d", player->cmd);
/* check application command */
- if (player->cmd == MMPLAYER_COMMAND_START || player->cmd == MMPLAYER_COMMAND_RESUME)
- {
+ if (player->cmd == MMPLAYER_COMMAND_START || player->cmd == MMPLAYER_COMMAND_RESUME) {
LOGW("playing.. should wait cmd lock then, will be interrupted");
/* lock will be released at mrp_resource_release_cb() */
}
LOGW("nothing to do");
goto FAILED;
- }
- else
- {
+ } else {
LOGW("can interrupt immediately");
goto INTERRUPT;
}
focus_msg = MM_PLAYER_FOCUS_CHANGED_BY_EMERGENCY;
} else if (strstr(reason_for_change, "call-voice") ||
- strstr(reason_for_change, "call-video") ||
- strstr(reason_for_change, "voip") ||
- strstr(reason_for_change, "ringtone-voip") ||
- strstr(reason_for_change, "ringtone-call")) {
+ strstr(reason_for_change, "call-video") ||
+ strstr(reason_for_change, "voip") ||
+ strstr(reason_for_change, "ringtone-voip") ||
+ strstr(reason_for_change, "ringtone-call")) {
focus_msg = MM_PLAYER_FOCUS_CHANGED_BY_CALL;
} else if (strstr(reason_for_change, "media") ||
}
if (acquire && (focus_msg != MM_PLAYER_FOCUS_CHANGED_BY_MEDIA))
- {
/* can acqurie */
focus_msg = MM_PLAYER_FOCUS_CHANGED_COMPLETED;
- }
LOGD("converted from reason(%s) to msg(%d)", reason_for_change, focus_msg);
*msg = focus_msg;
LOGW("focus watch notified");
- if (!__mmplayer_can_do_interrupt(player))
- {
+ if (!__mmplayer_can_do_interrupt(player)) {
LOGW("no need to interrupt, so leave");
goto EXIT_WITHOUT_UNLOCK;
}
- if (player->sound_focus.session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE)
- {
+ if (player->sound_focus.session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
LOGW("flags is UNINTERRUPTIBLE. do nothing.");
goto EXIT;
}
LOGW("watch: state: %d, focus_type : %d, reason_for_change : %s",
- focus_state, focus_type, (reason_for_change?reason_for_change:"N/A"));
+ focus_state, focus_type, (reason_for_change ? reason_for_change : "N/A"));
player->sound_focus.cb_pending = TRUE;
player->sound_focus.by_asm_cb = TRUE;
- if (focus_state == FOCUS_IS_ACQUIRED)
- {
+ if (focus_state == FOCUS_IS_ACQUIRED) {
LOGW("watch: FOCUS_IS_ACQUIRED");
if (MM_ERROR_NONE == __mmplayer_convert_sound_focus_state(FALSE, reason_for_change, &msg))
- {
player->sound_focus.focus_changed_msg = (int)msg;
- }
if (strstr(reason_for_change, "call") ||
strstr(reason_for_change, "voip") || /* FIXME: to check */
strstr(reason_for_change, "alarm") ||
- strstr(reason_for_change, "media"))
- {
- if (!MMPLAYER_IS_RTSP_STREAMING(player))
- {
+ strstr(reason_for_change, "media")) {
+ if (!MMPLAYER_IS_RTSP_STREAMING(player)) {
// hold 0.7 second to excute "fadedown mute" effect
LOGW("do fade down->pause->undo fade down");
__mmplayer_do_sound_fadedown(player, MM_PLAYER_FADEOUT_TIME_DEFAULT);
result = _mmplayer_pause((MMHandleType)player);
- if (result != MM_ERROR_NONE)
- {
+ if (result != MM_ERROR_NONE) {
LOGW("fail to set Pause state by asm");
goto EXIT;
}
__mmplayer_undo_sound_fadedown(player);
- }
- else
- {
+ } else
/* rtsp should connect again in specific network becasue tcp session can't be kept any more */
_mmplayer_unrealize((MMHandleType)player);
- }
- }
- else
- {
+ } else {
LOGW("pause immediately");
result = _mmplayer_pause((MMHandleType)player);
- if (result != MM_ERROR_NONE)
- {
+ if (result != MM_ERROR_NONE) {
LOGW("fail to set Pause state by asm");
goto EXIT;
}
}
- }
- else if (focus_state == FOCUS_IS_RELEASED)
- {
+ } else if (focus_state == FOCUS_IS_RELEASED) {
LOGW("FOCUS_IS_RELEASED: Got msg from asm to resume");
player->sound_focus.antishock = TRUE;
player->sound_focus.by_asm_cb = FALSE;
if (MM_ERROR_NONE == __mmplayer_convert_sound_focus_state(TRUE, reason_for_change, &msg))
- {
player->sound_focus.focus_changed_msg = (int)msg;
- }
//ASM server is single thread daemon. So use g_idle_add() to post resume msg
player->resume_event_id = g_idle_add((GSourceFunc)_asm_postmsg, (gpointer)player);
goto DONE;
- }
- else
- {
+ } else
LOGW("unknown focus state %d", focus_state);
- }
DONE:
player->sound_focus.by_asm_cb = FALSE;
LOGW("get focus notified");
- if (!__mmplayer_can_do_interrupt(player))
- {
+ if (!__mmplayer_can_do_interrupt(player)) {
LOGW("no need to interrupt, so leave");
goto EXIT_WITHOUT_UNLOCK;
}
- if (player->sound_focus.session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE)
- {
+ if (player->sound_focus.session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
LOGW("flags is UNINTERRUPTIBLE. do nothing.");
goto EXIT;
}
LOGW("state: %d, focus_type : %d, reason_for_change : %s",
- focus_state, focus_type, (reason_for_change?reason_for_change:"N/A"));
+ focus_state, focus_type, (reason_for_change ? reason_for_change : "N/A"));
player->sound_focus.cb_pending = TRUE;
player->sound_focus.by_asm_cb = TRUE;
// player->sound_focus.event_src = event_src;
- if (focus_state == FOCUS_IS_RELEASED)
- {
+ if (focus_state == FOCUS_IS_RELEASED) {
LOGW("FOCUS_IS_RELEASED");
if (MM_ERROR_NONE == __mmplayer_convert_sound_focus_state(FALSE, reason_for_change, &msg))
- {
player->sound_focus.focus_changed_msg = (int)msg;
- }
if (strstr(reason_for_change, "call") ||
strstr(reason_for_change, "voip") || /* FIXME: to check */
strstr(reason_for_change, "alarm") ||
- strstr(reason_for_change, "media"))
- {
- if (!MMPLAYER_IS_RTSP_STREAMING(player))
- {
+ strstr(reason_for_change, "media")) {
+ if (!MMPLAYER_IS_RTSP_STREAMING(player)) {
//hold 0.7 second to excute "fadedown mute" effect
LOGW("do fade down->pause->undo fade down");
__mmplayer_do_sound_fadedown(player, MM_PLAYER_FADEOUT_TIME_DEFAULT);
result = _mmplayer_pause((MMHandleType)player);
- if (result != MM_ERROR_NONE)
- {
+ if (result != MM_ERROR_NONE) {
LOGW("fail to set Pause state by asm");
goto EXIT;
}
__mmplayer_undo_sound_fadedown(player);
- }
- else
- {
+ } else
/* rtsp should connect again in specific network becasue tcp session can't be kept any more */
_mmplayer_unrealize((MMHandleType)player);
- }
- }
- else
- {
+ } else {
LOGW("pause immediately");
result = _mmplayer_pause((MMHandleType)player);
- if (result != MM_ERROR_NONE)
- {
+ if (result != MM_ERROR_NONE) {
LOGW("fail to set Pause state by asm");
goto EXIT;
}
}
- }
- else if (focus_state == FOCUS_IS_ACQUIRED)
- {
+ } else if (focus_state == FOCUS_IS_ACQUIRED) {
LOGW("FOCUS_IS_ACQUIRED: Got msg from asm to resume");
player->sound_focus.antishock = TRUE;
player->sound_focus.by_asm_cb = FALSE;
if (MM_ERROR_NONE == __mmplayer_convert_sound_focus_state(TRUE, reason_for_change, &msg))
- {
player->sound_focus.focus_changed_msg = (int)msg;
- }
//ASM server is single thread daemon. So use g_idle_add() to post resume msg
player->resume_event_id = g_idle_add((GSourceFunc)_asm_postmsg, (gpointer)player);
goto DONE;
- }
- else
- {
+ } else
LOGW("unknown focus state %d", focus_state);
- }
DONE:
if (!lazy_pause)
- {
player->sound_focus.by_asm_cb = FALSE;
- }
player->sound_focus.cb_pending = FALSE;
EXIT:
/* construct attributes */
player->attrs = _mmplayer_construct_attribute(handle);
- if (!player->attrs)
- {
+ if (!player->attrs) {
LOGE("Failed to construct attributes\n");
return ret;
}
/* initialize gstreamer with configured parameter */
- if (!__mmplayer_init_gstreamer(player))
- {
+ if (!__mmplayer_init_gstreamer(player)) {
LOGE("Initializing gstreamer failed\n");
_mmplayer_deconstruct_attribute(handle);
return ret;
/* create repeat thread */
player->repeat_thread =
g_thread_try_new("repeat_thread", __mmplayer_repeat_thread, (gpointer)player, NULL);
- if (!player->repeat_thread)
- {
+ if (!player->repeat_thread) {
LOGE("failed to create repeat_thread(%s)");
g_mutex_clear(&player->repeat_thread_mutex);
g_cond_clear(&player->repeat_thread_cond);
/* create next play thread */
player->next_play_thread =
g_thread_try_new("next_play_thread", __mmplayer_next_play_thread, (gpointer)player, NULL);
- if (!player->next_play_thread)
- {
+ if (!player->next_play_thread) {
LOGE("failed to create next play thread");
ret = MM_ERROR_PLAYER_RESOURCE_LIMIT;
g_mutex_clear(&player->next_play_thread_mutex);
}
ret = _mmplayer_initialize_video_capture(player);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to initialize video capture\n");
goto ERROR;
}
/* initialize resource manager */
- if (MM_ERROR_NONE != _mmplayer_resource_manager_init(&player->resource_manager, player))
- {
+ if (MM_ERROR_NONE != _mmplayer_resource_manager_init(&player->resource_manager, player)) {
LOGE("failed to initialize resource manager\n");
goto ERROR;
}
- if (MMPLAYER_IS_HTTP_PD(player))
- {
+ if (MMPLAYER_IS_HTTP_PD(player)) {
player->pd_downloader = NULL;
player->pd_file_save_path = NULL;
}
player->video_num_buffers = DEFAULT_NUM_OF_V_OUT_BUFFER;
player->video_extra_num_buffers = DEFAULT_NUM_OF_V_OUT_BUFFER;
if (player->ini.dump_element_keyword[0][0] == '\0')
- {
- player->ini.set_dump_element_flag= FALSE;
- }
+ player->ini.set_dump_element_flag = FALSE;
else
- {
player->ini.set_dump_element_flag = TRUE;
- }
/* set player state to null */
MMPLAYER_STATE_CHANGE_TIMEOUT(player) = player->ini.localplayback_state_change_timeout;
g_mutex_clear(&player->fsink_lock);
/* free thread */
- if (player->repeat_thread)
- {
+ if (player->repeat_thread) {
player->repeat_thread_exit = TRUE;
g_cond_signal(&player->repeat_thread_cond);
}
/* free next play thread */
- if (player->next_play_thread)
- {
+ if (player->next_play_thread) {
player->next_play_thread_exit = TRUE;
g_cond_signal(&player->next_play_thread_cond);
{
static gboolean initialized = FALSE;
static const int max_argc = 50;
- gint* argc = NULL;
+ gint* argc = NULL;
gchar** argv = NULL;
gchar** argv2 = NULL;
GError *err = NULL;
int i = 0;
int arg_count = 0;
- if (initialized)
- {
+ if (initialized) {
LOGD("gstreamer already initialized.\n");
return TRUE;
}
argv[0] = g_strdup("mmplayer");
/* add gst_param */
- for (i = 0; i < 5; i++) /* FIXIT : num of param is now fixed to 5. make it dynamic */
- {
- if (strlen(player->ini.gst_param[i]) > 0)
- {
+ for (i = 0; i < 5; i++) {
+ /* FIXIT : num of param is now fixed to 5. make it dynamic */
+ if (strlen(player->ini.gst_param[i]) > 0) {
argv[*argc] = g_strdup(player->ini.gst_param[i]);
(*argc)++;
}
(*argc)++;
/* check disable registry scan */
- if (player->ini.skip_rescan)
- {
+ if (player->ini.skip_rescan) {
argv[*argc] = g_strdup("--gst-disable-registry-update");
(*argc)++;
}
/* check disable segtrap */
- if (player->ini.disable_segtrap)
- {
+ if (player->ini.disable_segtrap) {
argv[*argc] = g_strdup("--gst-disable-segtrap");
(*argc)++;
}
LOGD("argc : %d\n", *argc);
arg_count = *argc;
- for (i = 0; i < arg_count; i++)
- {
+ for (i = 0; i < arg_count; i++) {
argv2[i] = argv[i];
LOGD("argv[%d] : %s\n", i, argv2[i]);
}
/* initializing gstreamer */
- if (!gst_init_check(argc, &argv, &err))
- {
+ if (!gst_init_check(argc, &argv, &err)) {
LOGE("Could not initialize GStreamer: %s\n", err ? err->message : "unknown error occurred");
if (err)
- {
g_error_free(err);
- }
goto ERROR;
}
/* release */
- for (i = 0; i < arg_count; i++)
- {
+ for (i = 0; i < arg_count; i++) {
//LOGD("release - argv[%d] : %s\n", i, argv2[i]);
MMPLAYER_FREEIF(argv2[i]);
}
ERROR:
/* release */
- for (i = 0; i < arg_count; i++)
- {
+ for (i = 0; i < arg_count; i++) {
LOGD("free[%d] : %s\n", i, argv2[i]);
MMPLAYER_FREEIF(argv2[i]);
}
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- if (player->pd_downloader)
- {
+ if (player->pd_downloader) {
_mmplayer_unrealize_pd_downloader((MMHandleType)player);
MMPLAYER_FREEIF(player->pd_downloader);
}
- if (MMPLAYER_IS_HTTP_PD(player))
- {
+ if (MMPLAYER_IS_HTTP_PD(player)) {
_mmplayer_destroy_pd_downloader((MMHandleType)player);
MMPLAYER_FREEIF(player->pd_file_save_path);
}
__mmplayer_destroy_streaming_ext(player);
/* release repeat thread */
- if (player->repeat_thread)
- {
+ if (player->repeat_thread) {
player->repeat_thread_exit = TRUE;
g_cond_signal(&player->repeat_thread_cond);
}
/* release next play thread */
- if (player->next_play_thread)
- {
+ if (player->next_play_thread) {
player->next_play_thread_exit = TRUE;
g_cond_signal(&player->next_play_thread_cond);
_mmplayer_release_video_capture(player);
/* flush any pending asm_cb */
- if (player->sound_focus.cb_pending)
- {
+ if (player->sound_focus.cb_pending) {
/* set a flag for make sure asm_cb to be returned immediately */
LOGW("asm cb has pending state");
player->sound_focus.exit_cb = TRUE;
/* withdraw asm */
if (MM_ERROR_NONE != _mmplayer_sound_unregister(&player->sound_focus))
- {
LOGE("failed to deregister asm server\n");
- }
/* de-initialize resource manager */
if (MM_ERROR_NONE != _mmplayer_resource_manager_deinit(&player->resource_manager))
- {
LOGE("failed to deinitialize resource manager\n");
- }
#ifdef USE_LAZY_PAUSE
- if (player->lazy_pause_event_id)
- {
+ if (player->lazy_pause_event_id) {
__mmplayer_remove_g_source_from_context(player->context.global_default, player->lazy_pause_event_id);
player->lazy_pause_event_id = 0;
}
#endif
- if (player->resume_event_id)
- {
+ if (player->resume_event_id) {
g_source_remove(player->resume_event_id);
player->resume_event_id = 0;
}
- if (player->resumable_cancel_id)
- {
+ if (player->resumable_cancel_id) {
g_source_remove(player->resumable_cancel_id);
player->resumable_cancel_id = 0;
}
/* release pipeline */
- if (MM_ERROR_NONE != __mmplayer_gst_destroy_pipeline(player))
- {
+ if (MM_ERROR_NONE != __mmplayer_gst_destroy_pipeline(player)) {
LOGE("failed to destory pipeline\n");
return MM_ERROR_PLAYER_INTERNAL;
}
- if (player->is_external_subtitle_present && player->subtitle_language_list)
- {
+ if (player->is_external_subtitle_present && player->subtitle_language_list) {
g_list_free(player->subtitle_language_list);
player->subtitle_language_list = NULL;
}
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- if (MMPLAYER_IS_HTTP_PD(player))
- {
+ if (MMPLAYER_IS_HTTP_PD(player)) {
gboolean bret = FALSE;
player->pd_downloader = _mmplayer_create_pd_downloader();
- if (!player->pd_downloader)
- {
+ if (!player->pd_downloader) {
LOGE("Unable to create PD Downloader...");
ret = MM_ERROR_PLAYER_NO_FREE_SPACE;
}
bret = _mmplayer_realize_pd_downloader((MMHandleType)player, player->profile.uri, player->pd_file_save_path, player->pipeline->mainbin[MMPLAYER_M_SRC].gst);
- if (FALSE == bret)
- {
+ if (FALSE == bret) {
LOGE("Unable to create PD Downloader...");
ret = MM_ERROR_PLAYER_NOT_INITIALIZED;
}
int ret = MM_ERROR_NONE;
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("fail to get attributes.\n");
return MM_ERROR_PLAYER_INTERNAL;
}
if (MM_ERROR_NONE != _mmplayer_sound_register(&player->sound_focus,
(mm_sound_focus_changed_cb)__mmplayer_sound_focus_callback,
(mm_sound_focus_changed_watch_cb)__mmplayer_sound_focus_watch_callback,
- (void*)player))
-
- {
+ (void*)player)) {
/* NOTE : we are dealing it as an error since we cannot expect it's behavior */
LOGE("failed to register asm server\n");
return MM_ERROR_POLICY_INTERNAL;
_mmplayer_realize(MMHandleType hplayer) // @
{
mm_player_t* player = (mm_player_t*)hplayer;
- char *uri =NULL;
+ char *uri = NULL;
void *param = NULL;
gboolean update_registry = FALSE;
MMHandleType attrs = 0;
MMPLAYER_CHECK_STATE(player, MMPLAYER_COMMAND_REALIZE);
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("fail to get attributes.\n");
return MM_ERROR_PLAYER_INTERNAL;
}
mm_attrs_get_string_by_name(attrs, "profile_uri", &uri);
mm_attrs_get_data_by_name(attrs, "profile_user_param", ¶m);
- if (player->profile.uri_type == MM_PLAYER_URI_TYPE_NONE)
- {
+ if (player->profile.uri_type == MM_PLAYER_URI_TYPE_NONE) {
ret = __mmfplayer_parse_profile((const char*)uri, param, &player->profile);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to parse profile\n");
return ret;
}
}
/* FIXIT : we can use thouse in player->profile directly */
- if (player->profile.uri_type == MM_PLAYER_URI_TYPE_MEM)
- {
+ if (player->profile.uri_type == MM_PLAYER_URI_TYPE_MEM) {
player->mem_buf.buf = (char *)player->profile.mem;
player->mem_buf.len = player->profile.mem_size;
player->mem_buf.offset = 0;
}
- if (uri && (strstr(uri, "es_buff://")))
- {
+ if (uri && (strstr(uri, "es_buff://"))) {
if (strstr(uri, "es_buff://push_mode"))
- {
player->es_player_push_mode = TRUE;
- }
else
- {
player->es_player_push_mode = FALSE;
- }
}
- if (player->profile.uri_type == MM_PLAYER_URI_TYPE_URL_MMS)
- {
+ if (player->profile.uri_type == MM_PLAYER_URI_TYPE_URL_MMS) {
LOGW("mms protocol is not supported format.\n");
return MM_ERROR_PLAYER_NOT_SUPPORTED_FORMAT;
}
/* registry should be updated for downloadable codec */
mm_attrs_get_int_by_name(attrs, "profile_update_registry", &update_registry);
- if (update_registry)
- {
+ if (update_registry) {
LOGD("updating registry...\n");
gst_update_registry();
/* realize pipeline */
ret = __gst_realize(player);
if (ret != MM_ERROR_NONE)
- {
LOGE("fail to realize the player.\n");
- }
else
- {
ret = __mmplayer_realize_streaming_ext(player);
- }
MMPLAYER_FLEAVE();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* destroy can called at anytime */
- if (player->pd_downloader && MMPLAYER_IS_HTTP_PD(player))
- {
+ if (player->pd_downloader && MMPLAYER_IS_HTTP_PD(player)) {
_mmplayer_unrealize_pd_downloader((MMHandleType)player);
MMPLAYER_FREEIF(player->pd_downloader);
}
ret = __gst_unrealize(player);
/* set asm stop if success */
- if (MM_ERROR_NONE == ret)
- {
+ if (MM_ERROR_NONE == ret) {
ret = _mmplayer_sound_release_focus(&player->sound_focus);
if (ret != MM_ERROR_NONE)
- {
LOGE("failed to release sound focus, ret(0x%x)\n", ret);
- }
- if (_mmplayer_resource_manager_get_state(&player->resource_manager, &resource_state) == MM_ERROR_NONE)
- {
- if (resource_state >= RESOURCE_STATE_ACQUIRED)
- {
+ if (_mmplayer_resource_manager_get_state(&player->resource_manager, &resource_state) == MM_ERROR_NONE) {
+ if (resource_state >= RESOURCE_STATE_ACQUIRED) {
ret = _mmplayer_resource_manager_release(&player->resource_manager);
if (ret != MM_ERROR_NONE)
- {
LOGE("failed to release resource, ret(0x%x)\n", ret);
- }
}
}
- if (_mmplayer_resource_manager_get_state(&player->resource_manager, &resource_state) == MM_ERROR_NONE)
- {
- if (resource_state == RESOURCE_STATE_PREPARED)
- {
+ if (_mmplayer_resource_manager_get_state(&player->resource_manager, &resource_state) == MM_ERROR_NONE) {
+ if (resource_state == RESOURCE_STATE_PREPARED) {
ret = _mmplayer_resource_manager_unprepare(&player->resource_manager);
if (ret != MM_ERROR_NONE)
- {
LOGE("failed to unprepare resource, ret(0x%x)\n", ret);
- }
}
}
- }
- else
- {
+ } else
LOGE("failed and don't change asm state to stop");
- }
MMPLAYER_FLEAVE();
volume.level[MM_VOLUME_CHANNEL_LEFT], volume.level[MM_VOLUME_CHANNEL_RIGHT]);
/* invalid factor range or not */
- for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++)
- {
+ for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++) {
if (volume.level[i] < MM_VOLUME_FACTOR_MIN || volume.level[i] > MM_VOLUME_FACTOR_MAX) {
LOGE("Invalid factor!(valid factor:0~1.0)\n");
return MM_ERROR_INVALID_ARGUMENT;
player->sound.volume = volume.level[MM_VOLUME_CHANNEL_LEFT];
/* check pipeline handle */
- if (!player->pipeline || !player->pipeline->audiobin)
- {
+ if (!player->pipeline || !player->pipeline->audiobin) {
LOGD("audiobin is not created yet\n");
LOGD("but, current stored volume will be set when it's created.\n");
/* setting volume to volume element */
vol_element = player->pipeline->audiobin[MMPLAYER_A_VOL].gst;
- if (vol_element)
- {
+ if (vol_element) {
LOGD("volume is set [%f]\n", player->sound.volume);
g_object_set(vol_element, "volume", player->sound.volume, NULL);
}
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* mute value shoud 0 or 1 */
- if (mute != 0 && mute != 1)
- {
+ if (mute != 0 && mute != 1) {
LOGE("bad mute value\n");
/* FIXIT : definitly, we need _BAD_PARAM error code */
player->sound.mute = mute;
/* just hold mute value if pipeline is not ready */
- if (!player->pipeline || !player->pipeline->audiobin)
- {
+ if (!player->pipeline || !player->pipeline->audiobin) {
LOGD("pipeline is not ready. holding mute value\n");
return MM_ERROR_NONE;
}
vol_element = player->pipeline->audiobin[MMPLAYER_A_SINK].gst;
/* NOTE : volume will only created when the bt is enabled */
- if (vol_element)
- {
+ if (vol_element) {
LOGD("mute : %d\n", mute);
g_object_set(vol_element, "mute", mute, NULL);
- }
- else
- {
+ } else
LOGD("volume elemnet is not created. using volume in audiosink\n");
- }
MMPLAYER_FLEAVE();
MMPLAYER_RETURN_VAL_IF_FAIL(pmute, MM_ERROR_INVALID_ARGUMENT);
/* just hold mute value if pipeline is not ready */
- if (!player->pipeline || !player->pipeline->audiobin)
- {
+ if (!player->pipeline || !player->pipeline->audiobin) {
LOGD("pipeline is not ready. returning stored value\n");
*pmute = player->sound.mute;
return MM_ERROR_NONE;
if (callback && !player->bufmgr)
player->bufmgr = tbm_bufmgr_init(-1);
- player->set_mode.media_packet_video_stream = (callback)?TRUE:FALSE;
+ player->set_mode.media_packet_video_stream = (callback) ? TRUE : FALSE;
player->video_stream_cb = callback;
player->video_stream_cb_user_param = user_param;
LOGD("pre buffer size : %d sec\n", second);
- if (second <= 0)
- {
+ if (second <= 0) {
LOGE("bad size value\n");
return MM_ERROR_INVALID_ARGUMENT;
}
- if (player->streamer == NULL)
- {
+ if (player->streamer == NULL) {
player->streamer = __mm_player_streaming_create();
__mm_player_streaming_initialize(player->streamer);
}
((mode == MM_PLAYER_BUFFERING_MODE_FIXED) && (second <= 0)))
return MM_ERROR_INVALID_ARGUMENT;
- if (player->streamer == NULL)
- {
+ if (player->streamer == NULL) {
player->streamer = __mm_player_streaming_create();
__mm_player_streaming_initialize(player->streamer);
}
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- if (MMPLAYER_IS_HTTP_PD(player))
- {
- if (!player->pd_downloader)
- {
+ if (MMPLAYER_IS_HTTP_PD(player)) {
+ if (!player->pd_downloader) {
ret = __mmplayer_realize_streaming_ext(player);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to realize streaming ext\n");
return ret;
}
}
- if (player->pd_downloader && player->pd_mode == MM_PLAYER_PD_MODE_URI)
- {
+ if (player->pd_downloader && player->pd_mode == MM_PLAYER_PD_MODE_URI) {
ret = _mmplayer_start_pd_downloader((MMHandleType)player);
- if (!ret)
- {
+ if (!ret) {
LOGE("ERROR while starting PD...\n");
return MM_ERROR_PLAYER_NOT_INITIALIZED;
}
MMPLAYER_CHECK_STATE(player, MMPLAYER_COMMAND_START);
ret = _mmplayer_sound_acquire_focus(&player->sound_focus);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to acquire sound focus.\n");
return ret;
}
/* NOTE : we should check and create pipeline again if not created as we destroy
* whole pipeline when stopping in streamming playback
*/
- if (!player->pipeline)
- {
+ if (!player->pipeline) {
ret = __gst_realize(player);
- if (MM_ERROR_NONE != ret)
- {
+ if (MM_ERROR_NONE != ret) {
LOGE("failed to realize before starting. only in streamming\n");
/* unlock */
return ret;
ret = __mmplayer_start_streaming_ext(player);
if (ret != MM_ERROR_NONE)
- {
LOGE("failed to start streaming ext \n");
- }
/* start pipeline */
ret = __gst_start(player);
if (ret != MM_ERROR_NONE)
- {
LOGE("failed to start player.\n");
- }
MMPLAYER_FLEAVE();
LOGD("not_supported_codec = 0x%02x, can_support_codec = 0x%02x\n",
player->not_supported_codec, player->can_support_codec);
- if (player->not_found_demuxer)
- {
+ if (player->not_found_demuxer) {
msg_param.code = MM_ERROR_PLAYER_CODEC_NOT_FOUND;
msg_param.data = g_strdup_printf("%s", player->unlinked_demuxer_mime);
return MM_ERROR_NONE;
}
- if (player->not_supported_codec)
- {
- if (player->can_support_codec) // There is one codec to play
- {
+ if (player->not_supported_codec) {
+ if (player->can_support_codec) {
+ // There is one codec to play
post_msg_direct = TRUE;
- }
- else
- {
+ } else {
if (player->pipeline->audiobin) // Some content has only PCM data in container.
post_msg_direct = TRUE;
}
- if (post_msg_direct)
- {
+ if (post_msg_direct) {
MMMessageParamType msg_param;
memset(&msg_param, 0, sizeof(MMMessageParamType));
- if (player->not_supported_codec == MISSING_PLUGIN_AUDIO)
- {
+ if (player->not_supported_codec == MISSING_PLUGIN_AUDIO) {
LOGW("not found AUDIO codec, posting error code to application.\n");
msg_param.code = MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND;
msg_param.data = g_strdup_printf("%s", player->unlinked_audio_mime);
- }
- else if (player->not_supported_codec == MISSING_PLUGIN_VIDEO)
- {
+ } else if (player->not_supported_codec == MISSING_PLUGIN_VIDEO) {
LOGW("not found VIDEO codec, posting error code to application.\n");
msg_param.code = MM_ERROR_PLAYER_VIDEO_CODEC_NOT_FOUND;
MMPLAYER_FREEIF(msg_param.data);
return MM_ERROR_NONE;
- }
- else // no any supported codec case
- {
+ } else {
+ // no any supported codec case
LOGW("not found any codec, posting error code to application.\n");
- if (player->not_supported_codec == MISSING_PLUGIN_AUDIO)
- {
+ if (player->not_supported_codec == MISSING_PLUGIN_AUDIO) {
msg_param.code = MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND;
msg_param.data = g_strdup_printf("%s", player->unlinked_audio_mime);
- }
- else
- {
+ } else {
msg_param.code = MM_ERROR_PLAYER_CODEC_NOT_FOUND;
msg_param.data = g_strdup_printf("%s, %s", player->unlinked_video_mime, player->unlinked_audio_mime);
}
gint timeout = 0;
int ret = MM_ERROR_NONE;
- if (player->gapless.reconfigure)
- {
+ if (player->gapless.reconfigure) {
LOGW("pipeline is under construction.\n");
MMPLAYER_PLAYBACK_LOCK(player);
ret = gst_element_get_state(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, &element_state, &element_pending_state, timeout * GST_SECOND);
if (ret == GST_STATE_CHANGE_FAILURE)
- {
LOGE("failed to change pipeline state within %d sec\n", timeout);
- }
}
}
ret = __gst_stop(player);
if (ret != MM_ERROR_NONE)
- {
LOGE("failed to stop player.\n");
- }
MMPLAYER_FLEAVE();
/* check pipline building state */
__mmplayer_check_pipeline(player);
- switch (MMPLAYER_CURRENT_STATE(player))
- {
- case MM_PLAYER_STATE_READY:
+ switch (MMPLAYER_CURRENT_STATE(player)) {
+ case MM_PLAYER_STATE_READY:
{
/* check prepare async or not.
* In the case of streaming playback, it's recommned to avoid blocking wait.
}
break;
- case MM_PLAYER_STATE_PLAYING:
+ case MM_PLAYER_STATE_PLAYING:
{
/* NOTE : store current point to overcome some bad operation
*(returning zero when getting current position in paused state) of some
ret = __gst_pause(player, async);
if (ret != MM_ERROR_NONE)
- {
LOGE("failed to pause player. ret : 0x%x\n", ret);
- }
- if (MMPLAYER_PREV_STATE(player) == MM_PLAYER_STATE_READY && MMPLAYER_CURRENT_STATE(player) == MM_PLAYER_STATE_PAUSED)
- {
+ if (MMPLAYER_PREV_STATE(player) == MM_PLAYER_STATE_READY && MMPLAYER_CURRENT_STATE(player) == MM_PLAYER_STATE_PAUSED) {
if (MM_ERROR_NONE != _mmplayer_update_video_param(player, "display_rotation"))
- {
LOGE("failed to update display_rotation");
- }
}
MMPLAYER_FLEAVE();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
ret = _mmplayer_sound_acquire_focus(&player->sound_focus);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to acquire sound focus.\n");
return ret;
}
ret = __gst_resume(player, async);
if (ret != MM_ERROR_NONE)
- {
LOGE("failed to resume player.\n");
- }
MMPLAYER_FLEAVE();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("fail to get attributes.\n");
return MM_ERROR_PLAYER_INTERNAL;
}
GST_FORMAT_TIME,
(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE),
GST_SEEK_TYPE_SET, start_pos,
- GST_SEEK_TYPE_SET, end_pos)))
- {
+ GST_SEEK_TYPE_SET, end_pos))) {
LOGE("failed to activate section repeat\n");
return MM_ERROR_PLAYER_SEEK;
LOGD("pcm extraction required position is from [%d] to [%d](msec)\n", required_start, required_end);
- if (required_start == 0 && required_end == 0)
- {
+ if (required_start == 0 && required_end == 0) {
LOGD("extracting entire stream");
return MM_ERROR_NONE;
- }
- else if (required_start < 0 || required_start > required_end || required_end < 0)
- {
+ } else if (required_start < 0 || required_start > required_end || required_end < 0) {
LOGD("invalid range for pcm extraction");
return MM_ERROR_INVALID_ARGUMENT;
}
/* get duration */
ret = gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &dur_nsec);
- if (!ret)
- {
+ if (!ret) {
LOGE("failed to get duration");
return MM_ERROR_PLAYER_INTERNAL;
}
dur_msec = GST_TIME_AS_MSECONDS(dur_nsec);
- if (dur_msec < required_end) // FIXME
- {
+ if (dur_msec < required_end) {
+ // FIXME
LOGD("invalid end pos for pcm extraction");
return MM_ERROR_INVALID_ARGUMENT;
}
GST_FORMAT_TIME,
(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE),
GST_SEEK_TYPE_SET, start_nsec,
- GST_SEEK_TYPE_SET, end_nsec)))
- {
+ GST_SEEK_TYPE_SET, end_nsec))) {
LOGE("failed to seek for pcm extraction\n");
return MM_ERROR_PLAYER_SEEK;
GST_FORMAT_TIME,
(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE),
GST_SEEK_TYPE_SET, cur_pos,
- GST_SEEK_TYPE_SET, player->duration)))
- {
+ GST_SEEK_TYPE_SET, player->duration))) {
LOGE("failed to deactivate section repeat\n");
return MM_ERROR_PLAYER_SEEK;
MMPLAYER_RETURN_VAL_IF_FAIL(streaming || !MMPLAYER_IS_STREAMING(player), MM_ERROR_NOT_SUPPORT_API);
/* The sound of video is not supported under 0.0 and over 2.0. */
- if (rate >= TRICK_PLAY_MUTE_THRESHOLD_MAX || rate < TRICK_PLAY_MUTE_THRESHOLD_MIN)
- {
+ if (rate >= TRICK_PLAY_MUTE_THRESHOLD_MAX || rate < TRICK_PLAY_MUTE_THRESHOLD_MIN) {
if (player->can_support_codec & FOUND_PLUGIN_VIDEO)
mute = TRUE;
}
LOGD("pos_msec = %"GST_TIME_FORMAT" and ret = %d and state = %d", GST_TIME_ARGS(pos_msec), ret, current_state);
if ((current_state == MM_PLAYER_STATE_PAUSED)
- || (!ret))
- //|| (player->last_position != 0 && pos_msec == 0))
- {
+ || (!ret) /*|| (player->last_position != 0 && pos_msec == 0)*/) {
LOGW("returning last point : %lld\n", player->last_position);
pos_msec = player->last_position;
}
- if (rate >= 0)
- {
+ if (rate >= 0) {
start = pos_msec;
stop = GST_CLOCK_TIME_NONE;
- }
- else
- {
+ } else {
start = GST_CLOCK_TIME_NONE;
stop = pos_msec;
}
GST_FORMAT_TIME,
(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE),
GST_SEEK_TYPE_SET, start,
- GST_SEEK_TYPE_SET, stop)))
- {
- LOGE("failed to set speed playback\n");
+ GST_SEEK_TYPE_SET, stop))) {
+ LOGE("failed to set speed playback\n");
return MM_ERROR_PLAYER_SEEK;
}
(g_strrstr(str_caps, "audio/x-imelody")) ||
(g_strrstr(str_caps, "audio/mobile-xmf")) ||
(g_strrstr(str_caps, "audio/xmf")) ||
- (g_strrstr(str_caps, "audio/mxmf")))
- {
+ (g_strrstr(str_caps, "audio/mxmf"))) {
LOGD("midi\n");
-
return TRUE;
}
{
if (g_strrstr(str_caps, "application/x-id3") ||
(g_strrstr(str_caps, "audio/mpeg") && g_strrstr(str_caps, "mpegversion= (int)1")))
- {
return TRUE;
- }
return FALSE;
}
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player && player->type);
- if (__mmplayer_is_midi_type(player->type))
- {
+ if (__mmplayer_is_midi_type(player->type)) {
player->bypass_audio_effect = TRUE;
- }
- else if (g_strrstr(player->type, "application/x-hls"))
- {
+ } else if (g_strrstr(player->type, "application/x-hls")) {
/* If it can't know exact type when it parses uri because of redirection case,
* it will be fixed by typefinder or when doing autoplugging.
*/
player->profile.uri_type = MM_PLAYER_URI_TYPE_HLS;
- if (player->streamer)
- {
+ if (player->streamer) {
player->streamer->is_adaptive_streaming = TRUE;
player->streamer->buffering_req.mode = MM_PLAYER_BUFFERING_MODE_FIXED;
player->streamer->buffering_req.runtime_second = 5;
}
- }
- else if (g_strrstr(player->type, "application/dash+xml"))
- {
+ } else if (g_strrstr(player->type, "application/dash+xml")) {
player->profile.uri_type = MM_PLAYER_URI_TYPE_DASH;
}
}
static void
-__mmplayer_typefind_have_type( GstElement *tf, guint probability, // @
+__mmplayer_typefind_have_type(GstElement *tf, guint probability, // @
GstCaps *caps, gpointer data)
{
mm_player_t* player = (mm_player_t*)data;
if ((!MMPLAYER_IS_WFD_STREAMING(player)) &&
(!MMPLAYER_IS_RTSP_STREAMING(player)) &&
- (g_strrstr(player->type, "audio/x-raw-int")))
- {
+ (g_strrstr(player->type, "audio/x-raw-int"))) {
LOGE("not support media format\n");
- if (player->msg_posted == FALSE)
- {
+ if (player->msg_posted == FALSE) {
MMMessageParamType msg_param;
memset(&msg_param, 0, sizeof(MMMessageParamType));
__mmplayer_update_content_type_info(player);
pad = gst_element_get_static_pad(tf, "src");
- if (!pad)
- {
+ if (!pad) {
LOGE("fail to get typefind src pad.\n");
return;
}
- if (player->use_decodebin)
- {
- if (!__mmplayer_try_to_plug_decodebin(player, pad, caps))
- {
+ if (player->use_decodebin) {
+ if (!__mmplayer_try_to_plug_decodebin(player, pad, caps)) {
gboolean async = FALSE;
LOGE("failed to autoplug %s\n", player->type);
mm_attrs_get_int_by_name(player->attrs, "profile_prepare_async", &async);
if (async && player->msg_posted == FALSE)
- {
__mmplayer_handle_missed_plugin(player);
- }
goto DONE;
}
- }
- else
- {
+ } else {
/* try to plug */
- if (!__mmplayer_try_to_plug(player, pad, caps))
- {
+ if (!__mmplayer_try_to_plug(player, pad, caps)) {
gboolean async = FALSE;
LOGE("failed to autoplug %s\n", player->type);
mm_attrs_get_int_by_name(player->attrs, "profile_prepare_async", &async);
if (async && player->msg_posted == FALSE)
- {
__mmplayer_handle_missed_plugin(player);
- }
goto DONE;
}
/* finish autopluging if no dynamic pad waiting */
- if ((!player->have_dynamic_pad) && (!player->has_many_types))
- {
+ if ((!player->have_dynamic_pad) && (!player->has_many_types)) {
if (!MMPLAYER_IS_RTSP_STREAMING(player))
- {
__mmplayer_pipeline_complete(NULL, (gpointer)player);
- }
}
}
/* create decodebin */
decodebin = gst_element_factory_make("decodebin", NULL);
- if (!decodebin)
- {
+ if (!decodebin) {
LOGE("fail to create decodebin\n");
goto ERROR;
}
GstElement* decodebin = NULL;
GstElement* queue2 = NULL;
GstPad* sinkpad = NULL;
- GstPad* qsrcpad= NULL;
+ GstPad* qsrcpad = NULL;
gchar *caps_str = NULL;
gint64 dur_bytes = 0L;
mainbin = player->pipeline->mainbin;
if ((!MMPLAYER_IS_HTTP_PD(player)) &&
- (MMPLAYER_IS_HTTP_STREAMING(player)))
- {
+ (MMPLAYER_IS_HTTP_STREAMING(player))) {
LOGD("creating http streaming buffering queue(queue2)\n");
- if (mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst)
- {
+ if (mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst) {
LOGE("MMPLAYER_M_MUXED_S_BUFFER is not null\n");
- }
- else
- {
+ } else {
queue2 = gst_element_factory_make("queue2", "queue2");
- if (!queue2)
- {
+ if (!queue2) {
LOGE("failed to create buffering queue element\n");
goto ERROR;
}
- if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), queue2))
- {
+ if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), queue2)) {
LOGE("failed to add buffering queue\n");
goto ERROR;
}
sinkpad = gst_element_get_static_pad(queue2, "sink");
qsrcpad = gst_element_get_static_pad(queue2, "src");
- if (GST_PAD_LINK_OK != gst_pad_link(srcpad, sinkpad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(srcpad, sinkpad)) {
LOGE("failed to link buffering queue\n");
goto ERROR;
}
/* NOTE : we cannot get any duration info from ts container in case of streaming */
// if (!g_strrstr(GST_ELEMENT_NAME(sinkelement), "mpegtsdemux"))
- if (!g_strrstr(player->type, "video/mpegts"))
- {
- max_buffer_size_bytes = (type == MUXED_BUFFER_TYPE_FILE)?(player->ini.http_max_size_bytes):(5*1024*1024);
+ if (!g_strrstr(player->type, "video/mpegts")) {
+ max_buffer_size_bytes = (type == MUXED_BUFFER_TYPE_FILE) ? (player->ini.http_max_size_bytes) : (5*1024*1024);
LOGD("max_buffer_size_bytes = %d\n", max_buffer_size_bytes);
__mm_player_streaming_set_queue2(player->streamer,
(guint64)dur_bytes);
}
- if (GST_STATE_CHANGE_FAILURE == gst_element_sync_state_with_parent(queue2))
- {
+ if (GST_STATE_CHANGE_FAILURE == gst_element_sync_state_with_parent(queue2)) {
LOGE("failed to sync queue2 state with parent\n");
goto ERROR;
}
/* create decodebin */
decodebin = __mmplayer_create_decodebin(player);
- if (!decodebin)
- {
+ if (!decodebin) {
LOGE("can not create autoplug element\n");
goto ERROR;
}
- if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), decodebin))
- {
+ if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), decodebin)) {
LOGE("failed to add decodebin\n");
goto ERROR;
}
sinkpad = gst_element_get_static_pad(decodebin, "sink");
- if (GST_PAD_LINK_OK != gst_pad_link(srcpad, sinkpad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(srcpad, sinkpad)) {
LOGE("failed to link decodebin\n");
goto ERROR;
}
* in case of hls, it does not need to have big buffer *
* because it is kind of adaptive streaming. */
if (((!MMPLAYER_IS_HTTP_PD(player)) &&
- (MMPLAYER_IS_HTTP_STREAMING(player))) || MMPLAYER_IS_DASH_STREAMING(player))
- {
+ (MMPLAYER_IS_HTTP_STREAMING(player))) || MMPLAYER_IS_DASH_STREAMING(player)) {
guint max_size_bytes = MAX_DECODEBIN_BUFFER_BYTES;
guint64 max_size_time = MAX_DECODEBIN_BUFFER_TIME;
- init_buffering_time = (init_buffering_time != 0)?(init_buffering_time):(player->ini.http_buffering_time);
+ init_buffering_time = (init_buffering_time != 0) ? (init_buffering_time) : (player->ini.http_buffering_time);
if (MMPLAYER_IS_HTTP_LIVE_STREAMING(player)) {
max_size_bytes = MAX_DECODEBIN_ADAPTIVE_BUFFER_BYTES;
"max-size-buffers", 0, NULL); // disable or automatic
}
- if (GST_STATE_CHANGE_FAILURE == gst_element_sync_state_with_parent(decodebin))
- {
+ if (GST_STATE_CHANGE_FAILURE == gst_element_sync_state_with_parent(decodebin)) {
LOGE("failed to sync decodebin state with parent\n");
goto ERROR;
}
if (sinkpad)
gst_object_unref(GST_OBJECT(sinkpad));
- if (queue2)
- {
+ if (queue2) {
/* NOTE : Trying to dispose element queue0, but it is in READY instead of the NULL state.
* You need to explicitly set elements to the NULL state before
* dropping the final reference, to allow them to clean up.
queue2 = NULL;
}
- if (decodebin)
- {
+ if (decodebin) {
/* NOTE : Trying to dispose element queue0, but it is in READY instead of the NULL state.
* You need to explicitly set elements to the NULL state before
* dropping the final reference, to allow them to clean up.
mainbin = player->pipeline->mainbin;
- mime = gst_structure_get_name(gst_caps_get_structure(caps, 0));
+ mime = gst_structure_get_name(gst_caps_get_structure(caps, 0));
/* return if we got raw output */
if (g_str_has_prefix(mime, "video/x-raw") || g_str_has_prefix(mime, "audio/x-raw")
- || g_str_has_prefix(mime, "text/plain") ||g_str_has_prefix(mime, "text/x-pango-markup"))
- {
+ || g_str_has_prefix(mime, "text/plain") || g_str_has_prefix(mime, "text/x-pango-markup")) {
element = (GstElement*)gst_pad_get_parent(pad);
/* NOTE : When no decoder has added during autoplugging. like a simple wave playback.
/* add queue if needed */
if ((g_strrstr(klass, "Demux") || g_strrstr(klass, "Depayloader")
- || g_strrstr(klass, "Parse")) && !g_str_has_prefix(mime, "text"))
- {
+ || g_strrstr(klass, "Parse")) && !g_str_has_prefix(mime, "text")) {
LOGD("adding raw queue\n");
queue = gst_element_factory_make("queue", NULL);
- if (!queue)
- {
+ if (!queue) {
LOGW("failed to create queue\n");
goto ERROR;
}
/* warmup */
- if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(queue, GST_STATE_READY))
- {
+ if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(queue, GST_STATE_READY)) {
LOGW("failed to set state READY to queue\n");
goto ERROR;
}
/* add to pipeline */
- if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), queue))
- {
+ if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), queue)) {
LOGW("failed to add queue\n");
goto ERROR;
}
/* link queue */
queue_pad = gst_element_get_static_pad(queue, "sink");
- if (GST_PAD_LINK_OK != gst_pad_link(pad, queue_pad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(pad, queue_pad)) {
LOGW("failed to link queue\n");
goto ERROR;
}
queue_pad = NULL;
/* running */
- if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(queue, GST_STATE_PAUSED))
- {
+ if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(queue, GST_STATE_PAUSED)) {
LOGW("failed to set state PAUSED to queue\n");
goto ERROR;
}
/* replace given pad to queue:src */
pad = gst_element_get_static_pad(queue, "src");
- if (!pad)
- {
+ if (!pad) {
LOGW("failed to get pad from queue\n");
goto ERROR;
}
/* check if player can do start continually */
MMPLAYER_CHECK_CMD_IF_EXIT(player);
- if (__mmplayer_link_sink(player,pad))
+ if (__mmplayer_link_sink(player, pad))
__mmplayer_gst_decode_callback(element, pad, player);
gst_object_unref(GST_OBJECT(element));
}
item = player->factories;
- for (; item != NULL ; item = item->next)
- {
+ for (; item != NULL; item = item->next) {
GstElementFactory *factory = GST_ELEMENT_FACTORY(item->data);
const GList *pads;
gint idx = 0;
skip = FALSE;
/* filtering exclude keyword */
- for (idx = 0; player->ini.exclude_element_keyword[idx][0] != '\0'; idx++)
- {
+ for (idx = 0; player->ini.exclude_element_keyword[idx][0] != '\0'; idx++) {
if (g_strrstr(GST_OBJECT_NAME(factory),
- player->ini.exclude_element_keyword[idx]))
- {
+ player->ini.exclude_element_keyword[idx])) {
LOGW("skipping [%s] by exculde keyword [%s]\n",
GST_OBJECT_NAME(factory),
player->ini.exclude_element_keyword[idx]);
}
}
- if (MMPLAYER_IS_RTSP_STREAMING(player) && g_strrstr(GST_OBJECT_NAME(factory), "omx_mpeg4dec"))
- {
+ if (MMPLAYER_IS_RTSP_STREAMING(player) && g_strrstr(GST_OBJECT_NAME(factory), "omx_mpeg4dec")) {
// omx decoder can not support mpeg4video data partitioned
// rtsp streaming didn't know mpeg4video data partitioned format
// so, if rtsp playback, player will skip omx_mpeg4dec.
/* NOTE : msl don't need to use image plugins.
* So, those plugins should be skipped for error handling.
*/
- if (g_strrstr(klass, "Codec/Decoder/Image"))
- {
+ if (g_strrstr(klass, "Codec/Decoder/Image")) {
LOGD("skipping [%s] by not required\n", GST_OBJECT_NAME(factory));
continue;
}
/* check pad compatability */
for (pads = gst_element_factory_get_static_pad_templates(factory);
- pads != NULL; pads=pads->next)
- {
+ pads != NULL; pads = pads->next) {
GstStaticPadTemplate *temp1 = pads->data;
GstCaps* static_caps = NULL;
|| temp1->presence != GST_PAD_ALWAYS)
continue;
+ /* using existing caps */
if (GST_IS_CAPS(&temp1->static_caps.caps))
- {
- /* using existing caps */
static_caps = gst_caps_ref(temp1->static_caps.caps);
- }
+ /* create one */
else
- {
- /* create one */
static_caps = gst_caps_from_string(temp1->static_caps.string);
- }
res = gst_caps_intersect((GstCaps*)caps, static_caps);
gst_caps_unref(static_caps);
static_caps = NULL;
- if (res && !gst_caps_is_empty(res))
- {
+ if (res && !gst_caps_is_empty(res)) {
GstElement *new_element;
GList *elements = player->parsers;
char *name_template = g_strdup(temp1->name_template);
gst_caps_unref(res);
/* check ALP Codec can be used or not */
- if ((g_strrstr(klass, "Codec/Decoder/Audio")))
- {
+ if ((g_strrstr(klass, "Codec/Decoder/Audio"))) {
/* consider mp3 audio only */
- if (!MMPLAYER_IS_STREAMING(player) && __mmplayer_is_only_mp3_type(player->type))
- {
+ if (!MMPLAYER_IS_STREAMING(player) && __mmplayer_is_only_mp3_type(player->type)) {
/* try to use ALP decoder first instead of selected decoder */
GstElement *element = NULL;
GstElementFactory * element_facory;
mm_attrs_get_string_by_name(player->attrs, "profile_uri", &path);
if (stat(path, &sb) == 0)
- {
data_size = (guint64)sb.st_size;
- }
LOGD("file size : %u", data_size);
- if (data_size > MIN_THRESHOLD_SIZE)
- {
+ if (data_size > MIN_THRESHOLD_SIZE) {
LOGD("checking if ALP can be used or not");
element = gst_element_factory_make("omx_mp3dec", "omx mp3 decoder");
- if (element)
- {
+ if (element) {
/* check availability because multi-instance is not supported */
GstStateChangeReturn ret = gst_element_set_state(element, GST_STATE_READY);
- if (ret != GST_STATE_CHANGE_SUCCESS) // use just selected decoder
- {
+ if (ret != GST_STATE_CHANGE_SUCCESS) {
+ // use just selected decoder
gst_object_unref(element);
- }
- else if (ret == GST_STATE_CHANGE_SUCCESS) // replace facotry to use omx
- {
+ } else if (ret == GST_STATE_CHANGE_SUCCESS) {
+ // replace facotry to use omx
/* clean */
gst_element_set_state(element, GST_STATE_NULL);
gst_object_unref(element);
element_facory = gst_element_factory_find("omx_mp3dec");
/* replace, otherwise use selected thing instead */
- if (element_facory)
- {
+ if (element_facory) {
factory = element_facory;
name_to_plug = GST_OBJECT_NAME(factory);
}
}
}
}
- }
- else if ((g_strrstr(klass, "Codec/Decoder/Video")))
- {
- if (g_strrstr(GST_OBJECT_NAME(factory), "omx_"))
- {
+ } else if ((g_strrstr(klass, "Codec/Decoder/Video"))) {
+ if (g_strrstr(GST_OBJECT_NAME(factory), "omx_")) {
char *env = getenv("MM_PLAYER_HW_CODEC_DISABLE");
- if (env != NULL)
- {
- if (strncasecmp(env, "yes", 3) == 0)
- {
+ if (env != NULL) {
+ if (strncasecmp(env, "yes", 3) == 0) {
LOGD("skipping [%s] by disabled\n", name_to_plug);
MMPLAYER_FREEIF(name_template);
continue;
LOGD("found %s to plug\n", name_to_plug);
new_element = gst_element_factory_create(GST_ELEMENT_FACTORY(factory), NULL);
- if (!new_element)
- {
+ if (!new_element) {
LOGE("failed to create element [%s]. continue with next.\n",
GST_OBJECT_NAME(factory));
/* check and skip it if it was already used. Otherwise, it can be an infinite loop
* because parser can accept its own output as input.
*/
- if (g_strrstr(klass, "Parser"))
- {
+ if (g_strrstr(klass, "Parser")) {
gchar *selected = NULL;
- for (; elements; elements = g_list_next(elements))
- {
+ for (; elements; elements = g_list_next(elements)) {
gchar *element_name = elements->data;
- if (g_strrstr(element_name, name_to_plug))
- {
+ if (g_strrstr(element_name, name_to_plug)) {
LOGD("but, %s already linked, so skipping it\n", name_to_plug);
skip = TRUE;
}
}
- if (skip)
- {
+ if (skip) {
MMPLAYER_FREEIF(name_template);
continue;
}
}
/* store specific handles for futher control */
- if (g_strrstr(klass, "Demux") || g_strrstr(klass, "Parse"))
- {
+ if (g_strrstr(klass, "Demux") || g_strrstr(klass, "Parse")) {
/* FIXIT : first value will be overwritten if there's more
* than 1 demuxer/parser
*/
mainbin[MMPLAYER_M_DEMUX].gst = new_element;
/*Added for multi audio support */
- if (g_strrstr(klass, "Demux"))
- {
+ if (g_strrstr(klass, "Demux")) {
mainbin[MMPLAYER_M_DEMUX_EX].id = MMPLAYER_M_DEMUX_EX;
mainbin[MMPLAYER_M_DEMUX_EX].gst = new_element;
/* NOTE : workaround for bug in mpegtsdemux since doesn't emit
no-more-pad signal. this may cause wrong content attributes at PAUSED state
this code should be removed after mpegtsdemux is fixed */
- if (g_strrstr(GST_OBJECT_NAME(factory), "mpegtsdemux"))
- {
+ if (g_strrstr(GST_OBJECT_NAME(factory), "mpegtsdemux")) {
LOGW("force no-more-pad to TRUE since mpegtsdemux os not giving no-more-pad signal. content attributes may wrong");
player->no_more_pad = TRUE;
}
}
if (g_strrstr(name_to_plug, "asfdemux")) // to support trust-zone only
- {
- g_object_set(mainbin[MMPLAYER_M_DEMUX_EX].gst, "file-location", player->profile.uri,NULL);
- }
- }
- else if (g_strrstr(klass, "Decoder") && __mmplayer_link_decoder(player,pad))
- {
- if (mainbin[MMPLAYER_M_DEC1].gst == NULL)
- {
+ g_object_set(mainbin[MMPLAYER_M_DEMUX_EX].gst, "file-location", player->profile.uri, NULL);
+ } else if (g_strrstr(klass, "Decoder") && __mmplayer_link_decoder(player, pad)) {
+ if (mainbin[MMPLAYER_M_DEC1].gst == NULL) {
LOGD("plugged element is decoder. take it[MMPLAYER_M_DEC1]\n");
mainbin[MMPLAYER_M_DEC1].id = MMPLAYER_M_DEC1;
mainbin[MMPLAYER_M_DEC1].gst = new_element;
- }
- else if (mainbin[MMPLAYER_M_DEC2].gst == NULL)
- {
+ } else if (mainbin[MMPLAYER_M_DEC2].gst == NULL) {
LOGD("plugged element is decoder. take it[MMPLAYER_M_DEC2]\n");
mainbin[MMPLAYER_M_DEC2].id = MMPLAYER_M_DEC2;
mainbin[MMPLAYER_M_DEC2].gst = new_element;
* before returning result of play start. And, missing plugin should be
* updated here for multi track files.
*/
- if (g_str_has_prefix(mime, "video"))
- {
+ if (g_str_has_prefix(mime, "video")) {
GstPad *src_pad = NULL;
GstPadTemplate *pad_templ = NULL;
GstCaps *caps = NULL;
/* clean */
MMPLAYER_FREEIF(caps_str);
gst_object_unref(src_pad);
- }
- else if (g_str_has_prefix(mime, "audio"))
- {
+ } else if (g_str_has_prefix(mime, "audio")) {
LOGD("found AUDIO decoder\n");
player->not_supported_codec &= MISSING_PLUGIN_VIDEO;
player->can_support_codec |= FOUND_PLUGIN_AUDIO;
}
if (!__mmplayer_close_link(player, pad, new_element,
- name_template,gst_element_factory_get_static_pad_templates(factory)))
- {
+ name_template, gst_element_factory_get_static_pad_templates(factory))) {
MMPLAYER_FREEIF(name_template);
if (player->keep_detecting_vcodec)
- continue;
+ continue;
/* Link is failed even though a supportable codec is found. */
__mmplayer_check_not_supported_codec(player, klass, mime);
* Some motion jpeg clips can have playable audio track.
* So, msl have to play audio after displaying popup written video format not supported.
*/
- if (!(player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst))
- {
- if (!(player->can_support_codec | player->videodec_linked | player->audiodec_linked))
- {
+ if (!(player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst)) {
+ if (!(player->can_support_codec | player->videodec_linked | player->audiodec_linked)) {
LOGD("not found demuxer\n");
player->not_found_demuxer = TRUE;
player->unlinked_demuxer_mime = g_strdup_printf("%s", mime);
}
}
- if (!g_strrstr(factory_class, "Demuxer"))
- {
- if ((g_str_has_prefix(mime, "video")) || (g_str_has_prefix(mime, "image")))
- {
+ if (!g_strrstr(factory_class, "Demuxer")) {
+ if ((g_str_has_prefix(mime, "video")) || (g_str_has_prefix(mime, "image"))) {
LOGD("can support codec=%d, vdec_linked=%d, adec_linked=%d\n",
player->can_support_codec, player->videodec_linked, player->audiodec_linked);
/* check that clip have multi tracks or not */
- if ((player->can_support_codec & FOUND_PLUGIN_VIDEO) && (player->videodec_linked))
- {
+ if ((player->can_support_codec & FOUND_PLUGIN_VIDEO) && (player->videodec_linked)) {
LOGD("video plugin is already linked\n");
- }
- else
- {
+ } else {
LOGW("add VIDEO to missing plugin\n");
player->not_supported_codec |= MISSING_PLUGIN_VIDEO;
}
- }
- else if (g_str_has_prefix(mime, "audio"))
- {
- if ((player->can_support_codec & FOUND_PLUGIN_AUDIO) && (player->audiodec_linked))
- {
+ } else if (g_str_has_prefix(mime, "audio")) {
+ if ((player->can_support_codec & FOUND_PLUGIN_AUDIO) && (player->audiodec_linked)) {
LOGD("audio plugin is already linked\n");
- }
- else
- {
+ } else {
LOGW("add AUDIO to missing plugin\n");
player->not_supported_codec |= MISSING_PLUGIN_AUDIO;
}
static void
__mmplayer_pipeline_complete(GstElement *decodebin, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
+ mm_player_t* player = (mm_player_t*)data;
MMPLAYER_FENTER();
/* remove fakesink. */
if (!__mmplayer_gst_remove_fakesink(player,
- &player->pipeline->mainbin[MMPLAYER_M_SRC_FAKESINK]))
- {
+ &player->pipeline->mainbin[MMPLAYER_M_SRC_FAKESINK])) {
/* NOTE : __mmplayer_pipeline_complete() can be called several time. because
* signaling mechanism(pad-added, no-more-pad, new-decoded-pad) from various
* source element are not same. To overcome this situation, this function will called
if ((player->ini.async_start) &&
(player->msg_posted == FALSE) &&
(player->cmd >= MMPLAYER_COMMAND_START))
- {
__mmplayer_handle_missed_plugin(player);
- }
MMPLAYER_GENERATE_DOT_IF_ENABLED(player, "pipeline-status-complete");
}
LOGD("checking for gapless play");
- if (player->pipeline->textbin)
- {
+ if (player->pipeline->textbin) {
LOGE("subtitle path is enabled. gapless play is not supported.\n");
goto ERROR;
}
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("fail to get attributes.\n");
goto ERROR;
}
#ifdef TIZEN_TV
/* gapless playback is not supported in case of video at TV profile. */
- if (video)
- {
+ if (video) {
LOGW("not support video gapless playback");
goto ERROR;
}
#endif
- if (mm_attrs_get_int_by_name(attrs, "pd_mode", &mode) == MM_ERROR_NONE)
- {
- if (mode == TRUE)
- {
+ if (mm_attrs_get_int_by_name(attrs, "pd_mode", &mode) == MM_ERROR_NONE) {
+ if (mode == TRUE) {
LOGW("pd mode\n");
goto ERROR;
}
}
if (mm_attrs_get_int_by_name(attrs, "profile_play_count", &count) != MM_ERROR_NONE)
- {
LOGE("can not get play count\n");
- }
if (mm_attrs_get_int_by_name(attrs, "gapless_mode", &gapless) != MM_ERROR_NONE)
- {
LOGE("can not get gapless mode\n");
- }
- if (video && !gapless)
- {
+ if (video && !gapless) {
LOGW("not enabled video gapless playback");
goto ERROR;
}
if ((count == -1 || count > 1)) /* enable gapless when looping or repeat */
gapless = 1;
- if (!gapless)
- {
+ if (!gapless) {
LOGW("gapless is disabled\n"); /* FIXME: playlist(without gapless) is not implemented. */
goto ERROR;
}
LOGD("repeat count = %d, num_of_list = %d\n", count, num_of_list);
- if (num_of_list == 0)
- {
- if (mm_attrs_get_string_by_name(player->attrs, "profile_uri", &uri) != MM_ERROR_NONE)
- {
+ if (num_of_list == 0) {
+ if (mm_attrs_get_string_by_name(player->attrs, "profile_uri", &uri) != MM_ERROR_NONE) {
LOGE("can not get profile_uri\n");
goto ERROR;
}
- if (!uri)
- {
+ if (!uri) {
LOGE("uri list is empty.\n");
goto ERROR;
}
LOGD("add original path : %s ", uri);
num_of_list = 1;
- uri= NULL;
+ uri = NULL;
}
uri_idx = player->uri_info.uri_idx;
- while (TRUE)
- {
+ while (TRUE) {
check_cnt++;
- if (check_cnt > num_of_list)
- {
+ if (check_cnt > num_of_list) {
LOGE("there is no valid uri.");
goto ERROR;
}
LOGD("uri idx : %d / %d\n", uri_idx, num_of_list);
- if (uri_idx < num_of_list-1)
- {
+ if (uri_idx < num_of_list-1) {
uri_idx++;
- }
- else
- {
- if ((count <= 1) && (count != -1))
- {
+ } else {
+ if ((count <= 1) && (count != -1)) {
LOGD("no repeat.");
goto ERROR;
- }
- else if (count > 1) /* decrease play count */
- {
- /* we successeded to rewind. update play count and then wait for next EOS */
+ } else if (count > 1) {
+ /* decrease play count */
+ /* we succeeded to rewind. update play count and then wait for next EOS */
count--;
mm_attrs_set_int_by_name(attrs, "profile_play_count", count);
/* commit attribute */
if (mmf_attrs_commit(attrs))
- {
LOGE("failed to commit attribute\n");
- }
}
/* count < 0 : repeat continually */
uri = g_list_nth_data(player->uri_info.uri_list, uri_idx);
LOGD("uri idx : %d, uri = %s\n", uri_idx, uri);
- if (uri == NULL)
- {
+ if (uri == NULL) {
LOGW("next uri does not exist\n");
continue;
}
- if (__mmfplayer_parse_profile((const char*)uri, NULL, &profile) != MM_ERROR_NONE)
- {
+ if (__mmfplayer_parse_profile((const char*)uri, NULL, &profile) != MM_ERROR_NONE) {
LOGE("failed to parse profile\n");
continue;
}
if ((profile.uri_type != MM_PLAYER_URI_TYPE_FILE) &&
- (profile.uri_type != MM_PLAYER_URI_TYPE_URL_HTTP))
- {
+ (profile.uri_type != MM_PLAYER_URI_TYPE_URL_HTTP)) {
LOGW("uri type is not supported(%d).", profile.uri_type);
continue;
}
player->uri_info.uri_idx = uri_idx;
mm_attrs_set_string_by_name(player->attrs, "profile_uri", uri);
- if (mmf_attrs_commit(player->attrs))
- {
+ if (mmf_attrs_commit(player->attrs)) {
LOGE("failed to commit.\n");
goto ERROR;
}
_mmplayer_track_initialize(player);
- for (i = 0; i < MM_PLAYER_STREAM_COUNT_MAX; i++)
- {
+ for (i = 0; i < MM_PLAYER_STREAM_COUNT_MAX; i++) {
player->bitrate[i] = 0;
player->maximum_bitrate[i] = 0;
}
- if (player->v_stream_caps)
- {
+ if (player->v_stream_caps) {
gst_caps_unref(player->v_stream_caps);
player->v_stream_caps = NULL;
}
mm_attrs_set_int_by_name(player->attrs, "content_audio_found", 0);
/* clean found parsers */
- if (player->parsers)
- {
+ if (player->parsers) {
GList *parsers = player->parsers;
- for (;parsers ; parsers = g_list_next(parsers))
- {
+ for (; parsers; parsers = g_list_next(parsers)) {
gchar *name = parsers->data;
MMPLAYER_FREEIF(name);
}
}
/* clean found audio decoders */
- if (player->audio_decoders)
- {
+ if (player->audio_decoders) {
GList *a_dec = player->audio_decoders;
- for (;a_dec ; a_dec = g_list_next(a_dec))
- {
+ for (; a_dec; a_dec = g_list_next(a_dec)) {
gchar *name = a_dec->data;
MMPLAYER_FREEIF(name);
}
if ((player == NULL) ||
(player->pipeline == NULL) ||
- (player->pipeline->mainbin == NULL))
- {
+ (player->pipeline->mainbin == NULL)) {
LOGE("player is null.\n");
goto ERROR;
}
msg_param.code = MM_ERROR_PLAYER_INTERNAL;
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("fail to get attributes.\n");
goto ERROR;
}
mm_attrs_get_string_by_name(attrs, "profile_uri", &uri);
- if (__mmfplayer_parse_profile((const char*)uri, NULL, &player->profile) != MM_ERROR_NONE)
- {
+ if (__mmfplayer_parse_profile((const char*)uri, NULL, &player->profile) != MM_ERROR_NONE) {
LOGE("failed to parse profile\n");
msg_param.code = MM_ERROR_PLAYER_INVALID_URI;
goto ERROR;
}
if ((MMPLAYER_URL_HAS_DASH_SUFFIX(player)) ||
- (MMPLAYER_URL_HAS_HLS_SUFFIX(player)))
- {
+ (MMPLAYER_URL_HAS_HLS_SUFFIX(player))) {
LOGE("it's dash or hls. not support.");
msg_param.code = MM_ERROR_PLAYER_INVALID_URI;
goto ERROR;
}
/* setup source */
- switch (player->profile.uri_type)
+ switch (player->profile.uri_type) {
+ /* file source */
+ case MM_PLAYER_URI_TYPE_FILE:
{
- /* file source */
- case MM_PLAYER_URI_TYPE_FILE:
- {
- LOGD("using filesrc for 'file://' handler.\n");
-
- element = gst_element_factory_make("filesrc", "source");
+ LOGD("using filesrc for 'file://' handler.\n");
- if (!element)
- {
- LOGE("failed to create filesrc\n");
- break;
- }
+ element = gst_element_factory_make("filesrc", "source");
- g_object_set(G_OBJECT(element), "location", (player->profile.uri)+7, NULL); /* uri+7 -> remove "file:// */
+ if (!element) {
+ LOGE("failed to create filesrc\n");
break;
}
- case MM_PLAYER_URI_TYPE_URL_HTTP:
- {
- gchar *user_agent, *proxy, *cookies, **cookie_list;
- gint http_timeout = DEFAULT_HTTP_TIMEOUT;
- user_agent = proxy = cookies = NULL;
- cookie_list = NULL;
- element = gst_element_factory_make(player->ini.httpsrc_element, "http_streaming_source");
- if (!element)
- {
- LOGE("failed to create http streaming source element[%s].\n", player->ini.httpsrc_element);
- break;
- }
- LOGD("using http streamming source [%s].\n", player->ini.httpsrc_element);
+ g_object_set(G_OBJECT(element), "location", (player->profile.uri)+7, NULL); /* uri+7 -> remove "file:// */
+ break;
+ }
+ case MM_PLAYER_URI_TYPE_URL_HTTP:
+ {
+ gchar *user_agent, *proxy, *cookies, **cookie_list;
+ gint http_timeout = DEFAULT_HTTP_TIMEOUT;
+ user_agent = proxy = cookies = NULL;
+ cookie_list = NULL;
- /* get attribute */
- mm_attrs_get_string_by_name(attrs, "streaming_cookie", &cookies);
- mm_attrs_get_string_by_name(attrs, "streaming_user_agent", &user_agent);
- mm_attrs_get_string_by_name(attrs, "streaming_proxy", &proxy);
- mm_attrs_get_int_by_name(attrs, "streaming_timeout", &http_timeout);
-
- if ((http_timeout == DEFAULT_HTTP_TIMEOUT) &&
- (player->ini.http_timeout != DEFAULT_HTTP_TIMEOUT))
- {
- LOGD("get timeout from ini\n");
- http_timeout = player->ini.http_timeout;
- }
-
- /* get attribute */
- SECURE_LOGD("location : %s\n", player->profile.uri);
- SECURE_LOGD("cookies : %s\n", cookies);
- SECURE_LOGD("proxy : %s\n", proxy);
- SECURE_LOGD("user_agent : %s\n", user_agent);
- LOGD("timeout : %d\n", http_timeout);
-
- /* setting property to streaming source */
- g_object_set(G_OBJECT(element), "location", player->profile.uri, NULL);
- g_object_set(G_OBJECT(element), "timeout", http_timeout, NULL);
- g_object_set(G_OBJECT(element), "blocksize", (unsigned long)(64*1024), NULL);
-
- /* check if prosy is vailid or not */
- if (util_check_valid_url(proxy))
- g_object_set(G_OBJECT(element), "proxy", proxy, NULL);
- /* parsing cookies */
- if ((cookie_list = util_get_cookie_list((const char*)cookies)))
- g_object_set(G_OBJECT(element), "cookies", cookie_list, NULL);
- if (user_agent)
- g_object_set(G_OBJECT(element), "user_agent", user_agent, NULL);
+ element = gst_element_factory_make(player->ini.httpsrc_element, "http_streaming_source");
+ if (!element) {
+ LOGE("failed to create http streaming source element[%s].\n", player->ini.httpsrc_element);
break;
}
- default:
- LOGE("not support uri type %d\n", player->profile.uri_type);
- break;
+ LOGD("using http streamming source [%s].\n", player->ini.httpsrc_element);
+
+ /* get attribute */
+ mm_attrs_get_string_by_name(attrs, "streaming_cookie", &cookies);
+ mm_attrs_get_string_by_name(attrs, "streaming_user_agent", &user_agent);
+ mm_attrs_get_string_by_name(attrs, "streaming_proxy", &proxy);
+ mm_attrs_get_int_by_name(attrs, "streaming_timeout", &http_timeout);
+
+ if ((http_timeout == DEFAULT_HTTP_TIMEOUT) &&
+ (player->ini.http_timeout != DEFAULT_HTTP_TIMEOUT)) {
+ LOGD("get timeout from ini\n");
+ http_timeout = player->ini.http_timeout;
+ }
+
+ /* get attribute */
+ SECURE_LOGD("location : %s\n", player->profile.uri);
+ SECURE_LOGD("cookies : %s\n", cookies);
+ SECURE_LOGD("proxy : %s\n", proxy);
+ SECURE_LOGD("user_agent : %s\n", user_agent);
+ LOGD("timeout : %d\n", http_timeout);
+
+ /* setting property to streaming source */
+ g_object_set(G_OBJECT(element), "location", player->profile.uri, NULL);
+ g_object_set(G_OBJECT(element), "timeout", http_timeout, NULL);
+ g_object_set(G_OBJECT(element), "blocksize", (unsigned long)(64*1024), NULL);
+
+ /* check if prosy is vailid or not */
+ if (util_check_valid_url(proxy))
+ g_object_set(G_OBJECT(element), "proxy", proxy, NULL);
+ /* parsing cookies */
+ if ((cookie_list = util_get_cookie_list((const char*)cookies)))
+ g_object_set(G_OBJECT(element), "cookies", cookie_list, NULL);
+ if (user_agent)
+ g_object_set(G_OBJECT(element), "user_agent", user_agent, NULL);
+ break;
+ }
+ default:
+ LOGE("not support uri type %d\n", player->profile.uri_type);
+ break;
}
- if (!element)
- {
+ if (!element) {
LOGE("no source element was created.\n");
goto ERROR;
}
- if (gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), element) == FALSE)
- {
+ if (gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), element) == FALSE) {
LOGE("failed to add source element to pipeline\n");
gst_object_unref(GST_OBJECT(element));
element = NULL;
element = NULL;
- if (MMPLAYER_IS_HTTP_STREAMING(player))
- {
- if (player->streamer == NULL)
- {
+ if (MMPLAYER_IS_HTTP_STREAMING(player)) {
+ if (player->streamer == NULL) {
player->streamer = __mm_player_streaming_create();
__mm_player_streaming_initialize(player->streamer);
}
element = gst_element_factory_make("typefind", "typefinder");
MMPLAYER_SIGNAL_CONNECT(player, element, MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "have-type",
G_CALLBACK(__mmplayer_typefind_have_type), (gpointer)player);
- }
- else
- {
+ } else {
elemId = MMPLAYER_M_AUTOPLUG;
element = __mmplayer_create_decodebin(player);
}
/* check autoplug element is OK */
- if (!element)
- {
+ if (!element) {
LOGE("can not create element(%d)\n", elemId);
goto ERROR;
}
- if (gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), element) == FALSE)
- {
+ if (gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), element) == FALSE) {
LOGE("failed to add sinkbin to pipeline\n");
gst_object_unref(GST_OBJECT(element));
element = NULL;
mainbin[elemId].id = elemId;
mainbin[elemId].gst = element;
- if (gst_element_link(mainbin[MMPLAYER_M_SRC].gst, mainbin[elemId].gst) == FALSE)
- {
+ if (gst_element_link(mainbin[MMPLAYER_M_SRC].gst, mainbin[elemId].gst) == FALSE) {
LOGE("Failed to link src - autoplug(or typefind)\n");
goto ERROR;
}
- if (gst_element_set_state(mainbin[MMPLAYER_M_SRC].gst, target) == GST_STATE_CHANGE_FAILURE)
- {
+ if (gst_element_set_state(mainbin[MMPLAYER_M_SRC].gst, target) == GST_STATE_CHANGE_FAILURE) {
LOGE("Failed to change state of src element\n");
goto ERROR;
}
- if (!MMPLAYER_IS_HTTP_STREAMING(player))
- {
- if (gst_element_set_state(mainbin[MMPLAYER_M_AUTOPLUG].gst, target) == GST_STATE_CHANGE_FAILURE)
- {
+ if (!MMPLAYER_IS_HTTP_STREAMING(player)) {
+ if (gst_element_set_state(mainbin[MMPLAYER_M_AUTOPLUG].gst, target) == GST_STATE_CHANGE_FAILURE) {
LOGE("Failed to change state of decodebin\n");
goto ERROR;
}
- }
- else
- {
- if (gst_element_set_state(mainbin[MMPLAYER_M_TYPEFIND].gst, target) == GST_STATE_CHANGE_FAILURE)
- {
+ } else {
+ if (gst_element_set_state(mainbin[MMPLAYER_M_TYPEFIND].gst, target) == GST_STATE_CHANGE_FAILURE) {
LOGE("Failed to change state of src element\n");
goto ERROR;
}
return;
ERROR:
- if (player)
- {
+ if (player) {
MMPLAYER_PLAYBACK_UNLOCK(player);
- if (!player->msg_posted)
- {
+ if (!player->msg_posted) {
MMPLAYER_POST_MSG(player, MM_MESSAGE_ERROR, &msg_param);
player->msg_posted = TRUE;
}
LOGD("type %d", type);
- switch (type)
- {
- case MM_PLAYER_TRACK_TYPE_AUDIO:
- selectorId = MMPLAYER_M_A_INPUT_SELECTOR;
- sinkId = MMPLAYER_A_BIN;
- sinkbin = player->pipeline->audiobin;
+ switch (type) {
+ case MM_PLAYER_TRACK_TYPE_AUDIO:
+ selectorId = MMPLAYER_M_A_INPUT_SELECTOR;
+ sinkId = MMPLAYER_A_BIN;
+ sinkbin = player->pipeline->audiobin;
break;
- case MM_PLAYER_TRACK_TYPE_VIDEO:
- selectorId = MMPLAYER_M_V_INPUT_SELECTOR;
- sinkId = MMPLAYER_V_BIN;
- sinkbin = player->pipeline->videobin;
- send_notice = TRUE;
+ case MM_PLAYER_TRACK_TYPE_VIDEO:
+ selectorId = MMPLAYER_M_V_INPUT_SELECTOR;
+ sinkId = MMPLAYER_V_BIN;
+ sinkbin = player->pipeline->videobin;
+ send_notice = TRUE;
break;
- case MM_PLAYER_TRACK_TYPE_TEXT:
- selectorId = MMPLAYER_M_T_INPUT_SELECTOR;
- sinkId = MMPLAYER_T_BIN;
- sinkbin = player->pipeline->textbin;
+ case MM_PLAYER_TRACK_TYPE_TEXT:
+ selectorId = MMPLAYER_M_T_INPUT_SELECTOR;
+ sinkId = MMPLAYER_T_BIN;
+ sinkbin = player->pipeline->textbin;
break;
- default:
- LOGE("requested type is not supportable");
- return FALSE;
+ default:
+ LOGE("requested type is not supportable");
+ return FALSE;
break;
}
- if (player->pipeline->mainbin[selectorId].gst)
- {
+ if (player->pipeline->mainbin[selectorId].gst) {
gint n;
srcpad = gst_element_get_static_pad(player->pipeline->mainbin[selectorId].gst, "src");
gst_pad_remove_probe(srcpad, selector->event_probe_id);
selector->event_probe_id = 0;
- if ((sinkbin) && (sinkbin[sinkId].gst))
- {
+ if ((sinkbin) && (sinkbin[sinkId].gst)) {
sinkpad = gst_element_get_static_pad(sinkbin[sinkId].gst, "sink");
- if (srcpad && sinkpad)
- {
+ if (srcpad && sinkpad) {
/* after getting drained signal there is no data flows, so no need to do pad_block */
LOGD("unlink %s:%s, %s:%s", GST_DEBUG_PAD_NAME(srcpad), GST_DEBUG_PAD_NAME(sinkpad));
gst_pad_unlink(srcpad, sinkpad);
LOGD("selector release");
/* release and unref requests pad from the selector */
- for (n = 0; n < selector->channels->len; n++)
- {
+ for (n = 0; n < selector->channels->len; n++) {
GstPad *sinkpad = g_ptr_array_index(selector->channels, n);
gst_element_release_request_pad((player->pipeline->mainbin[selectorId].gst), sinkpad);
}
if ((!__mmplayer_deactivate_selector(player, MM_PLAYER_TRACK_TYPE_AUDIO)) ||
(!__mmplayer_deactivate_selector(player, MM_PLAYER_TRACK_TYPE_VIDEO)) ||
- (!__mmplayer_deactivate_selector(player, MM_PLAYER_TRACK_TYPE_TEXT)))
- {
+ (!__mmplayer_deactivate_selector(player, MM_PLAYER_TRACK_TYPE_TEXT))) {
LOGE("deactivate selector error");
goto ERROR;
}
_mmplayer_track_destroy(player);
__mmplayer_release_signal_connection(player, MM_PLAYER_SIGNAL_TYPE_AUTOPLUG);
- if (player->streamer)
- {
+ if (player->streamer) {
__mm_player_streaming_deinitialize(player->streamer);
__mm_player_streaming_destroy(player->streamer);
player->streamer = NULL;
ERROR:
- if (!player->msg_posted)
- {
+ if (!player->msg_posted) {
MMMessageParamType msg = {0,};
/*post error*/
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
mm_attrs_set_string_by_name(player->attrs, "profile_uri", uri);
- if (mmf_attrs_commit(player->attrs))
- {
+ if (mmf_attrs_commit(player->attrs)) {
LOGE("failed to commit the original uri.\n");
result = MM_ERROR_PLAYER_INTERNAL;
- }
- else
- {
+ } else {
if (_mmplayer_set_next_uri(hplayer, uri, TRUE) != MM_ERROR_NONE)
- {
LOGE("failed to add the original uri in the uri list.\n");
- }
}
MMPLAYER_FLEAVE();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
MMPLAYER_RETURN_VAL_IF_FAIL(uri, MM_ERROR_INVALID_ARGUMENT);
- if (player->pipeline && player->pipeline->textbin)
- {
+ if (player->pipeline && player->pipeline->textbin) {
LOGE("subtitle path is enabled.\n");
return MM_ERROR_PLAYER_INVALID_STATE;
}
num_of_list = g_list_length(player->uri_info.uri_list);
- if (is_first_path == TRUE)
- {
- if (num_of_list == 0)
- {
+ if (is_first_path == TRUE) {
+ if (num_of_list == 0) {
player->uri_info.uri_list = g_list_append(player->uri_info.uri_list, g_strdup(uri));
LOGD("add original path : %s", uri);
- }
- else
- {
+ } else {
player->uri_info.uri_list = g_list_delete_link(player->uri_info.uri_list, g_list_nth(player->uri_info.uri_list, 0));
player->uri_info.uri_list = g_list_insert(player->uri_info.uri_list, g_strdup(uri), 0);
LOGD("change original path : %s", uri);
}
- }
- else
- {
+ } else {
MMHandleType attrs = 0;
attrs = MMPLAYER_GET_ATTRS(player);
- if (num_of_list == 0)
- {
+ if (num_of_list == 0) {
char *original_uri = NULL;
- if (attrs)
- {
+ if (attrs) {
mm_attrs_get_string_by_name(attrs, "profile_uri", &original_uri);
- if (!original_uri)
- {
+ if (!original_uri) {
LOGE("there is no original uri.");
return MM_ERROR_PLAYER_INVALID_STATE;
}
num_of_list = g_list_length(player->uri_info.uri_list);
- if (num_of_list > 0)
- {
+ if (num_of_list > 0) {
gint uri_idx = player->uri_info.uri_idx;
if (uri_idx < num_of_list-1)
caps_str = gst_caps_to_string(caps);
/* set it directly because not sent by TAG */
- if (g_strrstr(caps_str, "mobile-xmf")) {
+ if (g_strrstr(caps_str, "mobile-xmf"))
mm_attrs_set_string_by_name(player->attrs, "content_audio_codec", "mobile-xmf");
- }
MMPLAYER_FREEIF(caps_str);
} else if (g_str_has_prefix(mime, "video") && !player->ini.video_playback_supported) {
MMMessageParamType msg_param;
LOGD("found new element [%s] to link", factory_name);
/* store type string */
- if (player->type == NULL)
- {
+ if (player->type == NULL) {
player->type = gst_caps_to_string(caps);
__mmplayer_update_content_type_info(player);
}
mm_attrs_get_int_by_name(player->attrs,
"display_surface_type", &surface_type);
LOGD("check display surface type attribute: %d", surface_type);
- if (surface_type == MM_DISPLAY_SURFACE_EVAS && strstr(factory_name, "omx"))
- {
+ if (surface_type == MM_DISPLAY_SURFACE_EVAS && strstr(factory_name, "omx")) {
LOGW("skipping [%s] for supporting evasimagesink temporarily.\n", factory_name);
result = GST_AUTOPLUG_SELECT_SKIP;
goto DONE;
}
/* filtering exclude keyword */
- for (idx = 0; player->ini.exclude_element_keyword[idx][0] != '\0'; idx++)
- {
- if (strstr(factory_name, player->ini.exclude_element_keyword[idx]))
- {
+ for (idx = 0; player->ini.exclude_element_keyword[idx][0] != '\0'; idx++) {
+ if (strstr(factory_name, player->ini.exclude_element_keyword[idx])) {
LOGW("skipping [%s] by exculde keyword [%s]\n",
factory_name, player->ini.exclude_element_keyword[idx]);
/* NOTE : msl don't need to use image plugins.
* So, those plugins should be skipped for error handling.
*/
- if (g_strrstr(klass, "Codec/Decoder/Image"))
- {
+ if (g_strrstr(klass, "Codec/Decoder/Image")) {
LOGD("skipping [%s] by not required\n", factory_name);
result = GST_AUTOPLUG_SELECT_SKIP;
goto DONE;
}
if ((MMPLAYER_IS_MS_BUFF_SRC(player)) &&
- (g_strrstr(klass, "Codec/Demuxer") || (g_strrstr(klass, "Codec/Parser"))))
- {
+ (g_strrstr(klass, "Codec/Demuxer") || (g_strrstr(klass, "Codec/Parser")))) {
// TO CHECK : subtitle if needed, add subparse exception.
LOGD("skipping parser/demuxer [%s] in es player by not required\n", factory_name);
result = GST_AUTOPLUG_SELECT_SKIP;
goto DONE;
}
- if (g_strrstr(factory_name, "mpegpsdemux"))
- {
+ if (g_strrstr(factory_name, "mpegpsdemux")) {
LOGD("skipping PS container - not support\n");
result = GST_AUTOPLUG_SELECT_SKIP;
goto DONE;
player->smooth_streaming = TRUE;
/* check ALP Codec can be used or not */
- if ((g_strrstr(klass, "Codec/Decoder/Audio")))
- {
+ if ((g_strrstr(klass, "Codec/Decoder/Audio"))) {
GstStructure* str = NULL;
gint channels = 0;
str = gst_caps_get_structure(caps, 0);
- if (str)
- {
+ if (str) {
gst_structure_get_int(str, "channels", &channels);
LOGD("check audio ch : %d %d\n", player->max_audio_channels, channels);
if (player->max_audio_channels < channels)
- {
player->max_audio_channels = channels;
- }
}
-
+ /* set stream information */
if (!player->audiodec_linked)
- {
- /* set stream information */
__mmplayer_set_audio_attrs(player, caps);
- }
- }
- else if (g_strrstr(klass, "Codec/Decoder/Video"))
- {
+ } 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)))
- {
+ (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_state) == MM_ERROR_NONE)
- {
+ if (_mmplayer_resource_manager_get_state(&player->resource_manager, &resource_state) == MM_ERROR_NONE) {
/* prepare resource manager for video decoder */
- if ((resource_state >= RESOURCE_STATE_INITIALIZED) && (resource_state < RESOURCE_STATE_ACQUIRED))
- {
+ if ((resource_state >= RESOURCE_STATE_INITIALIZED) && (resource_state < RESOURCE_STATE_ACQUIRED)) {
if (_mmplayer_resource_manager_prepare(&player->resource_manager, RESOURCE_TYPE_VIDEO_DECODER)
- != MM_ERROR_NONE)
- {
+ != MM_ERROR_NONE) {
LOGW("could not prepare for video_decoder resource, skip it.");
result = GST_AUTOPLUG_SELECT_SKIP;
goto DONE;
}
if ((g_strrstr(klass, "Codec/Parser/Converter/Video")) ||
- (g_strrstr(klass, "Codec/Decoder/Video")))
- {
+ (g_strrstr(klass, "Codec/Decoder/Video"))) {
gint stype = 0;
gint width = 0;
GstStructure *str = NULL;
/* don't make video because of not required */
if ((stype == MM_DISPLAY_SURFACE_NULL) &&
- (player->set_mode.media_packet_video_stream == FALSE))
- {
+ (player->set_mode.media_packet_video_stream == FALSE)) {
LOGD("no video because it's not required. -> return expose");
result = GST_AUTOPLUG_SELECT_EXPOSE;
goto DONE;
}
}
- if (g_strrstr(klass, "Decoder"))
- {
+ if (g_strrstr(klass, "Decoder")) {
const char* mime = NULL;
mime = gst_structure_get_name(gst_caps_get_structure(caps, 0));
- if (g_str_has_prefix(mime, "video"))
- {
+ if (g_str_has_prefix(mime, "video")) {
// __mmplayer_check_video_zero_cpoy(player, factory);
player->not_supported_codec &= MISSING_PLUGIN_AUDIO;
player->can_support_codec |= FOUND_PLUGIN_VIDEO;
player->videodec_linked = 1;
- }
- else if (g_str_has_prefix(mime, "audio"))
- {
+ } else if (g_str_has_prefix(mime, "audio")) {
player->not_supported_codec &= MISSING_PLUGIN_VIDEO;
player->can_support_codec |= FOUND_PLUGIN_AUDIO;
__mmplayer_gst_decode_autoplug_factories(GstElement *bin, GstPad* pad,
GstCaps * caps, gpointer data)
{
- //mm_player_t* player = (mm_player_t*)data;
+ //mm_player_t* player = (mm_player_t*)data;
LOGD("decodebin is requesting factories for caps [%s] from element[%s]",
- gst_caps_to_string(caps),
- GST_ELEMENT_NAME(GST_PAD_PARENT(pad)));
+ gst_caps_to_string(caps),
+ GST_ELEMENT_NAME(GST_PAD_PARENT(pad)));
return NULL;
}
__mmplayer_gst_decode_pad_removed(GstElement *elem, GstPad* new_pad,
gpointer data) // @
{
- //mm_player_t* player = (mm_player_t*)data;
+ //mm_player_t* player = (mm_player_t*)data;
GstCaps* caps = NULL;
LOGD("[Decodebin2] pad-removed signal\n");
caps = gst_pad_query_caps(new_pad, NULL);
- if (caps)
- {
+ if (caps) {
gchar* caps_str = NULL;
caps_str = gst_caps_to_string(caps);
LOGD("__mmplayer_gst_decode_drained");
- if (player->use_deinterleave == TRUE)
- {
+ if (player->use_deinterleave == TRUE) {
LOGD("group playing mode.");
return;
}
- if (!g_mutex_trylock(&player->cmd_lock))
- {
+ if (!g_mutex_trylock(&player->cmd_lock)) {
LOGW("Fail to get cmd lock");
return;
}
- if (!__mmplayer_verify_next_play_path(player))
- {
+ if (!__mmplayer_verify_next_play_path(player)) {
LOGD("decoding is finished.");
__mmplayer_reset_gapless_state(player);
g_mutex_unlock(&player->cmd_lock);
LOGD("add buffer probe");
//<-
- if (g_strrstr(klass, "Codec/Decoder/Audio"))
- {
+ if (g_strrstr(klass, "Codec/Decoder/Audio")) {
gchar* selected = NULL;
selected = g_strdup(GST_ELEMENT_NAME(element));
player->audio_decoders = g_list_append(player->audio_decoders, selected);
}
//-> temp code
- if (g_strrstr(klass, "Parser"))
- {
+ if (g_strrstr(klass, "Parser")) {
gchar* selected = NULL;
selected = g_strdup(factory_name);
player->parsers = g_list_append(player->parsers, selected);
}
- if ((g_strrstr(klass, "Demux") || g_strrstr(klass, "Parse")) && !(g_strrstr(klass, "Adaptive")))
- {
+ if ((g_strrstr(klass, "Demux") || g_strrstr(klass, "Parse")) && !(g_strrstr(klass, "Adaptive"))) {
/* FIXIT : first value will be overwritten if there's more
* than 1 demuxer/parser
*/
player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst = element;
/*Added for multi audio support */ // Q. del?
- if (g_strrstr(klass, "Demux"))
- {
+ if (g_strrstr(klass, "Demux")) {
player->pipeline->mainbin[MMPLAYER_M_DEMUX_EX].id = MMPLAYER_M_DEMUX_EX;
player->pipeline->mainbin[MMPLAYER_M_DEMUX_EX].gst = element;
}
}
- if (g_strrstr(factory_name, "asfdemux") || g_strrstr(factory_name, "qtdemux") || g_strrstr(factory_name, "avidemux"))
- {
+ if (g_strrstr(factory_name, "asfdemux") || g_strrstr(factory_name, "qtdemux") || g_strrstr(factory_name, "avidemux")) {
int surface_type = 0;
mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &surface_type);
}
// to support trust-zone only
- if (g_strrstr(factory_name, "asfdemux"))
- {
+ if (g_strrstr(factory_name, "asfdemux")) {
LOGD("set file-location %s\n", player->profile.uri);
g_object_set(G_OBJECT(element), "file-location", player->profile.uri, NULL);
if (player->video_hub_download_mode == TRUE)
- {
g_object_set(G_OBJECT(element), "downloading-mode", player->video_hub_download_mode, NULL);
- }
- }
- else if (g_strrstr(factory_name, "legacyh264parse"))
- {
+ } else if (g_strrstr(factory_name, "legacyh264parse")) {
LOGD("[%s] output-format to legacyh264parse\n", "mssdemux");
g_object_set(G_OBJECT(element), "output-format", 1, NULL); /* NALU/Byte Stream format */
- }
- else if (g_strrstr(factory_name, "mpegaudioparse"))
- {
+ } else if (g_strrstr(factory_name, "mpegaudioparse")) {
if ((MMPLAYER_IS_HTTP_STREAMING(player)) &&
- (__mmplayer_is_only_mp3_type(player->type)))
- {
+ (__mmplayer_is_only_mp3_type(player->type))) {
LOGD("[mpegaudioparse] set streaming pull mode.");
g_object_set(G_OBJECT(element), "http-pull-mp3dec", TRUE, NULL);
}
- }
- else if (g_strrstr(factory_name, player->ini.videocodec_element_hw))
- {
+ } else if (g_strrstr(factory_name, player->ini.videocodec_element_hw))
player->pipeline->mainbin[MMPLAYER_M_DEC1].gst = element;
- }
+
if ((player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst) &&
- (g_strrstr(GST_ELEMENT_NAME(element), "multiqueue")))
- {
+ (g_strrstr(GST_ELEMENT_NAME(element), "multiqueue"))) {
LOGD("plugged element is multiqueue. take it\n");
player->pipeline->mainbin[MMPLAYER_M_DEMUXED_S_BUFFER].id = MMPLAYER_M_DEMUXED_S_BUFFER;
player->pipeline->mainbin[MMPLAYER_M_DEMUXED_S_BUFFER].gst = element;
if ((MMPLAYER_IS_HTTP_STREAMING(player)) ||
- (MMPLAYER_IS_HTTP_LIVE_STREAMING(player)))
- {
+ (MMPLAYER_IS_HTTP_LIVE_STREAMING(player))) {
/* in case of multiqueue, max bytes size is defined with fixed value in mm_player_streaming.h*/
__mm_player_streaming_set_multiqueue(player->streamer,
element,
return FALSE;
/* This callback can be set to music player only. */
- if ((player->can_support_codec & 0x02) == FOUND_PLUGIN_VIDEO)
- {
+ if ((player->can_support_codec & 0x02) == FOUND_PLUGIN_VIDEO) {
LOGW("audio callback is not supported for video");
return FALSE;
}
- if (player->audio_stream_cb)
- {
- {
- GstPad *pad = NULL;
+ if (player->audio_stream_cb) {
+ GstPad *pad = NULL;
- pad = gst_element_get_static_pad(player->pipeline->audiobin[MMPLAYER_A_SINK].gst, "sink");
+ pad = gst_element_get_static_pad(player->pipeline->audiobin[MMPLAYER_A_SINK].gst, "sink");
- if (!pad)
- {
- LOGE("failed to get sink pad from audiosink to probe data\n");
- return FALSE;
- }
- player->audio_cb_probe_id = gst_pad_add_probe(pad, GST_PAD_PROBE_TYPE_BUFFER,
- __mmplayer_audio_stream_probe, player, NULL);
+ if (!pad) {
+ LOGE("failed to get sink pad from audiosink to probe data\n");
+ return FALSE;
+ }
+ player->audio_cb_probe_id = gst_pad_add_probe(pad, GST_PAD_PROBE_TYPE_BUFFER,
+ __mmplayer_audio_stream_probe, player, NULL);
- gst_object_unref(pad);
+ gst_object_unref(pad);
- pad = NULL;
- }
- }
- else
- {
+ pad = NULL;
+ } else {
LOGE("There is no audio callback to configure.\n");
return FALSE;
}
MMPLAYER_RETURN_IF_FAIL(player);
player->factories = gst_registry_feature_filter(gst_registry_get(),
- (GstPluginFeatureFilter)__mmplayer_feature_filter, FALSE, NULL);
+ (GstPluginFeatureFilter)__mmplayer_feature_filter, FALSE, NULL);
player->factories = g_list_sort(player->factories, (GCompareFunc)util_factory_rank_compare);
}
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
- if (player->factories)
- {
+ if (player->factories) {
gst_plugin_feature_list_free(player->factories);
player->factories = NULL;
}
/* recover mode */
player->set_mode.rich_audio = cur_mode;
- for (i = 0; i < MM_PLAYER_STREAM_COUNT_MAX; i++)
- {
+ for (i = 0; i < MM_PLAYER_STREAM_COUNT_MAX; i++) {
player->bitrate[i] = 0;
player->maximum_bitrate[i] = 0;
}
/* remove media stream cb(appsrc cb) */
- for (i = 0; i < MM_PLAYER_STREAM_TYPE_MAX; i++)
- {
+ for (i = 0; i < MM_PLAYER_STREAM_TYPE_MAX; i++) {
player->media_stream_buffer_status_cb[i] = NULL;
player->media_stream_seek_data_cb[i] = NULL;
}
/* free memory related to audio effect */
MMPLAYER_FREEIF(player->audio_effect_info.custom_ext_level_for_plugin);
- if (player->state_tune_caps)
- {
+ if (player->state_tune_caps) {
gst_caps_unref(player->state_tune_caps);
player->state_tune_caps = NULL;
}
mm_attrs_set_int_by_name(player->attrs, "content_audio_found", 0);
/* clean found parsers */
- if (player->parsers)
- {
+ if (player->parsers) {
GList *parsers = player->parsers;
- for (;parsers ; parsers = g_list_next(parsers))
- {
+ for (; parsers; parsers = g_list_next(parsers)) {
gchar *name = parsers->data;
MMPLAYER_FREEIF(name);
}
}
/* clean found audio decoders */
- if (player->audio_decoders)
- {
+ if (player->audio_decoders) {
GList *a_dec = player->audio_decoders;
- for (;a_dec ; a_dec = g_list_next(a_dec))
- {
+ for (; a_dec; a_dec = g_list_next(a_dec)) {
gchar *name = a_dec->data;
MMPLAYER_FREEIF(name);
}
}
/* clean the uri list except original uri */
- if (player->uri_info.uri_list)
- {
+ if (player->uri_info.uri_list) {
original_uri = g_list_nth_data(player->uri_info.uri_list, 0);
- if (player->attrs)
- {
+ if (player->attrs) {
mm_attrs_set_string_by_name(player->attrs, "profile_uri", original_uri);
LOGD("restore original uri = %s\n", original_uri);
if (mmf_attrs_commit(player->attrs))
- {
LOGE("failed to commit the original uri.\n");
- }
}
GList *uri_list = player->uri_info.uri_list;
- for (;uri_list ; uri_list = g_list_next(uri_list))
- {
+ for (; uri_list; uri_list = g_list_next(uri_list)) {
gchar *uri = uri_list->data;
MMPLAYER_FREEIF(uri);
}
LOGD("creating %s to plug\n", name);
element = gst_element_factory_make(name, NULL);
- if (!element)
- {
+ if (!element) {
LOGE("failed to create queue\n");
return NULL;
}
- if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(element, GST_STATE_READY))
- {
+ if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(element, GST_STATE_READY)) {
LOGE("failed to set state READY to %s\n", name);
gst_object_unref(element);
return NULL;
}
- if (!gst_bin_add(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst), element))
- {
+ if (!gst_bin_add(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst), element)) {
LOGE("failed to add %s\n", name);
gst_object_unref(element);
return NULL;
sinkpad = gst_element_get_static_pad(element, "sink");
- if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad)) {
LOGE("failed to link %s\n", name);
gst_object_unref(sinkpad);
gst_object_unref(element);
LOGD("plugging pad %s:%s to newly create %s:%s\n",
GST_ELEMENT_NAME(GST_PAD_PARENT(srcpad)),
- GST_PAD_NAME(srcpad),
- GST_ELEMENT_NAME(sinkelement),
- padname);
+ GST_PAD_NAME(srcpad),
+ GST_ELEMENT_NAME(sinkelement),
+ padname);
factory = gst_element_get_factory(sinkelement);
klass = gst_element_factory_get_metadata(factory, GST_ELEMENT_METADATA_KLASS);
MMPLAYER_CHECK_CMD_IF_EXIT(player);
/* need it to warm up omx before linking to pipeline */
- if (g_strrstr(GST_ELEMENT_NAME(GST_PAD_PARENT(srcpad)), "demux"))
- {
+ if (g_strrstr(GST_ELEMENT_NAME(GST_PAD_PARENT(srcpad)), "demux")) {
LOGD("get demux caps.\n");
- if (player->state_tune_caps)
- {
+ if (player->state_tune_caps) {
gst_caps_unref(player->state_tune_caps);
player->state_tune_caps = NULL;
}
}
/* NOTE : OMX Codec can check if resource is available or not at this state. */
- if (g_strrstr(GST_ELEMENT_NAME(sinkelement), "omx"))
- {
- if (player->state_tune_caps != NULL)
- {
+ if (g_strrstr(GST_ELEMENT_NAME(sinkelement), "omx")) {
+ if (player->state_tune_caps != NULL) {
LOGD("set demux's caps to omx codec if resource is available");
- if (gst_pad_set_caps(gst_element_get_static_pad(sinkelement, "sink"), player->state_tune_caps))
- {
+ if (gst_pad_set_caps(gst_element_get_static_pad(sinkelement, "sink"), player->state_tune_caps)) {
target_state = GST_STATE_PAUSED;
isvideo_decoder = TRUE;
g_object_set(G_OBJECT(sinkelement), "state-tuning", TRUE, NULL);
- }
- else
- {
+ } else
LOGW("failed to set caps for state tuning");
- }
}
gst_caps_unref(player->state_tune_caps);
player->state_tune_caps = NULL;
}
- if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(sinkelement, target_state))
- {
+ if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(sinkelement, target_state)) {
LOGE("failed to set %d state to %s\n", target_state, GST_ELEMENT_NAME(sinkelement));
- if (isvideo_decoder)
- {
+ if (isvideo_decoder) {
gst_element_set_state(sinkelement, GST_STATE_NULL);
gst_object_unref(G_OBJECT(sinkelement));
player->keep_detecting_vcodec = TRUE;
}
/* add to pipeline */
- if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), sinkelement))
- {
+ if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), sinkelement)) {
LOGE("failed to add %s to mainbin\n", GST_ELEMENT_NAME(sinkelement));
goto ERROR;
}
/* added to support multi track files */
/* only decoder case and any of the video/audio still need to link*/
- if (g_strrstr(klass, "Decoder") && __mmplayer_link_decoder(player,srcpad))
- {
+ if (g_strrstr(klass, "Decoder") && __mmplayer_link_decoder(player, srcpad)) {
gchar *name = g_strdup(GST_ELEMENT_NAME(GST_PAD_PARENT(srcpad)));
- if (g_strrstr(name, "mpegtsdemux")|| g_strrstr(name, "mssdemux"))
- {
+ if (g_strrstr(name, "mpegtsdemux") || g_strrstr(name, "mssdemux")) {
gchar *src_demux_caps_str = NULL;
gchar *needed_parser = NULL;
GstCaps *src_demux_caps = NULL;
gst_caps_unref(src_demux_caps);
- if (g_strrstr(src_demux_caps_str, "video/x-h264"))
- {
- if (g_strrstr(name, "mssdemux"))
- {
+ if (g_strrstr(src_demux_caps_str, "video/x-h264")) {
+ if (g_strrstr(name, "mssdemux")) {
needed_parser = g_strdup("legacyh264parse");
smooth_streaming = TRUE;
- }
- else
- {
+ } else
needed_parser = g_strdup("h264parse");
- }
- }
- else if (g_strrstr(src_demux_caps_str, "video/mpeg"))
- {
+ } else if (g_strrstr(src_demux_caps_str, "video/mpeg"))
needed_parser = g_strdup("mpeg4videoparse");
- }
+
MMPLAYER_FREEIF(src_demux_caps_str);
- if (needed_parser)
- {
+ if (needed_parser) {
parser = __mmplayer_element_create_and_link(player, srcpad, needed_parser);
MMPLAYER_FREEIF(needed_parser);
- if (!parser)
- {
+ if (!parser) {
LOGE("failed to create parser\n");
- }
- else
- {
+ } else {
if (smooth_streaming)
- {
g_object_set(parser, "output-format", 1, NULL); /* NALU/Byte Stream format */
- }
/* update srcpad if parser is created */
pssrcpad = gst_element_get_static_pad(parser, "src");
MMPLAYER_FREEIF(name);
queue = __mmplayer_element_create_and_link(player, srcpad, "queue"); // parser - queue or demuxer - queue
- if (!queue)
- {
+ if (!queue) {
LOGE("failed to create queue\n");
goto ERROR;
}
/* assigning queue handle for futher manipulation purpose */
/* FIXIT : make it some kind of list so that msl can support more then two stream(text, data, etc...) */
- if (mainbin[MMPLAYER_M_Q1].gst == NULL)
- {
+ if (mainbin[MMPLAYER_M_Q1].gst == NULL) {
mainbin[MMPLAYER_M_Q1].id = MMPLAYER_M_Q1;
mainbin[MMPLAYER_M_Q1].gst = queue;
- if (player->profile.uri_type == MM_PLAYER_URI_TYPE_SS)
- {
+ if (player->profile.uri_type == MM_PLAYER_URI_TYPE_SS) {
g_object_set(G_OBJECT(mainbin[MMPLAYER_M_Q1].gst), "max-size-time", 0 , NULL);
g_object_set(G_OBJECT(mainbin[MMPLAYER_M_Q1].gst), "max-size-buffers", 2, NULL);
g_object_set(G_OBJECT(mainbin[MMPLAYER_M_Q1].gst), "max-size-bytes", 0, NULL);
- }
- else
- {
+ } else {
if (!MMPLAYER_IS_RTSP_STREAMING(player))
g_object_set(G_OBJECT(mainbin[MMPLAYER_M_Q1].gst), "max-size-time", q_max_size_time * GST_SECOND, NULL);
}
- }
- else if (mainbin[MMPLAYER_M_Q2].gst == NULL)
- {
+ } else if (mainbin[MMPLAYER_M_Q2].gst == NULL) {
mainbin[MMPLAYER_M_Q2].id = MMPLAYER_M_Q2;
mainbin[MMPLAYER_M_Q2].gst = queue;
- if (player->profile.uri_type == MM_PLAYER_URI_TYPE_SS)
- {
+ if (player->profile.uri_type == MM_PLAYER_URI_TYPE_SS) {
g_object_set(G_OBJECT(mainbin[MMPLAYER_M_Q2].gst), "max-size-time", 0 , NULL);
g_object_set(G_OBJECT(mainbin[MMPLAYER_M_Q2].gst), "max-size-buffers", 2, NULL);
g_object_set(G_OBJECT(mainbin[MMPLAYER_M_Q2].gst), "max-size-bytes", 0, NULL);
- }
- else
- {
+ } else {
if (!MMPLAYER_IS_RTSP_STREAMING(player))
g_object_set(G_OBJECT(mainbin[MMPLAYER_M_Q2].gst), "max-size-time", q_max_size_time * GST_SECOND, NULL);
}
- }
- else
- {
+ } else {
LOGE("Not supporting more then two elementary stream\n");
g_assert(1);
}
pad = gst_element_get_static_pad(sinkelement, padname);
- if (!pad)
- {
+ if (!pad) {
LOGW("failed to get pad(%s) from %s. retrying with [sink]\n",
padname, GST_ELEMENT_NAME(sinkelement));
pad = gst_element_get_static_pad(sinkelement, "sink");
- if (!pad)
- {
+ if (!pad) {
LOGE("failed to get pad(sink) from %s. \n",
GST_ELEMENT_NAME(sinkelement));
goto ERROR;
}
}
- /* to check the video/audio type set the proper flag*/
+ /* to check the video/audio type set the proper flag*/
const gchar *mime_type = NULL;
- {
- srccaps = gst_pad_query_caps(srcpad, NULL);
- if (!srccaps)
- goto ERROR;
-
- str = gst_caps_get_structure(srccaps, 0);
- if (!str)
- goto ERROR;
-
- mime_type = gst_structure_get_name(str);
- if (!mime_type)
- goto ERROR;
- }
+ srccaps = gst_pad_query_caps(srcpad, NULL);
+ if (!srccaps)
+ goto ERROR;
+ str = gst_caps_get_structure(srccaps, 0);
+ if (!str)
+ goto ERROR;
+ mime_type = gst_structure_get_name(str);
+ if (!mime_type)
+ goto ERROR;
/* link queue and decoder. so, it will be queue - decoder. */
- if (GST_PAD_LINK_OK != gst_pad_link(srcpad, pad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(srcpad, pad)) {
gst_object_unref(GST_OBJECT(pad));
LOGE("failed to link(%s) to pad(%s)\n", GST_ELEMENT_NAME(sinkelement), padname);
/* reconstitute supportable codec */
if (strstr(mime_type, "video"))
- {
player->can_support_codec ^= FOUND_PLUGIN_VIDEO;
- }
else if (strstr(mime_type, "audio"))
- {
player->can_support_codec ^= FOUND_PLUGIN_AUDIO;
- }
goto ERROR;
}
- if (strstr(mime_type, "video"))
- {
+ if (strstr(mime_type, "video")) {
player->videodec_linked = 1;
LOGI("player->videodec_linked set to 1\n");
- }
- else if (strstr(mime_type, "audio"))
- {
+ } else if (strstr(mime_type, "audio")) {
player->audiodec_linked = 1;
LOGI("player->auddiodec_linked set to 1\n");
}
srccaps = NULL;
}
- if (!MMPLAYER_IS_HTTP_PD(player))
- {
- if ((g_strrstr(klass, "Demux") && !g_strrstr(klass, "Metadata")) || (g_strrstr(klass, "Parser")))
- {
- if (MMPLAYER_IS_HTTP_STREAMING(player))
- {
+ if (!MMPLAYER_IS_HTTP_PD(player)) {
+ if ((g_strrstr(klass, "Demux") && !g_strrstr(klass, "Metadata")) || (g_strrstr(klass, "Parser"))) {
+ if (MMPLAYER_IS_HTTP_STREAMING(player)) {
gint64 dur_bytes = 0L;
muxed_buffer_type_e type = MUXED_BUFFER_TYPE_MEM_QUEUE;
- if (!mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst)
- {
+ if (!mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst) {
LOGD("creating http streaming buffering queue\n");
queue = gst_element_factory_make("queue2", "queue2");
- if (!queue)
- {
+ if (!queue) {
LOGE("failed to create buffering queue element\n");
goto ERROR;
}
- if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(queue, GST_STATE_READY))
- {
+ if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(queue, GST_STATE_READY)) {
LOGE("failed to set state READY to buffering queue\n");
goto ERROR;
}
- if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), queue))
- {
+ if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), queue)) {
LOGE("failed to add buffering queue\n");
goto ERROR;
}
qsinkpad = gst_element_get_static_pad(queue, "sink");
qsrcpad = gst_element_get_static_pad(queue, "src");
- if (GST_PAD_LINK_OK != gst_pad_link(srcpad, qsinkpad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(srcpad, qsinkpad)) {
LOGE("failed to link buffering queue\n");
goto ERROR;
}
mainbin[MMPLAYER_M_MUXED_S_BUFFER].id = MMPLAYER_M_MUXED_S_BUFFER;
mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst = queue;
- if (!MMPLAYER_IS_HTTP_LIVE_STREAMING(player))
- {
+ if (!MMPLAYER_IS_HTTP_LIVE_STREAMING(player)) {
if (!gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_SRC].gst, GST_FORMAT_BYTES, &dur_bytes))
LOGE("fail to get duration.\n");
}
/* NOTE : we cannot get any duration info from ts container in case of streaming */
- if (!g_strrstr(GST_ELEMENT_NAME(sinkelement), "mpegtsdemux"))
- {
+ if (!g_strrstr(GST_ELEMENT_NAME(sinkelement), "mpegtsdemux")) {
__mm_player_streaming_set_queue2(player->streamer,
queue,
TRUE,
}
/* if it is not decoder or */
/* in decoder case any of the video/audio still need to link*/
- if (!g_strrstr(klass, "Decoder"))
- {
-
+ if (!g_strrstr(klass, "Decoder")) {
pad = gst_element_get_static_pad(sinkelement, padname);
- if (!pad)
- {
+ if (!pad) {
LOGW("failed to get pad(%s) from %s. retrying with [sink]\n",
padname, GST_ELEMENT_NAME(sinkelement));
pad = gst_element_get_static_pad(sinkelement, "sink");
- if (!pad)
- {
+ if (!pad) {
LOGE("failed to get pad(sink) from %s. \n",
GST_ELEMENT_NAME(sinkelement));
goto ERROR;
}
}
- if (GST_PAD_LINK_OK != gst_pad_link(srcpad, pad))
- {
+ if (GST_PAD_LINK_OK != gst_pad_link(srcpad, pad)) {
gst_object_unref(GST_OBJECT(pad));
LOGE("failed to link(%s) to pad(%s)\n", GST_ELEMENT_NAME(sinkelement), padname);
goto ERROR;
gst_object_unref(GST_OBJECT(pad));
}
- for (;templlist != NULL; templlist = templlist->next)
- {
+ for (; templlist != NULL; templlist = templlist->next) {
padtemplate = templlist->data;
LOGD("director = [%d], presence = [%d]\n", padtemplate->direction, padtemplate->presence);
- if ( padtemplate->direction != GST_PAD_SRC ||
- padtemplate->presence == GST_PAD_REQUEST )
+ if (padtemplate->direction != GST_PAD_SRC ||
+ padtemplate->presence == GST_PAD_REQUEST)
continue;
- switch (padtemplate->presence)
- {
- case GST_PAD_ALWAYS:
+ switch (padtemplate->presence) {
+ case GST_PAD_ALWAYS:
{
GstPad *srcpad = gst_element_get_static_pad(sinkelement, "src");
GstCaps *caps = gst_pad_query_caps(srcpad, NULL);
/* Check whether caps has many types */
- if (!gst_caps_is_fixed(caps))
- {
+ if (!gst_caps_is_fixed(caps)) {
LOGD("always pad but, caps has many types");
MMPLAYER_LOG_GST_CAPS_TYPE(caps);
has_many_types = TRUE;
break;
}
- if (!__mmplayer_try_to_plug(player, srcpad, caps))
- {
+ if (!__mmplayer_try_to_plug(player, srcpad, caps)) {
gst_object_unref(GST_OBJECT(srcpad));
gst_caps_unref(GST_CAPS(caps));
break;
- case GST_PAD_SOMETIMES:
- has_dynamic_pads = TRUE;
+ case GST_PAD_SOMETIMES:
+ has_dynamic_pads = TRUE;
break;
- default:
- break;
+ default:
+ break;
}
}
/* check if player can do start continually */
MMPLAYER_CHECK_CMD_IF_EXIT(player);
- if (has_dynamic_pads)
- {
+ if (has_dynamic_pads) {
player->have_dynamic_pad = TRUE;
MMPLAYER_SIGNAL_CONNECT(player, sinkelement, MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "pad-added",
G_CALLBACK(__mmplayer_add_new_pad), player);
/* for streaming, more then one typefind will used for each elementary stream
* so this doesn't mean the whole pipeline completion
*/
- if (!MMPLAYER_IS_RTSP_STREAMING(player))
- {
+ if (!MMPLAYER_IS_RTSP_STREAMING(player)) {
MMPLAYER_SIGNAL_CONNECT(player, sinkelement, MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "no-more-pads",
G_CALLBACK(__mmplayer_pipeline_complete), player);
}
}
- if (has_many_types)
- {
+ if (has_many_types) {
GstPad *pad = NULL;
player->has_many_types = has_many_types;
/* check if player can do start continually */
MMPLAYER_CHECK_CMD_IF_EXIT(player);
- if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(sinkelement, GST_STATE_PAUSED))
- {
+ if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(sinkelement, GST_STATE_PAUSED)) {
LOGE("failed to set state PAUSED to %s\n", GST_ELEMENT_NAME(sinkelement));
goto ERROR;
}
- if (queue)
- {
- if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(queue, GST_STATE_PAUSED))
- {
+ if (queue) {
+ if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(queue, GST_STATE_PAUSED)) {
LOGE("failed to set state PAUSED to queue\n");
goto ERROR;
}
qsrcpad = NULL;
}
- if (parser)
- {
- if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(parser, GST_STATE_PAUSED))
- {
+ if (parser) {
+ if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(parser, GST_STATE_PAUSED)) {
LOGE("failed to set state PAUSED to queue\n");
goto ERROR;
}
ERROR:
- if (queue)
- {
+ if (queue) {
gst_object_unref(GST_OBJECT(qsrcpad));
/* NOTE : Trying to dispose element queue0, but it is in READY instead of the NULL state.
*/
gst_element_set_state(queue, GST_STATE_NULL);
/* And, it still has a parent "player".
- * You need to let the parent manage the object instead of unreffing the object directly.
- */
+ * You need to let the parent manage the object instead of unreffing the object directly.
+ */
gst_bin_remove(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), queue);
//gst_object_unref(queue);
if (srccaps)
gst_caps_unref(GST_CAPS(srccaps));
- return FALSE;
+ return FALSE;
}
static gboolean __mmplayer_feature_filter(GstPluginFeature *feature, gpointer data) // @
{
- const gchar *klass;
+ const gchar *klass;
/* we only care about element factories */
if (!GST_IS_ELEMENT_FACTORY(feature))
g_strrstr(klass, "Codec/Decoder") == NULL &&
g_strrstr(klass, "Depayloader") == NULL &&
g_strrstr(klass, "Parse") == NULL)
- {
return FALSE;
- }
- return TRUE;
+ return TRUE;
}
return;
LOGD("name=%s\n", name);
- if (!__mmplayer_try_to_plug(player, pad, caps))
- {
+ if (!__mmplayer_try_to_plug(player, pad, caps)) {
LOGE("failed to autoplug for type(%s)\n", name);
gst_caps_unref(caps);
return;
/* set unlinked mime type for downloadable codec */
- if (g_str_has_prefix(stream_type, "video/"))
- {
- if (g_str_has_prefix(stream_type, "video/mpeg"))
- {
+ if (g_str_has_prefix(stream_type, "video/")) {
+ if (g_str_has_prefix(stream_type, "video/mpeg")) {
gst_structure_get_int(str, MM_PLAYER_MPEG_VNAME, &version);
version_field = MM_PLAYER_MPEG_VNAME;
- }
- else if (g_str_has_prefix(stream_type, "video/x-wmv"))
- {
+ } else if (g_str_has_prefix(stream_type, "video/x-wmv")) {
gst_structure_get_int(str, MM_PLAYER_WMV_VNAME, &version);
version_field = MM_PLAYER_WMV_VNAME;
- }
- else if (g_str_has_prefix(stream_type, "video/x-divx"))
- {
+ } else if (g_str_has_prefix(stream_type, "video/x-divx")) {
gst_structure_get_int(str, MM_PLAYER_DIVX_VNAME, &version);
version_field = MM_PLAYER_DIVX_VNAME;
}
if (version)
- {
player->unlinked_video_mime = g_strdup_printf("%s, %s=%d", stream_type, version_field, version);
- }
else
- {
player->unlinked_video_mime = g_strdup_printf("%s", stream_type);
- }
- }
- else if (g_str_has_prefix(stream_type, "audio/"))
- {
- if (g_str_has_prefix(stream_type, "audio/mpeg")) // mp3 or aac
- {
+ } else if (g_str_has_prefix(stream_type, "audio/")) {
+ if (g_str_has_prefix(stream_type, "audio/mpeg")) {
+ // mp3 or aac
gst_structure_get_int(str, MM_PLAYER_MPEG_VNAME, &version);
version_field = MM_PLAYER_MPEG_VNAME;
- }
- else if (g_str_has_prefix(stream_type, "audio/x-wma"))
- {
+ } else if (g_str_has_prefix(stream_type, "audio/x-wma")) {
gst_structure_get_int(str, MM_PLAYER_WMA_VNAME, &version);
version_field = MM_PLAYER_WMA_VNAME;
}
if (version)
- {
player->unlinked_audio_mime = g_strdup_printf("%s, %s=%d", stream_type, version_field, version);
- }
else
- {
player->unlinked_audio_mime = g_strdup_printf("%s", stream_type);
- }
}
MMPLAYER_FLEAVE();
MMPLAYER_RETURN_IF_FAIL(player);
MMPLAYER_RETURN_IF_FAIL(pad);
- GST_OBJECT_LOCK(pad);
+ GST_OBJECT_LOCK(pad);
if ((caps = gst_pad_get_current_caps(pad)))
gst_caps_ref(caps);
GST_OBJECT_UNLOCK(pad);
- if (NULL == caps)
- {
+ if (NULL == caps) {
caps = gst_pad_query_caps(pad, NULL);
if (!caps) return;
}
/* Note : If the stream is the subtitle, we try not to play it. Just close the demuxer subtitle pad.
* If want to play it, remove this code.
*/
- if (g_strrstr(name, "application"))
- {
- if (g_strrstr(name, "x-id3") || g_strrstr(name, "x-apetag"))
- {
+ if (g_strrstr(name, "application")) {
+ if (g_strrstr(name, "x-id3") || g_strrstr(name, "x-apetag")) {
/* If id3/ape tag comes, keep going */
LOGD("application mime exception : id3/ape tag");
- }
- else
- {
+ } else {
/* Otherwise, we assume that this stream is subtile. */
LOGD(" application mime type pad is closed.");
return;
}
- }
- else if (g_strrstr(name, "audio"))
- {
+ } else if (g_strrstr(name, "audio")) {
gint samplerate = 0, channels = 0;
- if (player->audiodec_linked)
- {
+ if (player->audiodec_linked) {
gst_caps_unref(caps);
LOGD("multi tracks. skip to plug");
return;
mm_attrs_set_int_by_name(player->attrs, "content_audio_channels", channels);
LOGD("audio samplerate : %d channels : %d", samplerate, channels);
- }
- else if (g_strrstr(name, "video"))
- {
+ } else if (g_strrstr(name, "video")) {
gint stype;
mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &stype);
/* don't make video because of not required */
- if (stype == MM_DISPLAY_SURFACE_NULL || stype == MM_DISPLAY_SURFACE_REMOTE)
- {
+ if (stype == MM_DISPLAY_SURFACE_NULL || stype == MM_DISPLAY_SURFACE_REMOTE) {
LOGD("no video because it's not required");
return;
}
player->v_stream_caps = gst_caps_copy(caps); //if needed, video caps is required when videobin is created
}
- if (!__mmplayer_try_to_plug(player, pad, caps))
- {
+ if (!__mmplayer_try_to_plug(player, pad, caps)) {
LOGE("failed to autoplug for type(%s)", name);
__mmplayer_set_unlinked_mime_type(player, caps);
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("fail to get attributes.");
return FALSE;
}
/* get sound_extraction property */
mm_attrs_get_int_by_name(attrs, "pcm_extraction", &sound_extraction);
- if (!sound_extraction)
- {
+ if (!sound_extraction) {
LOGD("checking pcm extraction mode : %d ", sound_extraction);
return FALSE;
}
}
static gboolean
-__mmplayer_handle_streaming_error (mm_player_t* player, GstMessage * message)
+__mmplayer_handle_streaming_error(mm_player_t* player, GstMessage * message)
{
LOGD("\n");
MMMessageParamType msg_param;
if (!gst_structure_get_uint(s, "error_id", &error_id))
error_id = MMPLAYER_STREAMING_ERROR_NONE;
- switch (error_id)
- {
- case MMPLAYER_STREAMING_ERROR_UNSUPPORTED_AUDIO:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_AUDIO;
- break;
- case MMPLAYER_STREAMING_ERROR_UNSUPPORTED_VIDEO:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_VIDEO;
- break;
- case MMPLAYER_STREAMING_ERROR_CONNECTION_FAIL:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_CONNECTION_FAIL;
- break;
- case MMPLAYER_STREAMING_ERROR_DNS_FAIL:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_DNS_FAIL;
- break;
- case MMPLAYER_STREAMING_ERROR_SERVER_DISCONNECTED:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_SERVER_DISCONNECTED;
- break;
- case MMPLAYER_STREAMING_ERROR_BAD_SERVER:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_BAD_SERVER;
- break;
- case MMPLAYER_STREAMING_ERROR_INVALID_PROTOCOL:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_INVALID_PROTOCOL;
- break;
- case MMPLAYER_STREAMING_ERROR_INVALID_URL:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_INVALID_URL;
- break;
- case MMPLAYER_STREAMING_ERROR_UNEXPECTED_MSG:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_UNEXPECTED_MSG;
- break;
- case MMPLAYER_STREAMING_ERROR_OUT_OF_MEMORIES:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_OUT_OF_MEMORIES;
- break;
- case MMPLAYER_STREAMING_ERROR_RTSP_TIMEOUT:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_RTSP_TIMEOUT;
- break;
- case MMPLAYER_STREAMING_ERROR_BAD_REQUEST:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_BAD_REQUEST;
- break;
- case MMPLAYER_STREAMING_ERROR_NOT_AUTHORIZED:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_NOT_AUTHORIZED;
- break;
- case MMPLAYER_STREAMING_ERROR_PAYMENT_REQUIRED:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_PAYMENT_REQUIRED;
- break;
- case MMPLAYER_STREAMING_ERROR_FORBIDDEN:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_FORBIDDEN;
- break;
- case MMPLAYER_STREAMING_ERROR_CONTENT_NOT_FOUND:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_CONTENT_NOT_FOUND;
- break;
- case MMPLAYER_STREAMING_ERROR_METHOD_NOT_ALLOWED:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_METHOD_NOT_ALLOWED;
- break;
- case MMPLAYER_STREAMING_ERROR_NOT_ACCEPTABLE:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_NOT_ACCEPTABLE;
- break;
- case MMPLAYER_STREAMING_ERROR_PROXY_AUTHENTICATION_REQUIRED:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_PROXY_AUTHENTICATION_REQUIRED;
- break;
- case MMPLAYER_STREAMING_ERROR_SERVER_TIMEOUT:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_SERVER_TIMEOUT;
- break;
- case MMPLAYER_STREAMING_ERROR_GONE:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_GONE;
- break;
- case MMPLAYER_STREAMING_ERROR_LENGTH_REQUIRED:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_LENGTH_REQUIRED;
- break;
- case MMPLAYER_STREAMING_ERROR_PRECONDITION_FAILED:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_PRECONDITION_FAILED;
- break;
- case MMPLAYER_STREAMING_ERROR_REQUEST_ENTITY_TOO_LARGE:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_REQUEST_ENTITY_TOO_LARGE;
- break;
- case MMPLAYER_STREAMING_ERROR_REQUEST_URI_TOO_LARGE:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_REQUEST_URI_TOO_LARGE;
- break;
- case MMPLAYER_STREAMING_ERROR_UNSUPPORTED_MEDIA_TYPE:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_MEDIA_TYPE;
- break;
- case MMPLAYER_STREAMING_ERROR_PARAMETER_NOT_UNDERSTOOD:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_PARAMETER_NOT_UNDERSTOOD;
- break;
- case MMPLAYER_STREAMING_ERROR_CONFERENCE_NOT_FOUND:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_CONFERENCE_NOT_FOUND;
- break;
- case MMPLAYER_STREAMING_ERROR_NOT_ENOUGH_BANDWIDTH:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_NOT_ENOUGH_BANDWIDTH;
- break;
- case MMPLAYER_STREAMING_ERROR_NO_SESSION_ID:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_NO_SESSION_ID;
- break;
- case MMPLAYER_STREAMING_ERROR_METHOD_NOT_VALID_IN_THIS_STATE:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_METHOD_NOT_VALID_IN_THIS_STATE;
- break;
- case MMPLAYER_STREAMING_ERROR_HEADER_FIELD_NOT_VALID_FOR_SOURCE:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_HEADER_FIELD_NOT_VALID_FOR_SOURCE;
- break;
- case MMPLAYER_STREAMING_ERROR_INVALID_RANGE:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_INVALID_RANGE;
- break;
- case MMPLAYER_STREAMING_ERROR_PARAMETER_IS_READONLY:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_PARAMETER_IS_READONLY;
- break;
- case MMPLAYER_STREAMING_ERROR_AGGREGATE_OP_NOT_ALLOWED:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_AGGREGATE_OP_NOT_ALLOWED;
- break;
- case MMPLAYER_STREAMING_ERROR_ONLY_AGGREGATE_OP_ALLOWED:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_ONLY_AGGREGATE_OP_ALLOWED;
- break;
- case MMPLAYER_STREAMING_ERROR_BAD_TRANSPORT:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_BAD_TRANSPORT;
- break;
- case MMPLAYER_STREAMING_ERROR_DESTINATION_UNREACHABLE:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_DESTINATION_UNREACHABLE;
- break;
- case MMPLAYER_STREAMING_ERROR_INTERNAL_SERVER_ERROR:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_INTERNAL_SERVER_ERROR;
- break;
- case MMPLAYER_STREAMING_ERROR_NOT_IMPLEMENTED:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_NOT_IMPLEMENTED;
- break;
- case MMPLAYER_STREAMING_ERROR_BAD_GATEWAY:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_BAD_GATEWAY;
- break;
- case MMPLAYER_STREAMING_ERROR_SERVICE_UNAVAILABLE:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_SERVICE_UNAVAILABLE;
- break;
- case MMPLAYER_STREAMING_ERROR_GATEWAY_TIME_OUT:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_GATEWAY_TIME_OUT;
- break;
- case MMPLAYER_STREAMING_ERROR_RTSP_VERSION_NOT_SUPPORTED:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_RTSP_VERSION_NOT_SUPPORTED;
- break;
- case MMPLAYER_STREAMING_ERROR_OPTION_NOT_SUPPORTED:
- msg_param.code = MM_ERROR_PLAYER_STREAMING_OPTION_NOT_SUPPORTED;
- break;
- default:
- {
- MMPLAYER_FREEIF(s);
- return MM_ERROR_PLAYER_STREAMING_FAIL;
- }
+ switch (error_id) {
+ case MMPLAYER_STREAMING_ERROR_UNSUPPORTED_AUDIO:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_AUDIO;
+ break;
+ case MMPLAYER_STREAMING_ERROR_UNSUPPORTED_VIDEO:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_VIDEO;
+ break;
+ case MMPLAYER_STREAMING_ERROR_CONNECTION_FAIL:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_CONNECTION_FAIL;
+ break;
+ case MMPLAYER_STREAMING_ERROR_DNS_FAIL:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_DNS_FAIL;
+ break;
+ case MMPLAYER_STREAMING_ERROR_SERVER_DISCONNECTED:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_SERVER_DISCONNECTED;
+ break;
+ case MMPLAYER_STREAMING_ERROR_BAD_SERVER:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_BAD_SERVER;
+ break;
+ case MMPLAYER_STREAMING_ERROR_INVALID_PROTOCOL:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_INVALID_PROTOCOL;
+ break;
+ case MMPLAYER_STREAMING_ERROR_INVALID_URL:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_INVALID_URL;
+ break;
+ case MMPLAYER_STREAMING_ERROR_UNEXPECTED_MSG:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_UNEXPECTED_MSG;
+ break;
+ case MMPLAYER_STREAMING_ERROR_OUT_OF_MEMORIES:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_OUT_OF_MEMORIES;
+ break;
+ case MMPLAYER_STREAMING_ERROR_RTSP_TIMEOUT:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_RTSP_TIMEOUT;
+ break;
+ case MMPLAYER_STREAMING_ERROR_BAD_REQUEST:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_BAD_REQUEST;
+ break;
+ case MMPLAYER_STREAMING_ERROR_NOT_AUTHORIZED:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_NOT_AUTHORIZED;
+ break;
+ case MMPLAYER_STREAMING_ERROR_PAYMENT_REQUIRED:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_PAYMENT_REQUIRED;
+ break;
+ case MMPLAYER_STREAMING_ERROR_FORBIDDEN:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_FORBIDDEN;
+ break;
+ case MMPLAYER_STREAMING_ERROR_CONTENT_NOT_FOUND:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_CONTENT_NOT_FOUND;
+ break;
+ case MMPLAYER_STREAMING_ERROR_METHOD_NOT_ALLOWED:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_METHOD_NOT_ALLOWED;
+ break;
+ case MMPLAYER_STREAMING_ERROR_NOT_ACCEPTABLE:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_NOT_ACCEPTABLE;
+ break;
+ case MMPLAYER_STREAMING_ERROR_PROXY_AUTHENTICATION_REQUIRED:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_PROXY_AUTHENTICATION_REQUIRED;
+ break;
+ case MMPLAYER_STREAMING_ERROR_SERVER_TIMEOUT:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_SERVER_TIMEOUT;
+ break;
+ case MMPLAYER_STREAMING_ERROR_GONE:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_GONE;
+ break;
+ case MMPLAYER_STREAMING_ERROR_LENGTH_REQUIRED:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_LENGTH_REQUIRED;
+ break;
+ case MMPLAYER_STREAMING_ERROR_PRECONDITION_FAILED:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_PRECONDITION_FAILED;
+ break;
+ case MMPLAYER_STREAMING_ERROR_REQUEST_ENTITY_TOO_LARGE:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_REQUEST_ENTITY_TOO_LARGE;
+ break;
+ case MMPLAYER_STREAMING_ERROR_REQUEST_URI_TOO_LARGE:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_REQUEST_URI_TOO_LARGE;
+ break;
+ case MMPLAYER_STREAMING_ERROR_UNSUPPORTED_MEDIA_TYPE:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_MEDIA_TYPE;
+ break;
+ case MMPLAYER_STREAMING_ERROR_PARAMETER_NOT_UNDERSTOOD:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_PARAMETER_NOT_UNDERSTOOD;
+ break;
+ case MMPLAYER_STREAMING_ERROR_CONFERENCE_NOT_FOUND:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_CONFERENCE_NOT_FOUND;
+ break;
+ case MMPLAYER_STREAMING_ERROR_NOT_ENOUGH_BANDWIDTH:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_NOT_ENOUGH_BANDWIDTH;
+ break;
+ case MMPLAYER_STREAMING_ERROR_NO_SESSION_ID:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_NO_SESSION_ID;
+ break;
+ case MMPLAYER_STREAMING_ERROR_METHOD_NOT_VALID_IN_THIS_STATE:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_METHOD_NOT_VALID_IN_THIS_STATE;
+ break;
+ case MMPLAYER_STREAMING_ERROR_HEADER_FIELD_NOT_VALID_FOR_SOURCE:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_HEADER_FIELD_NOT_VALID_FOR_SOURCE;
+ break;
+ case MMPLAYER_STREAMING_ERROR_INVALID_RANGE:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_INVALID_RANGE;
+ break;
+ case MMPLAYER_STREAMING_ERROR_PARAMETER_IS_READONLY:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_PARAMETER_IS_READONLY;
+ break;
+ case MMPLAYER_STREAMING_ERROR_AGGREGATE_OP_NOT_ALLOWED:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_AGGREGATE_OP_NOT_ALLOWED;
+ break;
+ case MMPLAYER_STREAMING_ERROR_ONLY_AGGREGATE_OP_ALLOWED:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_ONLY_AGGREGATE_OP_ALLOWED;
+ break;
+ case MMPLAYER_STREAMING_ERROR_BAD_TRANSPORT:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_BAD_TRANSPORT;
+ break;
+ case MMPLAYER_STREAMING_ERROR_DESTINATION_UNREACHABLE:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_DESTINATION_UNREACHABLE;
+ break;
+ case MMPLAYER_STREAMING_ERROR_INTERNAL_SERVER_ERROR:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_INTERNAL_SERVER_ERROR;
+ break;
+ case MMPLAYER_STREAMING_ERROR_NOT_IMPLEMENTED:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_NOT_IMPLEMENTED;
+ break;
+ case MMPLAYER_STREAMING_ERROR_BAD_GATEWAY:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_BAD_GATEWAY;
+ break;
+ case MMPLAYER_STREAMING_ERROR_SERVICE_UNAVAILABLE:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_SERVICE_UNAVAILABLE;
+ break;
+ case MMPLAYER_STREAMING_ERROR_GATEWAY_TIME_OUT:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_GATEWAY_TIME_OUT;
+ break;
+ case MMPLAYER_STREAMING_ERROR_RTSP_VERSION_NOT_SUPPORTED:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_RTSP_VERSION_NOT_SUPPORTED;
+ break;
+ case MMPLAYER_STREAMING_ERROR_OPTION_NOT_SUPPORTED:
+ msg_param.code = MM_ERROR_PLAYER_STREAMING_OPTION_NOT_SUPPORTED;
+ break;
+ default:
+ {
+ MMPLAYER_FREEIF(s);
+ return MM_ERROR_PLAYER_STREAMING_FAIL;
+ }
}
error_string = g_strdup(gst_structure_get_string(s, "error_string"));
if (error_string)
msg_param.data = (void *) error_string;
- if (message->src)
- {
+ if (message->src) {
msg_src_element = GST_ELEMENT_NAME(GST_ELEMENT_CAST(message->src));
LOGE("-Msg src : [%s] Code : [%x] Error : [%s] \n",
}
/* post error to application */
- if (!player->msg_posted)
- {
+ if (!player->msg_posted) {
MMPLAYER_POST_MSG(player, MM_MESSAGE_ERROR, &msg_param);
/* don't post more if one was sent already */
player->msg_posted = TRUE;
- }
- else
- {
+ } else
LOGD("skip error post because it's sent already.\n");
- }
MMPLAYER_FREEIF(s);
MMPLAYER_FLEAVE();
/* post now if delay is zero */
- if (delay_in_ms == 0 || player->set_mode.pcm_extraction)
- {
+ if (delay_in_ms == 0 || player->set_mode.pcm_extraction) {
LOGD("eos delay is zero. posting EOS now\n");
MMPLAYER_POST_MSG(player, MM_MESSAGE_END_OF_STREAM, NULL);
LOGD("global default context = %p, eos timer id = %d", player->context.global_default, player->eos_timer);
/* check timer is valid. if not, send EOS now */
- if (player->eos_timer == 0)
- {
+ if (player->eos_timer == 0) {
LOGW("creating timer for delayed EOS has failed. sending EOS now\n");
MMPLAYER_POST_MSG(player, MM_MESSAGE_END_OF_STREAM, NULL);
}
{
MMPLAYER_RETURN_IF_FAIL(player);
- if (player->eos_timer)
- {
+ if (player->eos_timer) {
LOGD("cancel eos timer");
__mmplayer_remove_g_source_from_context(player->context.global_default, player->eos_timer);
player->eos_timer = 0;
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- if (player->play_count > 1)
- {
+ if (player->play_count > 1) {
gint ret_value = 0;
ret_value = __gst_set_position(player, MM_PLAYER_POS_FORMAT_TIME, 0, TRUE);
- if (ret_value == MM_ERROR_NONE)
- {
+ if (ret_value == MM_ERROR_NONE) {
MMHandleType attrs = 0;
attrs = MMPLAYER_GET_ATTRS(player);
mm_attrs_set_int_by_name(attrs, "profile_play_count", player->play_count);
mmf_attrs_commit(attrs);
- }
- else
- {
+ } else
LOGE("seeking to 0 failed in repeat play");
- }
- }
- else
- {
+ } else
/* posting eos */
MMPLAYER_POST_MSG(player, MM_MESSAGE_END_OF_STREAM, NULL);
- }
/* we are returning FALSE as we need only one posting */
return FALSE;
if (!name)
goto ERROR;
- if (strstr(name, "video"))
- {
- if (player->videodec_linked)
- {
+ if (strstr(name, "video")) {
+ if (player->videodec_linked) {
LOGI("Video decoder already linked\n");
return FALSE;
}
}
- if (strstr(name, "audio"))
- {
- if (player->audiodec_linked)
- {
+ if (strstr(name, "audio")) {
+ if (player->audiodec_linked) {
LOGI("Audio decoder already linked\n");
return FALSE;
}
if (!name)
goto ERROR;
- if (strstr(name, "video"))
- {
- if (player->videosink_linked)
- {
+ if (strstr(name, "video")) {
+ if (player->videosink_linked) {
LOGI("Video Sink already linked\n");
return FALSE;
}
}
- if (strstr(name, "audio"))
- {
- if (player->audiosink_linked)
- {
+ if (strstr(name, "audio")) {
+ if (player->audiosink_linked) {
LOGI("Audio Sink already linked\n");
return FALSE;
}
}
- if (strstr(name, "text"))
- {
- if (player->textsink_linked)
- {
+ if (strstr(name, "text")) {
+ if (player->textsink_linked) {
LOGI("Text Sink already linked\n");
return FALSE;
}
MMPLAYER_FLEAVE();
+ //return (!player->videosink_linked || !player->audiosink_linked);
return TRUE;
- //return(!player->videosink_linked || !player->audiosink_linked);
ERROR:
if (srccaps)
event2 = gst_event_copy((const GstEvent *)event);
sinks = player->sink_elements;
- while (sinks)
- {
+ while (sinks) {
GstElement *sink = GST_ELEMENT_CAST(sinks->data);
- if (GST_IS_ELEMENT(sink))
- {
+ if (GST_IS_ELEMENT(sink)) {
/* keep ref to the event */
gst_event_ref(event);
- if ((res = gst_element_send_event(sink, event)))
- {
+ if ((res = gst_element_send_event(sink, event))) {
LOGD("sending event[%s] to sink element [%s] success!\n",
GST_EVENT_TYPE_NAME(event), GST_ELEMENT_NAME(sink));
/* rtsp case, asyn_done is not called after seek during pause state */
- if (MMPLAYER_IS_RTSP_STREAMING(player))
- {
- if (strstr(GST_EVENT_TYPE_NAME(event), "seek"))
- {
- if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PAUSED)
- {
+ if (MMPLAYER_IS_RTSP_STREAMING(player)) {
+ if (strstr(GST_EVENT_TYPE_NAME(event), "seek")) {
+ if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PAUSED) {
LOGD("RTSP seek completed, after pause state..\n");
player->doing_seek = FALSE;
MMPLAYER_POST_MSG(player, MM_MESSAGE_SEEK_COMPLETED, NULL);
}
}
- if (MMPLAYER_IS_MS_BUFF_SRC(player))
- {
+ if (MMPLAYER_IS_MS_BUFF_SRC(player)) {
sinks = g_list_next(sinks);
continue;
- }
- else
+ } else
break;
}
/* Note : Textbin is not linked to the video or audio bin.
* It needs to send the event to the text sink seperatelly.
*/
- if (player->play_subtitle && !player->use_textoverlay)
- {
+ if (player->play_subtitle && !player->use_textoverlay) {
GstElement *text_sink = GST_ELEMENT_CAST(player->pipeline->textbin[MMPLAYER_T_FAKE_SINK].gst);
- if (GST_IS_ELEMENT(text_sink))
- {
+ if (GST_IS_ELEMENT(text_sink)) {
/* keep ref to the event */
gst_event_ref(event2);
if ((res = gst_element_send_event(text_sink, event2)))
- {
LOGD("sending event[%s] to subtitle sink element [%s] success!\n",
GST_EVENT_TYPE_NAME(event2), GST_ELEMENT_NAME(text_sink));
- }
else
- {
LOGE("sending event[%s] to subtitle sink element [%s] failed!\n",
GST_EVENT_TYPE_NAME(event2), GST_ELEMENT_NAME(text_sink));
- }
gst_event_unref(event2);
}
LOGD("release signals type : %d", type);
- if ((type < MM_PLAYER_SIGNAL_TYPE_AUTOPLUG) || (type >= MM_PLAYER_SIGNAL_TYPE_ALL))
- {
+ if ((type < MM_PLAYER_SIGNAL_TYPE_AUTOPLUG) || (type >= MM_PLAYER_SIGNAL_TYPE_ALL)) {
__mmplayer_release_signal_connection(player, MM_PLAYER_SIGNAL_TYPE_AUTOPLUG);
__mmplayer_release_signal_connection(player, MM_PLAYER_SIGNAL_TYPE_VIDEOBIN);
__mmplayer_release_signal_connection(player, MM_PLAYER_SIGNAL_TYPE_AUDIOBIN);
sig_list = player->signals[type];
- for (; sig_list; sig_list = sig_list->next)
- {
+ for (; sig_list; sig_list = sig_list->next) {
item = sig_list->data;
- if (item && item->obj && GST_IS_ELEMENT(item->obj))
- {
+ if (item && item->obj && GST_IS_ELEMENT(item->obj)) {
if (g_signal_handler_is_connected(item->obj, item->sig))
- {
g_signal_handler_disconnect(item->obj, item->sig);
- }
}
MMPLAYER_FREEIF(item);
player = MM_PLAYER_CAST(handle);
- if (surface_type < MM_DISPLAY_SURFACE_OVERLAY || surface_type >= MM_DISPLAY_SURFACE_NUM)
- {
+ if (surface_type < MM_DISPLAY_SURFACE_OVERLAY || surface_type >= MM_DISPLAY_SURFACE_NUM) {
LOGE("Not support this surface type(%d) for changing vidoesink", surface_type);
MMPLAYER_FLEAVE();
return MM_ERROR_INVALID_ARGUMENT;
}
/* load previous attributes */
- if (player->attrs)
- {
+ if (player->attrs) {
mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &prev_display_surface_type);
mm_attrs_get_data_by_name(player->attrs, "display_overlay", &prev_display_overlay);
LOGD("[0: Video surface, 1: EVAS surface] previous surface type(%d), new surface type(%d)", prev_display_surface_type, surface_type);
- if (prev_display_surface_type == surface_type)
- {
+ if (prev_display_surface_type == surface_type) {
LOGD("incoming display surface type is same as previous one, do nothing..");
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
- }
- else
- {
+ } else {
LOGE("failed to load attributes");
MMPLAYER_FLEAVE();
return MM_ERROR_PLAYER_INTERNAL;
/* check videosink element is created */
if (!player->pipeline || !player->pipeline->videobin ||
- !player->pipeline->videobin[MMPLAYER_V_SINK].gst)
- {
+ !player->pipeline->videobin[MMPLAYER_V_SINK].gst) {
LOGD("videosink element is not yet ready");
/* videobin is not created yet, so we just set attributes related to display surface */
LOGD("store display attribute for given surface type(%d)", surface_type);
mm_attrs_set_int_by_name(player->attrs, "display_surface_type", surface_type);
mm_attrs_set_data_by_name(player->attrs, "display_overlay", display_overlay, sizeof(display_overlay));
- if (mmf_attrs_commit(player->attrs))
- {
+ if (mmf_attrs_commit(player->attrs)) {
LOGE("failed to commit attribute");
MMPLAYER_FLEAVE();
return MM_ERROR_PLAYER_INTERNAL;
}
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
- }
- else
- {
+ } else {
/* get player command status */
- if (!(player->cmd == MMPLAYER_COMMAND_START || player->cmd == MMPLAYER_COMMAND_RESUME || player->cmd == MMPLAYER_COMMAND_PAUSE))
- {
- LOGE("invalid player command status(%d), __mmplayer_do_change_videosink() is only available with START/RESUME/PAUSE command",player->cmd);
+ if (!(player->cmd == MMPLAYER_COMMAND_START || player->cmd == MMPLAYER_COMMAND_RESUME || player->cmd == MMPLAYER_COMMAND_PAUSE)) {
+ LOGE("invalid player command status(%d), __mmplayer_do_change_videosink() is only available with START/RESUME/PAUSE command", player->cmd);
MMPLAYER_FLEAVE();
return MM_ERROR_PLAYER_INVALID_STATE;
}
cur_videosink_name = GST_ELEMENT_NAME(player->pipeline->videobin[MMPLAYER_V_SINK].gst);
/* surface change */
- for (i = 0 ; i < num_of_dec ; i++)
- {
+ for (i = 0 ; i < num_of_dec ; i++) {
if (player->pipeline->mainbin &&
- player->pipeline->mainbin[MMPLAYER_M_DEC1+i].gst)
- {
+ player->pipeline->mainbin[MMPLAYER_M_DEC1+i].gst) {
GstElementFactory *decfactory;
decfactory = gst_element_get_factory(player->pipeline->mainbin[MMPLAYER_M_DEC1+i].gst);
klass = gst_element_factory_get_metadata(decfactory, GST_ELEMENT_METADATA_KLASS);
- if ((g_strrstr(klass, "Codec/Decoder/Video")))
- {
- if (!strncmp(cur_videosink_name, "x", 1) && (surface_type == MM_DISPLAY_SURFACE_EVAS))
- {
+ if ((g_strrstr(klass, "Codec/Decoder/Video"))) {
+ if (!strncmp(cur_videosink_name, "x", 1) && (surface_type == MM_DISPLAY_SURFACE_EVAS)) {
ret = __mmplayer_do_change_videosink(player, MMPLAYER_M_DEC1+i, player->ini.videosink_element_evas, surface_type, display_overlay);
- if (ret)
- {
+ if (ret) {
goto ERROR_CASE;
- }
- else
- {
- LOGW("success to changing display surface(%d)",surface_type);
+ } else {
+ LOGW("success to changing display surface(%d)", surface_type);
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
- }
- else if (!strncmp(cur_videosink_name, "evas", 4) && (surface_type == MM_DISPLAY_SURFACE_OVERLAY))
- {
+ } else if (!strncmp(cur_videosink_name, "evas", 4) && (surface_type == MM_DISPLAY_SURFACE_OVERLAY)) {
ret = __mmplayer_do_change_videosink(player, MMPLAYER_M_DEC1+i, player->ini.videosink_element_overlay, surface_type, display_overlay);
- if (ret)
- {
+ if (ret) {
goto ERROR_CASE;
- }
- else
- {
- LOGW("success to changing display surface(%d)",surface_type);
+ } else {
+ LOGW("success to changing display surface(%d)", surface_type);
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
- }
- else
- {
- LOGE("invalid incoming surface type(%d) and current videosink_name(%s) for changing display surface",surface_type, cur_videosink_name);
+ } else {
+ LOGE("invalid incoming surface type(%d) and current videosink_name(%s) for changing display surface", surface_type, cur_videosink_name);
ret = MM_ERROR_PLAYER_INTERNAL;
goto ERROR_CASE;
}
/* rollback to previous attributes */
mm_attrs_set_int_by_name(player->attrs, "display_surface_type", prev_display_surface_type);
mm_attrs_set_data_by_name(player->attrs, "display_overlay", prev_display_overlay, sizeof(void*));
- if (mmf_attrs_commit(player->attrs))
- {
+ if (mmf_attrs_commit(player->attrs)) {
LOGE("failed to commit attributes to rollback");
MMPLAYER_FLEAVE();
return MM_ERROR_PLAYER_INTERNAL;
/* get information whether if audiobin is created */
if (!player->pipeline->audiobin ||
- !player->pipeline->audiobin[MMPLAYER_A_SINK].gst)
- {
+ !player->pipeline->audiobin[MMPLAYER_A_SINK].gst) {
LOGW("audiobin is null, this video content may not have audio data");
is_audiobin_created = FALSE;
}
/* get src pad of decoder and block it */
src_pad_dec = gst_element_get_static_pad(GST_ELEMENT(player->pipeline->mainbin[dec_index].gst), "src");
- if (!src_pad_dec)
- {
+ if (!src_pad_dec) {
LOGE("failed to get src pad from decode in mainbin");
return MM_ERROR_PLAYER_INTERNAL;
}
- if (!player->doing_seek && previous_state == MM_PLAYER_STATE_PLAYING)
- {
+ if (!player->doing_seek && previous_state == MM_PLAYER_STATE_PLAYING) {
LOGW("trying to block pad(video)");
// if (!gst_pad_set_blocked(src_pad_dec, TRUE))
gst_pad_add_probe(src_pad_dec, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
NULL, NULL, NULL);
-
{
LOGE("failed to set block pad(video)");
return MM_ERROR_PLAYER_INTERNAL;
}
LOGW("pad is blocked(video)");
- }
- else
- {
+ } else {
/* no data flows, so no need to do pad_block */
- if (player->doing_seek) {
+ if (player->doing_seek)
LOGW("not completed seek(%d), do nothing", player->doing_seek);
- }
+
LOGD("MM_PLAYER_STATE is not PLAYING now, skip pad-block(TRUE)");
}
/* remove pad */
if (!gst_element_remove_pad(player->pipeline->videobin[MMPLAYER_V_BIN].gst,
- GST_PAD_CAST(GST_GHOST_PAD(player->ghost_pad_for_videobin))))
- {
+ GST_PAD_CAST(GST_GHOST_PAD(player->ghost_pad_for_videobin)))) {
LOGE("failed to remove previous ghost_pad for videobin");
return MM_ERROR_PLAYER_INTERNAL;
}
/* change state of videobin to NULL */
LOGD("setting [%s] state to : %d", GST_ELEMENT_NAME(player->pipeline->videobin[MMPLAYER_V_BIN].gst), GST_STATE_NULL);
ret = gst_element_set_state(player->pipeline->videobin[MMPLAYER_V_BIN].gst, GST_STATE_NULL);
- if (ret != GST_STATE_CHANGE_SUCCESS)
- {
+ if (ret != GST_STATE_CHANGE_SUCCESS) {
LOGE("failed to change state of videobin to NULL");
return MM_ERROR_PLAYER_INTERNAL;
}
/* unlink between decoder and videobin and remove previous videosink from videobin */
- GST_ELEMENT_UNLINK(GST_ELEMENT(player->pipeline->mainbin[dec_index].gst),GST_ELEMENT(player->pipeline->videobin[MMPLAYER_V_BIN].gst));
- if (!gst_bin_remove(GST_BIN(player->pipeline->videobin[MMPLAYER_V_BIN].gst), GST_ELEMENT(player->pipeline->videobin[MMPLAYER_V_SINK].gst)))
- {
+ GST_ELEMENT_UNLINK(GST_ELEMENT(player->pipeline->mainbin[dec_index].gst), GST_ELEMENT(player->pipeline->videobin[MMPLAYER_V_BIN].gst));
+ if (!gst_bin_remove(GST_BIN(player->pipeline->videobin[MMPLAYER_V_BIN].gst), GST_ELEMENT(player->pipeline->videobin[MMPLAYER_V_SINK].gst))) {
LOGE("failed to remove former videosink from videobin");
return MM_ERROR_PLAYER_INTERNAL;
}
/* create a new videosink and add it to videobin */
player->pipeline->videobin[MMPLAYER_V_SINK].gst = gst_element_factory_make(videosink_element, videosink_element);
- if (!player->pipeline->videobin[MMPLAYER_V_SINK].gst)
- {
+ if (!player->pipeline->videobin[MMPLAYER_V_SINK].gst) {
LOGE("failed to create videosink element\n");
MMPLAYER_FLEAVE();
return MM_ERROR_PLAYER_INTERNAL;
g_object_set(G_OBJECT(player->pipeline->videobin[MMPLAYER_V_SINK].gst), "qos", TRUE, NULL);
/* save attributes */
- if (player->attrs)
- {
+ if (player->attrs) {
/* set a new display surface type */
mm_attrs_set_int_by_name(player->attrs, "display_surface_type", surface_type);
/* set a new diplay overlay */
- switch (surface_type)
- {
- case MM_DISPLAY_SURFACE_OVERLAY:
- LOGD("save attributes related to video display surface : id = %d", *(int*)display_overlay);
- mm_attrs_set_data_by_name(player->attrs, "display_overlay", display_overlay, sizeof(display_overlay));
- break;
- case MM_DISPLAY_SURFACE_EVAS:
- LOGD("save attributes related to display surface to EVAS : evas image object = %x", display_overlay);
- mm_attrs_set_data_by_name(player->attrs, "display_overlay", display_overlay, sizeof(void*));
- break;
- default:
- LOGE("invalid type(%d) for changing display surface",surface_type);
- MMPLAYER_FLEAVE();
- return MM_ERROR_INVALID_ARGUMENT;
+ switch (surface_type) {
+ case MM_DISPLAY_SURFACE_OVERLAY:
+ LOGD("save attributes related to video display surface : id = %d", *(int*)display_overlay);
+ mm_attrs_set_data_by_name(player->attrs, "display_overlay", display_overlay, sizeof(display_overlay));
+ break;
+ case MM_DISPLAY_SURFACE_EVAS:
+ LOGD("save attributes related to display surface to EVAS : evas image object = %x", display_overlay);
+ mm_attrs_set_data_by_name(player->attrs, "display_overlay", display_overlay, sizeof(void*));
+ break;
+ default:
+ LOGE("invalid type(%d) for changing display surface", surface_type);
+ MMPLAYER_FLEAVE();
+ return MM_ERROR_INVALID_ARGUMENT;
}
- if (mmf_attrs_commit(player->attrs))
- {
+ if (mmf_attrs_commit(player->attrs)) {
LOGE("failed to commit");
MMPLAYER_FLEAVE();
return MM_ERROR_PLAYER_INTERNAL;
}
- }
- else
- {
+ } else {
LOGE("player->attrs is null, failed to save attributes");
MMPLAYER_FLEAVE();
return MM_ERROR_PLAYER_INTERNAL;
}
/* update video param */
- if (MM_ERROR_NONE != _mmplayer_update_video_param(player, "update_all_param"))
- {
+ if (MM_ERROR_NONE != _mmplayer_update_video_param(player, "update_all_param")) {
LOGE("failed to update video param");
return MM_ERROR_PLAYER_INTERNAL;
}
/* change state of videobin to READY */
LOGD("setting [%s] state to : %d", GST_ELEMENT_NAME(player->pipeline->videobin[MMPLAYER_V_BIN].gst), GST_STATE_READY);
ret = gst_element_set_state(player->pipeline->videobin[MMPLAYER_V_BIN].gst, GST_STATE_READY);
- if (ret != GST_STATE_CHANGE_SUCCESS)
- {
+ if (ret != GST_STATE_CHANGE_SUCCESS) {
LOGE("failed to change state of videobin to READY");
return MM_ERROR_PLAYER_INTERNAL;
}
/* change ghostpad */
sink_pad_videosink = gst_element_get_static_pad(GST_ELEMENT(player->pipeline->videobin[MMPLAYER_V_SINK].gst), "sink");
- if (!sink_pad_videosink)
- {
+ if (!sink_pad_videosink) {
LOGE("failed to get sink pad from videosink element");
return MM_ERROR_PLAYER_INTERNAL;
}
player->ghost_pad_for_videobin = gst_ghost_pad_new("sink", sink_pad_videosink);
- if (!gst_pad_set_active(player->ghost_pad_for_videobin, TRUE))
- {
+ if (!gst_pad_set_active(player->ghost_pad_for_videobin, TRUE)) {
LOGE("failed to set active to ghost_pad");
return MM_ERROR_PLAYER_INTERNAL;
}
- if (FALSE == gst_element_add_pad(player->pipeline->videobin[MMPLAYER_V_BIN].gst, player->ghost_pad_for_videobin))
- {
+ if (FALSE == gst_element_add_pad(player->pipeline->videobin[MMPLAYER_V_BIN].gst, player->ghost_pad_for_videobin)) {
LOGE("failed to change ghostpad for videobin");
return MM_ERROR_PLAYER_INTERNAL;
}
/* link decoder with videobin */
sink_pad_videobin = gst_element_get_static_pad(GST_ELEMENT(player->pipeline->videobin[MMPLAYER_V_BIN].gst), "sink");
- if (!sink_pad_videobin)
- {
+ if (!sink_pad_videobin) {
LOGE("failed to get sink pad from videobin");
return MM_ERROR_PLAYER_INTERNAL;
}
- if (GST_PAD_LINK_OK != GST_PAD_LINK(src_pad_dec, sink_pad_videobin))
- {
+ if (GST_PAD_LINK_OK != GST_PAD_LINK(src_pad_dec, sink_pad_videobin)) {
LOGE("failed to link");
return MM_ERROR_PLAYER_INTERNAL;
}
/* clock setting for a new videosink plugin */
/* NOTE : Below operation is needed, because a new videosink plugin doesn't have clock for basesink,
so we set it from audiosink plugin or pipeline(system clock) */
- if (!is_audiobin_created)
- {
+ if (!is_audiobin_created) {
LOGW("audiobin is not created, get clock from pipeline..");
clock = GST_ELEMENT_CLOCK(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst);
- }
- else
- {
+ } else {
clock = GST_ELEMENT_CLOCK(player->pipeline->audiobin[MMPLAYER_A_SINK].gst);
}
- if (clock)
- {
+ if (clock) {
GstClockTime now;
GstClockTime base_time;
LOGD("set the clock to videosink");
gst_element_set_clock(GST_ELEMENT_CAST(player->pipeline->videobin[MMPLAYER_V_SINK].gst), clock);
clock = GST_ELEMENT_CLOCK(player->pipeline->videobin[MMPLAYER_V_SINK].gst);
- if (clock)
- {
+ if (clock) {
LOGD("got clock of videosink");
now = gst_clock_get_time(clock);
base_time = GST_ELEMENT_CAST(player->pipeline->videobin[MMPLAYER_V_SINK].gst)->base_time;
LOGD("at time %" GST_TIME_FORMAT ", base %"
GST_TIME_FORMAT, GST_TIME_ARGS(now), GST_TIME_ARGS(base_time));
- }
- else
- {
+ } else {
LOGE("failed to get clock of videosink after setting clock");
return MM_ERROR_PLAYER_INTERNAL;
}
- }
- else
- {
+ } else
LOGW("failed to get clock, maybe it is the time before first playing");
- }
- if (!player->doing_seek && previous_state == MM_PLAYER_STATE_PLAYING)
- {
+ if (!player->doing_seek && previous_state == MM_PLAYER_STATE_PLAYING) {
/* change state of videobin to PAUSED */
LOGD("setting [%s] state to : %d", GST_ELEMENT_NAME(player->pipeline->videobin[MMPLAYER_V_BIN].gst), GST_STATE_PLAYING);
ret = gst_element_set_state(player->pipeline->videobin[MMPLAYER_V_BIN].gst, GST_STATE_PLAYING);
- if (ret != GST_STATE_CHANGE_FAILURE)
- {
+ if (ret != GST_STATE_CHANGE_FAILURE) {
LOGW("change state of videobin to PLAYING, ret(%d)", ret);
- }
- else
- {
+ } else {
LOGE("failed to change state of videobin to PLAYING");
return MM_ERROR_PLAYER_INTERNAL;
}
/* release blocked and unref src pad of video decoder */
#if 0
- if (!gst_pad_set_blocked(src_pad_dec, FALSE))
- {
+ if (!gst_pad_set_blocked(src_pad_dec, FALSE)) {
LOGE("failed to set pad blocked FALSE(video)");
return MM_ERROR_PLAYER_INTERNAL;
}
#endif
LOGW("pad is unblocked(video)");
- }
- else
- {
- if (player->doing_seek) {
+ } else {
+ if (player->doing_seek)
LOGW("not completed seek(%d)", player->doing_seek);
- }
/* change state of videobin to PAUSED */
LOGD("setting [%s] state to : %d", GST_ELEMENT_NAME(player->pipeline->videobin[MMPLAYER_V_BIN].gst), GST_STATE_PAUSED);
ret = gst_element_set_state(player->pipeline->videobin[MMPLAYER_V_BIN].gst, GST_STATE_PAUSED);
- if (ret != GST_STATE_CHANGE_FAILURE)
- {
+ if (ret != GST_STATE_CHANGE_FAILURE) {
LOGW("change state of videobin to PAUSED, ret(%d)", ret);
- }
- else
- {
+ } else {
LOGE("failed to change state of videobin to PLAYING");
return MM_ERROR_PLAYER_INTERNAL;
}
gint64 pos_msec = 0;
LOGD("do get/set position for new videosink plugin");
- if (__gst_get_position(player, MM_PLAYER_POS_FORMAT_TIME, &position))
- {
+ if (__gst_get_position(player, MM_PLAYER_POS_FORMAT_TIME, &position)) {
LOGE("failed to get position");
return MM_ERROR_PLAYER_INTERNAL;
}
#ifdef SINKCHANGE_WITH_ACCURATE_SEEK
/* accurate seek */
- if (__gst_set_position(player, MM_PLAYER_POS_FORMAT_TIME, position, TRUE))
- {
+ if (__gst_set_position(player, MM_PLAYER_POS_FORMAT_TIME, position, TRUE)) {
LOGE("failed to set position");
return MM_ERROR_PLAYER_INTERNAL;
}
GST_FORMAT_TIME, (GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT),
GST_SEEK_TYPE_SET, pos_msec,
GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
- if (!ret )
- {
+ if (!ret) {
LOGE("failed to set position");
return MM_ERROR_PLAYER_INTERNAL;
}
}
if (src_pad_dec)
- {
gst_object_unref(src_pad_dec);
- }
LOGD("success to change sink");
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
-int _mmplayer_remove_audio_parser_decoder(mm_player_t* player,GstPad *inpad)
+int _mmplayer_remove_audio_parser_decoder(mm_player_t* player, GstPad *inpad)
{
int result = MM_ERROR_NONE;
- GstPad *peer = NULL,*pad = NULL;
+ GstPad *peer = NULL, *pad = NULL;
GstElement *Element = NULL;
MMPlayerGstElement* mainbin = NULL;
mainbin = player->pipeline->mainbin;
#if 0
- if (!gst_pad_set_blocked(inpad,TRUE))
- {
+ if (!gst_pad_set_blocked(inpad, TRUE)) {
result = MM_ERROR_PLAYER_INTERNAL;
goto EXIT;
}
/*Getting pad connected to demuxer audio pad */
peer = gst_pad_get_peer(inpad);
/* Disconnecting Demuxer and its peer plugin [audio] */
- if (peer)
- {
- if (!gst_pad_unlink(inpad,peer))
- {
+ if (peer) {
+ if (!gst_pad_unlink(inpad, peer)) {
result = MM_ERROR_PLAYER_INTERNAL;
goto EXIT;
}
- }
- else
- {
+ } else {
result = MM_ERROR_PLAYER_INTERNAL;
goto EXIT;
}
/*Removing elements between Demuxer and audiobin*/
- while (peer != NULL)
- {
+ while (peer != NULL) {
gchar *Element_name = NULL;
gchar *factory_name = NULL;
GList *elements = NULL;
GstElementFactory *factory = NULL;
/*Getting peer element*/
Element = gst_pad_get_parent_element(peer);
- if (Element == NULL)
- {
+ if (Element == NULL) {
gst_object_unref(peer);
result = MM_ERROR_PLAYER_INTERNAL;
break;
Element_name = gst_element_get_name(Element);
factory = gst_element_get_factory(Element);
/*checking the element is audio bin*/
- if (!strcmp(Element_name,"audiobin"))
- {
+ if (!strcmp(Element_name, "audiobin")) {
gst_object_unref(peer);
result = MM_ERROR_NONE;
- g_free(Element_name);
+ g_free(Element_name);
break;
}
factory_name = GST_OBJECT_NAME(factory);
- pad = gst_element_get_static_pad(Element,"src");
- if (pad == NULL)
- {
+ pad = gst_element_get_static_pad(Element, "src");
+ if (pad == NULL) {
result = MM_ERROR_PLAYER_INTERNAL;
- g_free(Element_name);
+ g_free(Element_name);
break;
}
gst_object_unref(peer);
peer = gst_pad_get_peer(pad);
- if (peer)
- {
- if (!gst_pad_unlink(pad,peer))
- {
+ if (peer) {
+ if (!gst_pad_unlink(pad, peer)) {
gst_object_unref(peer);
gst_object_unref(pad);
result = MM_ERROR_PLAYER_INTERNAL;
- g_free(Element_name);
+ g_free(Element_name);
break;
}
}
elements = player->parsers;
/* Removing the element form the list*/
- for (; elements; elements = g_list_next(elements))
- {
+ for (; elements; elements = g_list_next(elements)) {
Element_name = elements->data;
- if (g_strrstr(Element_name,factory_name))
- {
- player->parsers = g_list_remove(player->parsers,elements->data);
- }
+ if (g_strrstr(Element_name, factory_name))
+ player->parsers = g_list_remove(player->parsers, elements->data);
}
- gst_element_set_state(Element,GST_STATE_NULL);
- gst_bin_remove(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst),Element);
+ gst_element_set_state(Element, GST_STATE_NULL);
+ gst_bin_remove(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), Element);
gst_object_unref(pad);
if (Element == mainbin[MMPLAYER_M_Q1].gst)
- {
mainbin[MMPLAYER_M_Q1].gst = NULL;
- }
else if (Element == mainbin[MMPLAYER_M_Q2].gst)
- {
mainbin[MMPLAYER_M_Q2].gst = NULL;
- }
else if (Element == mainbin[MMPLAYER_M_DEC1].gst)
- {
mainbin[MMPLAYER_M_DEC1].gst = NULL;
- }
else if (Element == mainbin[MMPLAYER_M_DEC2].gst)
- {
mainbin[MMPLAYER_M_DEC2].gst = NULL;
- }
+
gst_object_unref(Element);
}
EXIT:
/* check player handle */
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline , MM_ERROR_PLAYER_NOT_INITIALIZED);
- if (!(player->pipeline->mainbin) || !(player->pipeline->textbin))
- {
+ if (!(player->pipeline->mainbin) || !(player->pipeline->textbin)) {
LOGE("Pipeline is not in proper state\n");
result = MM_ERROR_PLAYER_NOT_INITIALIZED;
goto EXIT;
LOGD("base_time=%" GST_TIME_FORMAT " start_time=%" GST_TIME_FORMAT " curr_time=%" GST_TIME_FORMAT,
GST_TIME_ARGS(base_time), GST_TIME_ARGS(start_time), GST_TIME_ARGS(curr_time));
- if (current_state > GST_STATE_READY)
- {
+ if (current_state > GST_STATE_READY) {
// sync state with current pipeline
gst_element_set_state(textbin[MMPLAYER_T_BIN].gst, GST_STATE_PAUSED);
gst_element_set_state(mainbin[MMPLAYER_M_SUBPARSE].gst, GST_STATE_PAUSED);
ret = gst_element_get_state(mainbin[MMPLAYER_M_SUBSRC].gst, &element_state, &element_pending_state, 5 * GST_SECOND);
if (GST_STATE_CHANGE_FAILURE == ret)
- {
LOGE("fail to state change.\n");
- }
}
gst_element_set_base_time(textbin[MMPLAYER_T_BIN].gst, base_time);
gst_element_set_start_time(textbin[MMPLAYER_T_BIN].gst, start_time);
- if (curr_clock)
- {
+ if (curr_clock) {
gst_element_set_clock(textbin[MMPLAYER_T_BIN].gst, curr_clock);
gst_object_unref(curr_clock);
}
// seek to current position
- if (!gst_element_query_position(mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &time))
- {
+ if (!gst_element_query_position(mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &time)) {
result = MM_ERROR_PLAYER_INVALID_STATE;
LOGE("gst_element_query_position failed, invalid state\n");
goto EXIT;
LOGD("seek time = %lld\n", time);
event = gst_event_new_seek(1.0, GST_FORMAT_TIME, (GstSeekFlags)(GST_SEEK_FLAG_FLUSH), GST_SEEK_TYPE_SET, time, GST_SEEK_TYPE_NONE, -1);
- if (event)
- {
+ if (event) {
__gst_send_event_to_sink(player, event);
- }
- else
- {
+ } else {
result = MM_ERROR_PLAYER_INTERNAL;
LOGE("gst_event_new_seek failed\n");
goto EXIT;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
MMPLAYER_RETURN_VAL_IF_FAIL(filepath, MM_ERROR_COMMON_INVALID_ARGUMENT);
- if (!(player->pipeline) || !(player->pipeline->mainbin))
- {
+ if (!(player->pipeline) || !(player->pipeline->mainbin)) {
result = MM_ERROR_PLAYER_INVALID_STATE;
LOGE("Pipeline is not in proper state\n");
goto EXIT;
textbin = player->pipeline->textbin;
current_state = GST_STATE(mainbin[MMPLAYER_M_PIPE].gst);
- if (current_state < GST_STATE_READY)
- {
+ if (current_state < GST_STATE_READY) {
result = MM_ERROR_PLAYER_INVALID_STATE;
LOGE("Pipeline is not in proper state\n");
goto EXIT;
}
attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs)
- {
+ if (!attrs) {
LOGE("cannot get content attribute\n");
result = MM_ERROR_PLAYER_INTERNAL;
goto EXIT;
}
mm_attrs_get_string_by_name(attrs, "subtitle_uri", &subtitle_uri);
- if (!subtitle_uri || strlen(subtitle_uri) < 1)
- {
+ if (!subtitle_uri || strlen(subtitle_uri) < 1) {
LOGE("subtitle uri is not proper filepath\n");
result = MM_ERROR_PLAYER_INVALID_URI;
goto EXIT;
LOGD("old subtitle file path is [%s]\n", subtitle_uri);
LOGD("new subtitle file path is [%s]\n", filepath);
- if (!strcmp(filepath, subtitle_uri))
- {
+ if (!strcmp(filepath, subtitle_uri)) {
LOGD("No need to swtich subtitle, as input filepath is same as current filepath\n");
goto EXIT;
- }
- else
- {
+ } else {
mm_attrs_set_string_by_name(player->attrs, "subtitle_uri", filepath);
- if (mmf_attrs_commit(player->attrs))
- {
+ if (mmf_attrs_commit(player->attrs)) {
LOGE("failed to commit.\n");
goto EXIT;
}
//gst_pad_set_blocked_async(src-srcpad, TRUE)
ret = gst_element_set_state(textbin[MMPLAYER_T_BIN].gst, GST_STATE_READY);
- if (ret != GST_STATE_CHANGE_SUCCESS)
- {
+ if (ret != GST_STATE_CHANGE_SUCCESS) {
LOGE("failed to change state of textbin to READY");
result = MM_ERROR_PLAYER_INTERNAL;
goto EXIT;
}
ret = gst_element_set_state(mainbin[MMPLAYER_M_SUBPARSE].gst, GST_STATE_READY);
- if (ret != GST_STATE_CHANGE_SUCCESS)
- {
+ if (ret != GST_STATE_CHANGE_SUCCESS) {
LOGE("failed to change state of subparse to READY");
result = MM_ERROR_PLAYER_INTERNAL;
goto EXIT;
}
ret = gst_element_set_state(mainbin[MMPLAYER_M_SUBSRC].gst, GST_STATE_READY);
- if (ret != GST_STATE_CHANGE_SUCCESS)
- {
+ if (ret != GST_STATE_CHANGE_SUCCESS) {
LOGE("failed to change state of filesrc to READY");
result = MM_ERROR_PLAYER_INTERNAL;
goto EXIT;
g_object_set(G_OBJECT(mainbin[MMPLAYER_M_SUBSRC].gst), "location", filepath, NULL);
charset = util_get_charset(filepath);
- if (charset)
- {
+ if (charset) {
LOGD("detected charset is %s\n", charset);
g_object_set(G_OBJECT(mainbin[MMPLAYER_M_SUBPARSE].gst), "subtitle-encoding", charset, NULL);
}
/* check player handle */
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- if (!player->pipeline) // IDLE state
- {
+ if (!player->pipeline) {
+ // IDLE state
mm_attrs_set_string_by_name(player->attrs, "subtitle_uri", filepath);
- if (mmf_attrs_commit(player->attrs))
- {
+ if (mmf_attrs_commit(player->attrs)) {
LOGE("failed to commit.\n");
- result= MM_ERROR_PLAYER_INTERNAL;
+ result = MM_ERROR_PLAYER_INTERNAL;
}
- }
- else // curr state <> IDLE(READY, PAUSE, PLAYING..)
- {
+ } else {
+ // cur state <> IDLE(READY, PAUSE, PLAYING..)
if (filepath == NULL)
return MM_ERROR_COMMON_INVALID_ARGUMENT;
- if (!__mmplayer_check_subtitle(player))
- {
+ if (!__mmplayer_check_subtitle(player)) {
mm_attrs_set_string_by_name(player->attrs, "subtitle_uri", filepath);
- if (mmf_attrs_commit(player->attrs))
- {
+ if (mmf_attrs_commit(player->attrs)) {
LOGE("failed to commit.\n");
result = MM_ERROR_PLAYER_INTERNAL;
}
LOGE("fail to create subtitle src\n");
result = _mmplayer_sync_subtitle_pipeline(player);
- }
- else
- {
+ } else
result = __mmplayer_change_external_subtitle_language(player, filepath);
- }
}
MMPLAYER_FLEAVE();
mainbin = player->pipeline->mainbin;
- if (type == MM_PLAYER_TRACK_TYPE_AUDIO)
- {
+ if (type == MM_PLAYER_TRACK_TYPE_AUDIO) {
elemId = MMPLAYER_M_A_INPUT_SELECTOR;
- }
- else if (type == MM_PLAYER_TRACK_TYPE_TEXT)
- {
+ } else if (type == MM_PLAYER_TRACK_TYPE_TEXT) {
elemId = MMPLAYER_M_T_INPUT_SELECTOR;
- }
- else
- {
+ } else {
/* Changing Video Track is not supported. */
LOGE("Track Type Error\n");
goto EXIT;
}
- if (mainbin[elemId].gst == NULL)
- {
+ if (mainbin[elemId].gst == NULL) {
result = MM_ERROR_PLAYER_NO_OP;
LOGD("Req track doesn't exist\n");
goto EXIT;
}
total_track_num = player->selector[type].total_track_num;
- if (total_track_num <= 0)
- {
+ if (total_track_num <= 0) {
result = MM_ERROR_PLAYER_NO_OP;
LOGD("Language list is not available \n");
goto EXIT;
}
- if ((index < 0) || (index >= total_track_num))
- {
+ if ((index < 0) || (index >= total_track_num)) {
result = MM_ERROR_INVALID_ARGUMENT;
LOGD("Not a proper index : %d \n", index);
goto EXIT;
/*To get the new pad from the selector*/
change_pad_name = g_strdup_printf("sink_%u", index);
- if (change_pad_name == NULL)
- {
+ if (change_pad_name == NULL) {
result = MM_ERROR_PLAYER_INTERNAL;
LOGD("Pad does not exists\n");
goto EXIT;
LOGD("new active pad name: %s\n", change_pad_name);
sinkpad = gst_element_get_static_pad(mainbin[elemId].gst, change_pad_name);
- if (sinkpad == NULL)
- {
+ if (sinkpad == NULL) {
LOGD("sinkpad is NULL");
result = MM_ERROR_PLAYER_INTERNAL;
goto EXIT;
gst_object_unref(sinkpad);
if (type == MM_PLAYER_TRACK_TYPE_AUDIO)
- {
__mmplayer_set_audio_attrs(player, caps);
- }
EXIT:
player = (mm_player_t*)hplayer;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- if (!player->pipeline)
- {
+ if (!player->pipeline) {
LOGE("Track %d pre setting -> %d\n", type, index);
player->selector[type].active_pad_index = index;
/*If index is same as running index no need to change the pad*/
if (current_active_index == index)
- {
goto EXIT;
- }
- if (!gst_element_query_position(mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &time))
- {
+ if (!gst_element_query_position(mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &time)) {
result = MM_ERROR_PLAYER_INVALID_STATE;
goto EXIT;
}
current_state = GST_STATE(mainbin[MMPLAYER_M_PIPE].gst);
- if (current_state < GST_STATE_PAUSED)
- {
+ if (current_state < GST_STATE_PAUSED) {
result = MM_ERROR_PLAYER_INVALID_STATE;
LOGW("Pipeline not in porper state\n");
goto EXIT;
}
result = __mmplayer_change_selector_pad(player, type, index);
- if (result != MM_ERROR_NONE)
- {
+ if (result != MM_ERROR_NONE) {
LOGE("change selector pad error\n");
goto EXIT;
}
player->selector[type].active_pad_index = index;
- if (current_state == GST_STATE_PLAYING)
- {
- event = gst_event_new_seek(1.0, GST_FORMAT_TIME, (GstSeekFlags)(GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SKIP),GST_SEEK_TYPE_SET, time, GST_SEEK_TYPE_NONE, -1);
- if (event)
- {
+ if (current_state == GST_STATE_PLAYING) {
+ event = gst_event_new_seek(1.0, GST_FORMAT_TIME, (GstSeekFlags)(GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SKIP), GST_SEEK_TYPE_SET, time, GST_SEEK_TYPE_NONE, -1);
+ if (event) {
__gst_send_event_to_sink(player, event);
- }
- else
- {
+ } else {
result = MM_ERROR_PLAYER_INTERNAL;
goto EXIT;
}
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- return(player->profile.uri_type == MM_PLAYER_URI_TYPE_MS_BUFF) ? TRUE : FALSE;
+ return (player->profile.uri_type == MM_PLAYER_URI_TYPE_MS_BUFF) ? TRUE : FALSE;
}
gboolean
gchar* t_suffix = g_ascii_strdown(suffix, -1);
if (g_str_has_suffix(player->profile.uri, suffix))
- {
ret = TRUE;
- }
MMPLAYER_FREEIF(t_url);
MMPLAYER_FREEIF(t_suffix);
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- if (MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_NULL)
- {
+ if (MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_NULL) {
MMPLAYER_PRINT_STATE(player);
LOGE("wrong-state : can't set the download mode to parse");
return MM_ERROR_PLAYER_INVALID_STATE;
}
- LOGD("set video hub download mode to %s", (mode)?"ON":"OFF");
+ LOGD("set video hub download mode to %s", (mode) ? "ON" : "OFF");
player->video_hub_download_mode = mode;
return MM_ERROR_NONE;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- LOGD("enable sync handler : %s", (enable)?"ON":"OFF");
+ LOGD("enable sync handler : %s", (enable) ? "ON" : "OFF");
player->sync_handler = enable;
return MM_ERROR_NONE;
}
int
-_mmplayer_set_video_share_master_clock( MMHandleType hplayer,
+_mmplayer_set_video_share_master_clock(MMHandleType hplayer,
long long clock,
long long clock_delta,
long long video_time,
// LOGD("in(us) : %lld, %lld, %lld, %lld, %lld", clock, clock_delta, video_time, media_clock, audio_time);
- if ((video_time < 0) || (player->doing_seek))
- {
+ if ((video_time < 0) || (player->doing_seek)) {
LOGD("skip setting master clock. %lld", video_time);
goto EXIT;
}
query_ret = gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &position);
if ((current_state != MM_PLAYER_STATE_PLAYING) ||
- (!query_ret))
- {
+ (!query_ret)) {
position = player->last_position;
LOGD("query fail. %lld", position);
}
- clock*= GST_USECOND;
+ clock *= GST_USECOND;
clock_delta *= GST_USECOND;
api_delta = clock - curr_time;
if ((player->video_share_api_delta == 0) || (player->video_share_api_delta > api_delta))
- {
player->video_share_api_delta = api_delta;
- }
else
- {
clock_delta += (api_delta - player->video_share_api_delta);
- }
- if ((player->video_share_clock_delta == 0) || (player->video_share_clock_delta > clock_delta))
- {
+ if ((player->video_share_clock_delta == 0) || (player->video_share_clock_delta > clock_delta)) {
player->video_share_clock_delta = (gint64)clock_delta;
position_delta = (position/GST_USECOND) - video_time;
adj_base_time = position_delta;
LOGD("video_share_clock_delta = %lld, adj = %lld", player->video_share_clock_delta, adj_base_time);
- }
- else
- {
+ } else {
gint64 new_play_time = 0;
- gint64 network_delay =0;
+ gint64 network_delay = 0;
video_time *= GST_USECOND;
* if adj_base_time is positive value, the stream time will be decreased.
* 3. If seek event is occurred, the start time will be reset. */
if ((player->pipeline->audiobin) &&
- (player->pipeline->audiobin[MMPLAYER_A_SINK].gst))
- {
+ (player->pipeline->audiobin[MMPLAYER_A_SINK].gst)) {
start_time_audio = gst_element_get_start_time(player->pipeline->audiobin[MMPLAYER_A_SINK].gst);
- if (start_time_audio != GST_CLOCK_TIME_NONE)
- {
+ if (start_time_audio != GST_CLOCK_TIME_NONE) {
LOGD("audio sink : gst_element_set_start_time -> NONE");
gst_element_set_start_time(player->pipeline->audiobin[MMPLAYER_A_SINK].gst, GST_CLOCK_TIME_NONE);
}
}
if ((player->pipeline->videobin) &&
- (player->pipeline->videobin[MMPLAYER_V_SINK].gst))
- {
+ (player->pipeline->videobin[MMPLAYER_V_SINK].gst)) {
start_time_video = gst_element_get_start_time(player->pipeline->videobin[MMPLAYER_V_SINK].gst);
- if (start_time_video != GST_CLOCK_TIME_NONE)
- {
+ if (start_time_video != GST_CLOCK_TIME_NONE) {
LOGD("video sink : gst_element_set_start_time -> NONE");
gst_element_set_start_time(player->pipeline->videobin[MMPLAYER_V_SINK].gst, GST_CLOCK_TIME_NONE);
}
}
int
-_mmplayer_get_video_share_master_clock( MMHandleType hplayer,
+_mmplayer_get_video_share_master_clock(MMHandleType hplayer,
long long *video_time,
long long *media_clock,
long long *audio_time)
if ((current_state == MM_PLAYER_STATE_PAUSED) ||
(!query_ret))
- {
position = player->last_position;
- }
*media_clock = *video_time = *audio_time = (position/GST_USECOND);
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
MMPLAYER_RETURN_VAL_IF_FAIL(angle, MM_ERROR_COMMON_INVALID_ARGUMENT);
- if (player->v_stream_caps)
- {
+ if (player->v_stream_caps) {
GstStructure *str = NULL;
str = gst_caps_get_structure(player->v_stream_caps, 0);
if (!gst_structure_get_int(str, "orientation", &org_angle))
- {
LOGD("missing 'orientation' field in video caps");
- }
}
LOGD("orientation: %d", org_angle);
int idx = 0;
- for (idx = 0; player->ini.dump_element_keyword[idx][0] != '\0'; idx++)
- {
- if (g_strrstr(factory_name, player->ini.dump_element_keyword[idx]))
- {
+ for (idx = 0; player->ini.dump_element_keyword[idx][0] != '\0'; idx++) {
+ if (g_strrstr(factory_name, player->ini.dump_element_keyword[idx])) {
LOGD("dump [%s] sink pad", player->ini.dump_element_keyword[idx]);
mm_player_dump_t *dump_s;
dump_s = g_malloc(sizeof(mm_player_dump_t));
- if (dump_s == NULL)
- {
+ if (dump_s == NULL) {
LOGE("malloc fail");
return FALSE;
}
dump_s->dump_pad = NULL;
dump_s->dump_pad = gst_element_get_static_pad(element, "sink");
- if (dump_s->dump_pad)
- {
+ if (dump_s->dump_pad) {
memset(dump_file_name, 0x00, PLAYER_INI_MAX_STRLEN*2);
snprintf(dump_file_name, PLAYER_INI_MAX_STRLEN*2, "%s/%s_sink_pad.dump", player->ini.dump_element_path, player->ini.dump_element_keyword[idx]);
- dump_s->dump_element_file = fopen(dump_file_name,"w+");
+ dump_s->dump_element_file = fopen(dump_file_name, "w+");
dump_s->probe_handle_id = gst_pad_add_probe(dump_s->dump_pad, GST_PAD_PROBE_TYPE_BUFFER, __mmplayer_dump_buffer_probe_cb, dump_s->dump_element_file, NULL);
/* add list for removed buffer probe and close FILE */
player->dump_list = g_list_append(player->dump_list, dump_s);
LOGD("%s sink pad added buffer probe for dump", factory_name);
return TRUE;
- }
- else
- {
+ } else {
g_free(dump_s);
dump_s = NULL;
LOGE("failed to get %s sink pad added", factory_name);
static void
__mmplayer_release_dump_list(GList *dump_list)
{
- if (dump_list)
- {
+ if (dump_list) {
GList *d_list = dump_list;
- for (;d_list ; d_list = g_list_next(d_list))
- {
+ for (; d_list; d_list = g_list_next(d_list)) {
mm_player_dump_t *dump_s = d_list->data;
- if (dump_s->dump_pad)
- {
+ if (dump_s->dump_pad) {
if (dump_s->probe_handle_id)
- {
gst_pad_remove_probe(dump_s->dump_pad, dump_s->probe_handle_id);
- }
-
}
- if (dump_s->dump_element_file)
- {
+ if (dump_s->dump_element_file) {
fclose(dump_s->dump_element_file);
dump_s->dump_element_file = NULL;
}
{
mm_player_t *player = (mm_player_t*)user_data;
MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_AUDIO;
- guint64 current_level_bytes=0;
+ guint64 current_level_bytes = 0;
MMPLAYER_RETURN_IF_FAIL(player);
LOGI("app-src: feed audio(%llu)\n", current_level_bytes);
if (player->media_stream_buffer_status_cb[type])
- {
player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN, current_level_bytes, player->buffer_cb_user_param);
- }
}
void
{
mm_player_t *player = (mm_player_t*)user_data;
MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_VIDEO;
- guint64 current_level_bytes=0;
+ guint64 current_level_bytes = 0;
MMPLAYER_RETURN_IF_FAIL(player);
LOGI("app-src: feed video(%llu)\n", current_level_bytes);
if (player->media_stream_buffer_status_cb[type])
- {
player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN, current_level_bytes, player->buffer_cb_user_param);
- }
}
void
{
mm_player_t *player = (mm_player_t*)user_data;
MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_TEXT;
- guint64 current_level_bytes=0;
+ guint64 current_level_bytes = 0;
MMPLAYER_RETURN_IF_FAIL(player);
g_object_get(G_OBJECT(element), "current-level-bytes", ¤t_level_bytes, NULL);
if (player->media_stream_buffer_status_cb[type])
- {
player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN, current_level_bytes, player->buffer_cb_user_param);
- }
}
void
{
mm_player_t *player = (mm_player_t*)user_data;
MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_AUDIO;
- guint64 current_level_bytes=0;
+ guint64 current_level_bytes = 0;
MMPLAYER_RETURN_IF_FAIL(player);
g_object_get(G_OBJECT(element), "current-level-bytes", ¤t_level_bytes, NULL);
if (player->media_stream_buffer_status_cb[type])
- {
player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW, current_level_bytes, player->buffer_cb_user_param);
- }
}
void
{
mm_player_t *player = (mm_player_t*)user_data;
MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_VIDEO;
- guint64 current_level_bytes=0;
+ guint64 current_level_bytes = 0;
MMPLAYER_RETURN_IF_FAIL(player);
g_object_get(G_OBJECT(element), "current-level-bytes", ¤t_level_bytes, NULL);
if (player->media_stream_buffer_status_cb[type])
- {
player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW, current_level_bytes, player->buffer_cb_user_param);
- }
}
gboolean
LOGD("app-src: seek audio data %llu\n", position);
if (player->media_stream_seek_data_cb[type])
- {
player->media_stream_seek_data_cb[type](type, position, player->buffer_cb_user_param);
- }
return TRUE;
}
LOGD("app-src: seek video data %llu\n", position);
if (player->media_stream_seek_data_cb[type])
- {
player->media_stream_seek_data_cb[type](type, position, player->buffer_cb_user_param);
- }
return TRUE;
}
LOGD("app-src: seek subtitle data\n");
if (player->media_stream_seek_data_cb[type])
- {
player->media_stream_seek_data_cb[type](type, position, player->buffer_cb_user_param);
- }
return TRUE;
}
projects / platform / core / multimedia / libmm-player.git / commitdiff