static int __mmplayer_gst_create_audio_sink_bin(mmplayer_t *player);
static int __mmplayer_gst_create_text_sink_bin(mmplayer_t *player);
-static void __mmplayer_gst_decode_no_more_pads(GstElement *elem, gpointer data);
static void __mmplayer_gst_create_sinkbin(GstElement *decodebin, GstPad *pad, gpointer data);
-static void __mmplayer_gst_decode_unknown_type(GstElement *elem, GstPad *pad, GstCaps *caps, gpointer data);
-static gboolean __mmplayer_gst_decode_autoplug_continue(GstElement *bin, GstPad *pad, GstCaps *caps, gpointer data);
-static void __mmplayer_gst_decode_pad_removed(GstElement *elem, GstPad *new_pad, gpointer data);
-static void __mmplayer_gst_decode_drained(GstElement *bin, gpointer data);
-static void __mmplayer_pipeline_complete(GstElement *decodebin, gpointer data);
static gboolean __mmplayer_is_midi_type(gchar *str_caps);
static gboolean __mmplayer_is_only_mp3_type(gchar *str_caps);
-static void __mmplayer_set_audio_attrs(mmplayer_t *player, GstCaps *caps);
+static void __mmplayer_set_audio_attrs(mmplayer_t *player, GstCaps *caps);
static gboolean __mmplayer_update_subtitle(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data);
static void __mmplayer_release_misc(mmplayer_t *player);
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->track[idx].event_probe_id)) {
#ifdef __DEBUG__
LOGW("[%d] skip", idx);
#endif
player->pipeline->mainbin[elem_idx].id = elem_idx;
player->pipeline->mainbin[elem_idx].gst = selector;
- /* player->selector[stream_type].active_pad_index = DEFAULT_TRACK; */
+ /* player->track[stream_type].active_track_index = DEFAULT_TRACK; */
srcpad = gst_element_get_static_pad(selector, "src");
LOGD("blocking %s:%s", GST_DEBUG_PAD_NAME(srcpad));
- player->selector[stream_type].block_id = gst_pad_add_probe(srcpad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
+ player->track[stream_type].block_id = gst_pad_add_probe(srcpad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
__mmplayer_gst_selector_blocked, NULL, NULL);
- player->selector[stream_type].event_probe_id = gst_pad_add_probe(srcpad, GST_PAD_PROBE_TYPE_EVENT_BOTH|GST_PAD_PROBE_TYPE_EVENT_FLUSH,
+ player->track[stream_type].event_probe_id = gst_pad_add_probe(srcpad, GST_PAD_PROBE_TYPE_EVENT_BOTH|GST_PAD_PROBE_TYPE_EVENT_FLUSH,
__mmplayer_gst_selector_event_probe, player, NULL);
gst_element_set_state(selector, GST_STATE_PAUSED);
const gchar *name = NULL;
GstPad *sinkpad = NULL;
gboolean first_track = FALSE;
+ gboolean caps_ret = TRUE;
main_element_id_e elem_idx = MMPLAYER_M_NUM;
mmplayer_track_type_e stream_type = MM_PLAYER_TRACK_TYPE_AUDIO;
LOGD("pad-added signal handling");
/* get mimetype from caps */
- caps = gst_pad_get_current_caps(pad);
- if (caps) {
- str = gst_caps_get_structure(caps, 0);
- if (str)
- name = gst_structure_get_name(str);
- }
- if (!name)
+ MMPLAYER_GST_GET_CAPS_INFO(pad, caps, str, name, caps_ret);
+ if (!caps_ret)
goto ERROR;
MMPLAYER_LOG_GST_CAPS_TYPE(caps);
LOGD("surface type : %d", stype);
- if (MMPLAYER_IS_MS_BUFF_SRC(player)) {
+ if (MMPLAYER_IS_MS_BUFF_SRC(player) || MMPLAYER_USE_URIDECODEBIN3(player)) {
__mmplayer_gst_create_sinkbin(elem, pad, player);
goto DONE;
}
gint samplerate = 0;
gint channels = 0;
- if (MMPLAYER_IS_MS_BUFF_SRC(player) || player->build_audio_offload) {
+ if (MMPLAYER_IS_MS_BUFF_SRC(player) || MMPLAYER_USE_URIDECODEBIN3(player) || player->build_audio_offload) {
if (player->build_audio_offload)
player->no_more_pad = TRUE; /* remove state holder */
__mmplayer_gst_create_sinkbin(elem, pad, player);
g_object_set(selector, "active-pad", sinkpad, NULL);
}
- _mmplayer_track_update_selector_info(player, stream_type, sinkpad);
+ if (!MMPLAYER_USE_URIDECODEBIN3(player))
+ _mmplayer_track_update_stream(player, stream_type, sinkpad);
DONE:
ERROR:
__mmplayer_gst_create_sinkbin(selector, srcpad, player);
LOGD("unblocking %s:%s", GST_DEBUG_PAD_NAME(srcpad));
- if (player->selector[type].block_id) {
- gst_pad_remove_probe(srcpad, player->selector[type].block_id);
- player->selector[type].block_id = 0;
+ if (player->track[type].block_id) {
+ gst_pad_remove_probe(srcpad, player->track[type].block_id);
+ player->track[type].block_id = 0;
}
if (srcpad) {
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
- LOGD("type: %d, the num of track: %d", type, player->selector[type].total_track_num);
+ LOGD("type: %d, the num of track: %d", type, player->track[type].total_track_num);
/* change track to active pad */
- active_index = player->selector[type].active_pad_index;
+ active_index = player->track[type].active_track_index;
if ((active_index != DEFAULT_TRACK) &&
(__mmplayer_change_selector_pad(player, type, active_index) != MM_ERROR_NONE)) {
LOGW("failed to change %d type track to %d", type, active_index);
- player->selector[type].active_pad_index = DEFAULT_TRACK;
+ player->track[type].active_track_index = DEFAULT_TRACK;
return;
}
if (type == MM_PLAYER_TRACK_TYPE_TEXT)
mm_player_set_attribute((MMHandleType)player, NULL,
- "content_text_track_num", player->selector[type].total_track_num,
- "current_text_track_index", player->selector[type].active_pad_index, NULL);
+ "content_text_track_num", player->track[type].total_track_num,
+ "current_text_track_index", player->track[type].active_track_index, NULL);
MMPLAYER_FLEAVE();
return;
}
if (player->num_dynamic_pad == 0) /* FIXME: num_dynamic_pad is only for rtsp? */
- __mmplayer_pipeline_complete(NULL, player);
+ _mmplayer_pipeline_complete(NULL, player);
return TRUE;
}
/* apply the audio track information */
- __mmplayer_set_decode_track_info(player, MM_PLAYER_TRACK_TYPE_AUDIO);
+ if (!MMPLAYER_USE_URIDECODEBIN3(player))
+ __mmplayer_set_decode_track_info(player, MM_PLAYER_TRACK_TYPE_AUDIO);
/* create audio sink path */
if (!__mmplayer_create_sink_path(player, audio_selector, MM_PLAYER_TRACK_TYPE_AUDIO)) {
/* apply the text track information */
__mmplayer_set_decode_track_info(player, MM_PLAYER_TRACK_TYPE_TEXT);
- if (player->selector[MM_PLAYER_TRACK_TYPE_TEXT].total_track_num > 0)
+ if (player->track[MM_PLAYER_TRACK_TYPE_TEXT].total_track_num > 0)
player->has_closed_caption = TRUE;
/* create text decode path */
return TRUE;
}
-static void
-__mmplayer_gst_decode_no_more_pads(GstElement *elem, gpointer data)
+void
+_mmplayer_gst_decode_no_more_pads(GstElement *elem, gpointer data)
{
mmplayer_t *player = NULL;
GstElement *video_selector = NULL;
LOGD("no more pads: %d, stream count dec : %d(num of dynamic pad)", player->no_more_pad, player->num_dynamic_pad);
if ((player->no_more_pad) && (player->num_dynamic_pad == 0))
- __mmplayer_pipeline_complete(NULL, player);
+ _mmplayer_pipeline_complete(NULL, player);
ERROR:
MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && player->pipeline->mainbin);
player->no_more_pad = TRUE;
- __mmplayer_pipeline_complete(NULL, player);
+ _mmplayer_pipeline_complete(NULL, player);
MMPLAYER_FLEAVE();
return;
MMPLAYER_FREEIF(player->type);
player->no_more_pad = FALSE;
player->num_dynamic_pad = 0;
- player->demux_pad_index = 0;
MMPLAYER_SUBTITLE_INFO_LOCK(player);
player->subtitle_language_list = NULL;
player->is_subtitle_off = FALSE; /* set the subtitle ON default */
player->video360_metadata.is_spherical = -1;
player->is_openal_plugin_used = FALSE;
- player->demux_pad_index = 0;
player->subtitle_language_list = NULL;
player->is_subtitle_force_drop = FALSE;
GstCaps *caps, gpointer data)
{
mmplayer_t *player = (mmplayer_t *)data;
- GstPad *pad = NULL;
MMPLAYER_FENTER();
__mmplayer_update_content_type_info(player);
- pad = gst_element_get_static_pad(tf, "src");
- if (!pad) {
- LOGE("fail to get typefind src pad.");
- return;
- }
+ if (!player->pipeline->mainbin[MMPLAYER_M_AUTOPLUG].gst) {
+ GstPad *pad = NULL;
- if (!_mmplayer_gst_create_decoder(player, pad, caps)) {
- gboolean async = FALSE;
- LOGE("failed to autoplug %s", player->type);
+ pad = gst_element_get_static_pad(tf, "src");
+ if (!pad) {
+ LOGE("fail to get typefind src pad.");
+ return;
+ }
- mm_attrs_get_int_by_name(player->attrs, "profile_prepare_async", &async);
+ if (!_mmplayer_gst_create_decoder(player, pad, caps)) {
+ gboolean async = FALSE;
+ LOGE("failed to autoplug %s", player->type);
- if (async && player->msg_posted == FALSE)
- __mmplayer_handle_missed_plugin(player);
+ mm_attrs_get_int_by_name(player->attrs, "profile_prepare_async", &async);
+ if (async && player->msg_posted == FALSE)
+ __mmplayer_handle_missed_plugin(player);
+ }
+ gst_object_unref(GST_OBJECT(pad));
}
-
- gst_object_unref(GST_OBJECT(pad));
-
MMPLAYER_FLEAVE();
-
return;
}
/* no-more-pad pad handling signal */
_mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "no-more-pads",
- G_CALLBACK(__mmplayer_gst_decode_no_more_pads), (gpointer)player);
+ G_CALLBACK(_mmplayer_gst_decode_no_more_pads), (gpointer)player);
_mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "pad-removed",
- G_CALLBACK(__mmplayer_gst_decode_pad_removed), (gpointer)player);
+ G_CALLBACK(_mmplayer_gst_decode_pad_removed), (gpointer)player);
/* This signal is emitted when a pad for which there is no further possible
decoding is added to the decodebin.*/
_mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "unknown-type",
- G_CALLBACK(__mmplayer_gst_decode_unknown_type), (gpointer)player);
+ G_CALLBACK(_mmplayer_gst_decode_unknown_type), (gpointer)player);
/* This signal is emitted whenever decodebin finds a new stream. It is emitted
before looking for any elements that can handle that stream.*/
_mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "autoplug-continue",
- G_CALLBACK(__mmplayer_gst_decode_autoplug_continue), (gpointer)player);
+ G_CALLBACK(_mmplayer_gst_decode_autoplug_continue), (gpointer)player);
if (player->need_video_dec_sorting || player->need_audio_dec_sorting)
_mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "autoplug-sort",
/* This signal is emitted once decodebin has finished decoding all the data.*/
_mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "drained",
- G_CALLBACK(__mmplayer_gst_decode_drained), (gpointer)player);
+ G_CALLBACK(_mmplayer_gst_decode_drained), (gpointer)player);
/* This signal is emitted when a element is added to the bin.*/
_mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "element-added",
return MM_ERROR_NONE;
}
-static void
-__mmplayer_pipeline_complete(GstElement *decodebin, gpointer data)
+void
+_mmplayer_pipeline_complete(GstElement *decodebin, gpointer data)
{
mmplayer_t *player = (mmplayer_t *)data;
/* remove fakesink. */
if (!_mmplayer_gst_remove_fakesink(player,
&player->pipeline->mainbin[MMPLAYER_M_SRC_FAKESINK])) {
- /* NOTE : __mmplayer_pipeline_complete() can be called several time. because
+ /* 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.
static gboolean
__mmplayer_deactivate_selector(mmplayer_t *player, mmplayer_track_type_e type)
{
- mmplayer_selector_t *selector = &player->selector[type];
+ mmplayer_track_t *selector = &player->track[type];
mmplayer_gst_element_t *sinkbin = NULL;
main_element_id_e selectorId = MMPLAYER_M_NUM;
main_element_id_e sinkId = MMPLAYER_M_NUM;
LOGD("selector release");
/* release and unref requests pad from the selector */
- for (n = 0; n < selector->channels->len; n++) {
- GstPad *sinkpad = g_ptr_array_index(selector->channels, n);
+ for (n = 0; n < selector->streams->len; n++) {
+ GstPad *sinkpad = g_ptr_array_index(selector->streams, n);
gst_element_release_request_pad((player->pipeline->mainbin[selectorId].gst), sinkpad);
}
- g_ptr_array_set_size(selector->channels, 0);
+
+ g_ptr_array_set_size(selector->streams, 0);
gst_element_set_state(player->pipeline->mainbin[selectorId].gst, GST_STATE_NULL);
gst_bin_remove(GST_BIN_CAST(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst), player->pipeline->mainbin[selectorId].gst);
return MM_ERROR_NONE;
}
-static void
-__mmplayer_gst_decode_unknown_type(GstElement *elem, GstPad *pad,
+void
+_mmplayer_gst_decode_unknown_type(GstElement *elem, GstPad *pad,
GstCaps *caps, gpointer data)
{
mmplayer_t *player = (mmplayer_t *)data;
__mmplayer_check_not_supported_codec(player, klass, mime);
}
-static gboolean
-__mmplayer_gst_decode_autoplug_continue(GstElement *bin, GstPad *pad,
- GstCaps *caps, gpointer data)
+gboolean
+_mmplayer_gst_decode_autoplug_continue(GstElement *bin, GstPad *pad,
+ GstCaps *caps, gpointer data)
{
mmplayer_t *player = (mmplayer_t *)data;
const char *mime = NULL;
return result;
}
-static void
-__mmplayer_gst_decode_pad_removed(GstElement *elem, GstPad *new_pad,
+void
+_mmplayer_gst_decode_pad_removed(GstElement *elem, GstPad *new_pad,
gpointer data)
{
//mmplayer_t *player = (mmplayer_t *)data;
gst_caps_unref(caps);
}
-static void
-__mmplayer_gst_decode_drained(GstElement *bin, gpointer data)
+void
+_mmplayer_gst_decode_drained(GstElement *bin, gpointer data)
{
mmplayer_t *player = (mmplayer_t *)data;
GstIterator *iter = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
- LOGD("__mmplayer_gst_decode_drained");
+ LOGD("got drained signal");
if (!MMPLAYER_CMD_TRYLOCK(player)) {
LOGW("Fail to get cmd lock");
}
static int
+__mmplayer_switch_stream(mmplayer_t *player, mmplayer_track_type_e type, int index)
+{
+ guint active_idx = 0;
+ GstStream *stream = NULL;
+ GList *streams = NULL;
+ GstEvent *ev = NULL;
+
+ LOGD("Switching Streams... type: %d, index: %d", type, index);
+
+ player->track[type].active_track_index = index;
+
+ for (int i = 0; i < MM_PLAYER_TRACK_TYPE_MAX; i++) {
+ /* FIXME: need to consider the non display type or audio only in case of MM_PLAYER_TRACK_TYPE_VIDEO */
+ if (player->track[i].total_track_num > 0) {
+ active_idx = player->track[i].active_track_index;
+ stream = g_ptr_array_index(player->track[i].streams, active_idx);
+ streams = g_list_append (streams, (gchar *)gst_stream_get_stream_id(stream));
+ LOGD("Selecting %d type stream : %s\n", i, gst_stream_get_stream_id(stream));
+ }
+ }
+
+ ev = gst_event_new_select_streams(streams);
+ gst_element_send_event(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, ev);
+ g_list_free(streams);
+
+ return MM_ERROR_NONE;
+}
+
+static int
__mmplayer_change_selector_pad(mmplayer_t *player, mmplayer_track_type_e type, int index)
{
int result = MM_ERROR_NONE;
goto EXIT;
}
- total_track_num = player->selector[type].total_track_num;
+ total_track_num = player->track[type].total_track_num;
if (total_track_num <= 0) {
result = MM_ERROR_PLAYER_NO_OP;
LOGD("Language list is not available");
gint current_active_index = 0;
GstState current_state = GST_STATE_VOID_PENDING;
- GstEvent *event = NULL;
gint64 time = 0;
MMPLAYER_FENTER();
if (!player->pipeline) {
LOGE("Track %d pre setting -> %d", type, index);
- player->selector[type].active_pad_index = index;
+ player->track[type].active_track_index = index;
goto EXIT;
}
mainbin = player->pipeline->mainbin;
- current_active_index = player->selector[type].active_pad_index;
+ current_active_index = player->track[type].active_track_index;
/*If index is same as running index no need to change the pad*/
if (current_active_index == index)
goto EXIT;
}
- result = __mmplayer_change_selector_pad(player, type, index);
+ if (MMPLAYER_USE_URIDECODEBIN3(player)) {
+ result = __mmplayer_switch_stream(player, type, index);
+ } else {
+ result = __mmplayer_change_selector_pad(player, type, index);
+ }
if (result != MM_ERROR_NONE) {
- LOGE("change selector pad error");
+ LOGE("failed to change track");
goto EXIT;
}
- player->selector[type].active_pad_index = index;
+ player->track[type].active_track_index = index;
- if (current_state == GST_STATE_PLAYING) {
- event = gst_event_new_seek(player->playback_rate, 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) {
- _mmplayer_gst_send_event_to_sink(player, event);
- } else {
- result = MM_ERROR_PLAYER_INTERNAL;
- goto EXIT;
+ if (!MMPLAYER_USE_URIDECODEBIN3(player)) {
+ GstEvent *event = NULL;
+ if (current_state == GST_STATE_PLAYING) {
+ event = gst_event_new_seek(player->playback_rate, 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) {
+ _mmplayer_gst_send_event_to_sink(player, event);
+ } else {
+ result = MM_ERROR_PLAYER_INTERNAL;
+ goto EXIT;
+ }
}
}