LOGW("duration : %lld msec", GST_TIME_AS_MSECONDS(dur_nsec));
}
+ if (player->duration < 0) {
+ LOGW("duration : %lld is Non-Initialized !!! \n",player->duration);
+ player->duration = 0;
+ }
+
/* try to get streaming service type */
stream_service_type = __mmplayer_get_stream_service_type(player);
mm_attrs_set_int_by_name(attrs, "streaming_type", stream_service_type);
case STREAMING_SERVICE_VOD:
LOGD("it's vod streaming");
break;
- case STREAMING_SERVICE_NONE:
- LOGE("should not get here");
- break;
default:
LOGE("should not get here");
}
int found = 0;
#define MMPLAYER_MAX_SOUND_PRIORITY 3
- /* it's first time to update all content attrs. */
- _mmplayer_update_content_attrs(player, ATTR_ALL);
+ /* rtsp case, get content attrs by GstMessage */
+ if (!MMPLAYER_IS_RTSP_STREAMING(player)) {
+ /* it's first time to update all content attrs. */
+ _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) {
case MM_PLAYER_STATE_NONE:
{
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)) {
- 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)) {
- LOGE("failed to get position\n");
- break;
- }
-
- /* key unit seek */
- pos_msec = position * G_GINT64_CONSTANT(1000000);
-
- __gst_seek(player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, 1.0,
- GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, GST_SEEK_TYPE_SET,
- pos_msec, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
+ /* rtsp streaming pause makes rtsp server stop sending data. */
+ if (!MMPLAYER_IS_RTSP_STREAMING(player)) {
+ LOGD("set pause state during buffering\n");
+ __gst_pause( player, TRUE );
}
}
}
break;
case MM_PLAYER_STATE_PLAYING:
- __gst_pause(player, TRUE);
+ /*[shweta.agg] rtsp streaming pause makes rtsp server stop sending data. */
+ if (!MMPLAYER_IS_RTSP_STREAMING(player)) {
+ __gst_pause ( player, TRUE );
+ }
break;
case MM_PLAYER_STATE_PAUSED:
case GST_MESSAGE_BUFFERING:
{
MMMessageParamType msg_param = {0, };
+ int bRet = MM_ERROR_NONE;
if (!MMPLAYER_IS_STREAMING(player))
break;
MMPLAYER_CMD_LOCK(player);
__mmplayer_update_buffer_setting(player, msg);
- if (__mmplayer_handle_buffering_message(player) == MM_ERROR_NONE) {
+ bRet = __mmplayer_handle_buffering_message(player);
+
+ if (bRet == 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->pending_resume &&
+ (player->streamer->buffering_percent >= MAX_BUFFER_PERCENT)) {
+
+ player->is_external_subtitle_added_now = FALSE;
+ player->pending_resume = FALSE;
+ _mmplayer_resume((MMHandleType)player);
+ }
+
if (MMPLAYER_IS_RTSP_STREAMING(player) &&
- (player->streamer->buffering_percent >= MAX_BUFFER_PERCENT)) {
+ (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;
+ }
+ }
+ }
+ } else if (bRet == MM_ERROR_PLAYER_INVALID_STATE) {
+ if (!player->streamer) {
+ LOGW("player->streamer is NULL, so discarding the buffering percent update\n");
+ break;
+ }
+
+ if ((MMPLAYER_IS_LIVE_STREAMING(player)) && (MMPLAYER_IS_RTSP_STREAMING(player))) {
+
+ LOGD("player->last_position=%lld , player->streamer->buffering_percent=%d \n",
+ GST_TIME_AS_SECONDS(player->last_position), player->streamer->buffering_percent);
+
+ if ((GST_TIME_AS_SECONDS(player->last_position) <= 0) && (MMPLAYER_CURRENT_STATE(player) == MM_PLAYER_STATE_PAUSED)) {
+ msg_param.connection.buffering = player->streamer->buffering_percent;
+ MMPLAYER_POST_MSG( player, MM_MESSAGE_BUFFERING, &msg_param );
+ } else {
+ LOGD("Not updating Buffering Message for Live RTSP case !!!\n");
}
+ } else {
+ msg_param.connection.buffering = player->streamer->buffering_percent;
+ MMPLAYER_POST_MSG( player, MM_MESSAGE_BUFFERING, &msg_param );
}
}
MMPLAYER_CMD_UNLOCK(player);
gst_element_state_get_name((GstState)newstate),
gst_element_state_get_name((GstState)pending));
+ if (newstate == GST_STATE_PLAYING) {
+ if ((MMPLAYER_IS_RTSP_STREAMING(player)) && (player->pending_seek.is_pending)) {
+
+ int retVal = MM_ERROR_NONE;
+ LOGD("trying to play from (%lu) pending position\n", player->pending_seek.pos);
+
+ retVal = __gst_set_position( player, player->pending_seek.format, player->pending_seek.pos, TRUE );
+
+ if (MM_ERROR_NONE != retVal)
+ LOGE("failed to seek pending postion. just keep staying current position.\n");
+
+ player->pending_seek.is_pending = FALSE;
+ }
+ }
+
if (oldstate == newstate) {
LOGD("pipeline reports state transition to old state");
break;
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 (MMPLAYER_IS_RTSP_STREAMING(player) && (MMPLAYER_IS_LIVE_STREAMING(player))) {
+
+ LOGD("Current Buffering Percent = %d",player->streamer->buffering_percent);
+ if (player->streamer->buffering_percent < 100) {
+
+ MMMessageParamType msg_param = {0, };
+ LOGW("Posting Buffering Completed Message to Application !!!");
+
+ msg_param.connection.buffering = 100;
+ MMPLAYER_POST_MSG ( player, MM_MESSAGE_BUFFERING, &msg_param );
+ }
+ }
}
if (player->gapless.stream_changed) {
msg_param.code = MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND;
MMPLAYER_POST_MSG(player, MM_MESSAGE_ERROR, &msg_param);
}
+
+ /* custom message for RTSP attribute :
+ RTSP case, buffer is not come from server before PLAYING state. However,we have to get attribute after PAUSE state chaged.
+ sdp which has contents info is received when rtsp connection is opened.
+ extract duration ,codec info , resolution from sdp and get it by GstMessage */
+ if (!strcmp(structure_name, "rtspsrc_properties")) {
+
+ gchar *audio_codec = NULL;
+ gchar *video_codec = NULL;
+ gchar *video_frame_size = NULL;
+
+ gst_structure_get(gst_message_get_structure(msg), "rtsp_duration", G_TYPE_UINT64, &player->duration, NULL);
+ LOGD("rtsp duration : %lld msec", GST_TIME_AS_MSECONDS(player->duration));
+ __mmplayer_get_stream_service_type(player);
+ mm_attrs_set_int_by_name(attrs, "content_duration", GST_TIME_AS_MSECONDS(player->duration));
+
+ gst_structure_get(gst_message_get_structure(msg), "rtsp_audio_codec", G_TYPE_STRING, &audio_codec, NULL);
+ LOGD("rtsp_audio_codec : %s", audio_codec);
+ if (audio_codec)
+ mm_attrs_set_string_by_name(player->attrs, "content_audio_codec", audio_codec);
+
+ gst_structure_get(gst_message_get_structure(msg), "rtsp_video_codec", G_TYPE_STRING, &video_codec, NULL);
+ LOGD("rtsp_video_codec : %s", video_codec);
+ if (video_codec)
+ mm_attrs_set_string_by_name(player->attrs, "content_video_codec", video_codec);
+
+ gst_structure_get(gst_message_get_structure(msg), "rtsp_video_frame_size", G_TYPE_STRING, &video_frame_size, NULL);
+ LOGD("rtsp_video_frame_size : %s", video_frame_size);
+ if (video_frame_size) {
+
+ char *seperator = strchr(video_frame_size, '-');
+ if (seperator) {
+
+ char video_width[10]={0,};
+ int frame_size_len = strlen(video_frame_size);
+ int separtor_len = strlen(seperator);
+
+ strncpy(video_width,video_frame_size,(frame_size_len-separtor_len));
+ mm_attrs_set_int_by_name(attrs, "content_video_width", atoi(video_width));
+
+ seperator++;
+ mm_attrs_set_int_by_name(attrs, "content_video_height", atoi(seperator));
+ }
+ }
+
+ if (mmf_attrs_commit(attrs))
+ LOGE("failed to commit.\n");
+ }
}
break;
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 ((MMPLAYER_IS_RTSP_STREAMING(player)) ||
+ (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);
}
g_timer_destroy(timer);
return ret;
- } else if (!player->video_stream_cb && (!player->pipeline->videobin) && (!player->pipeline->audiobin)) {
- if (MMPLAYER_IS_RTSP_STREAMING(player))
- return ret;
+
+ } else if ((!MMPLAYER_IS_RTSP_STREAMING(player)) && (!player->video_stream_cb) &&
+ (!player->pipeline->videobin) && (!player->pipeline->audiobin)) {
+
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 */
*/
if (!player->duration) {
if (!gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &dur_nsec))
+ {
+ /* [prasenjit.c] For RTSP Streaming , duration is not returned in READY state. So seek to the previous position does not work properly.
+ * Added a patch to postpone the actual seek when state changes to PLAY. Sending a fake SEEK_COMPLETED event to finish the current request. */
+ if ((MMPLAYER_IS_RTSP_STREAMING( player )) && (__mmplayer_get_stream_service_type(player) != STREAMING_SERVICE_LIVE)) {
+ player->pending_seek.is_pending = TRUE;
+ player->pending_seek.format = format;
+ player->pending_seek.pos = position;
+ player->doing_seek = FALSE;
+ MMPLAYER_POST_MSG ( player, MM_MESSAGE_SEEK_COMPLETED, NULL );
+ return MM_ERROR_NONE;
+ } else
goto SEEK_ERROR;
+ }
player->duration = dur_nsec;
}
LOGD("seeking to(%lu) msec, duration is %d msec\n", position, dur_msec);
+ /*
+ [prasenjit.c] For rtspsrc stack , npt-start value coming from server is used for finding the current position.
+ But when a rtsp clip (especially from Youtube Desktop View) is paused and kept for sometime,npt-start is still increasing.
+ This causes problem is position calculation during normal pause resume scenarios also.
+ Currently during seek , we are sending the current position to rtspsrc module for position saving for later use.
+ */
+ if ((MMPLAYER_IS_RTSP_STREAMING( player )) &&
+ (__mmplayer_get_stream_service_type(player) != STREAMING_SERVICE_LIVE)) {
+ if (!gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &pos_nsec))
+ LOGW("getting current position failed in seek\n");
+
+ player->last_position = pos_nsec;
+ g_object_set( player->pipeline->mainbin[MMPLAYER_M_SRC].gst, "resume-position", player->last_position, NULL );
+ }
+
if (player->doing_seek) {
LOGD("not completed seek");
return MM_ERROR_PLAYER_DOING_SEEK;
if (event)
__gst_send_event_to_sink(player, event);
- __gst_pause(player, FALSE);
+ if (!MMPLAYER_IS_RTSP_STREAMING(player))
+ __gst_pause(player, FALSE);
+ }
+
+ /* rtsp streaming case, there is no sink after READY TO PAUSE state(no preroll state change).
+ that's why set position through property. */
+ if ((MMPLAYER_IS_RTSP_STREAMING(player)) &&
+ (MMPLAYER_CURRENT_STATE(player) == MM_PLAYER_STATE_PAUSED) &&
+ (MMPLAYER_PREV_STATE(player) == MM_PLAYER_STATE_READY) &&
+ (!player->videodec_linked) && (!player->audiodec_linked)) {
+
+ g_object_set(player->pipeline->mainbin[MMPLAYER_M_SRC].gst, "pending-start-position", pos_nsec, NULL);
+ LOGD("[%s] set position =%"GST_TIME_FORMAT,
+ gst_element_get_name(player->pipeline->mainbin[MMPLAYER_M_SRC].gst), GST_TIME_ARGS(pos_nsec));
+ player->doing_seek = FALSE;
+ MMPLAYER_POST_MSG(player, MM_MESSAGE_SEEK_COMPLETED, NULL);
+ } else {
+ 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);
}
- 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;
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);
+ if (player->duration <= 0) {
+ LOGD("duration is [%lld], so returning position 0\n", player->duration);
*position = 0;
} else {
- pos = pos_msec / GST_SECOND;
- *position = pos * 100 / dur;
+ LOGD("postion is [%lld] msec , duration is [%lld] msec", pos_msec, player->duration);
+ *position = pos_msec * 100 / player->duration;
}
break;
}
player->has_closed_caption = FALSE;
player->video_num_buffers = DEFAULT_NUM_OF_V_OUT_BUFFER;
player->video_extra_num_buffers = DEFAULT_NUM_OF_V_OUT_BUFFER;
+ player->pending_resume = FALSE;
if (player->ini.dump_element_keyword[0][0] == '\0')
player->ini.set_dump_element_flag = FALSE;
else
player->audiosink_linked = 0;
player->textsink_linked = 0;
player->is_external_subtitle_present = FALSE;
+ player->is_external_subtitle_added_now = FALSE;
/* set the subtitle ON default */
player->is_subtitle_off = FALSE;
*/
mm_attrs_get_int_by_name(player->attrs, "profile_prepare_async", &async);
LOGD("prepare working mode : %s", (async ? "async" : "sync"));
+
+ /* [shweta.agg] Changing back sync of rtspsrc to async */
+ if (MMPLAYER_IS_RTSP_STREAMING(player)) {
+ LOGD("async prepare working mode for rtsp");
+ async = TRUE;
+ }
}
break;
LOGW("getting current position failed in paused\n");
player->last_position = pos_msec;
+ /*
+ [prasenjit.c] For rtspsrc stack , npt-start value coming from server is used for finding the current position.
+ But when a rtsp clip (especially from Youtube Desktop View) is paused and kept for sometime,npt-start is still increasing.
+ This causes problem is position calculation during normal pause resume scenarios also.
+ Currently during pause , we are sending the current position to rtspsrc module for position saving.
+ */
+ if ((MMPLAYER_IS_RTSP_STREAMING( player )) &&
+ (__mmplayer_get_stream_service_type(player) != STREAMING_SERVICE_LIVE)) {
+ g_object_set( player->pipeline->mainbin[MMPLAYER_M_SRC].gst, "resume-position", player->last_position, NULL );
+ }
}
break;
}
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ /* [shweta.agg] Changing back sync mode rtspsrc to async */
+ if ((MMPLAYER_IS_RTSP_STREAMING(player))) {
+ LOGD("async resume for rtsp case");
+ async = TRUE;
+ }
+
ret = _mmplayer_sound_acquire_focus(&player->sound_focus);
if (ret != MM_ERROR_NONE) {
LOGE("failed to acquire sound focus.\n");
player->audiosink_linked = 0;
player->textsink_linked = 0;
player->is_external_subtitle_present = FALSE;
+ player->is_external_subtitle_added_now = FALSE;
player->not_supported_codec = MISSING_PLUGIN_NONE;
player->can_support_codec = FOUND_PLUGIN_NONE;
player->pending_seek.is_pending = FALSE;
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
MMPLAYER_RETURN_VAL_IF_FAIL(event, FALSE);
+ /*[shweta.agg] While adding subtitles in live feeds seek is getting called.
+ Adding defensive check in framework layer.*/
+ if (GST_EVENT_TYPE(event) == GST_EVENT_SEEK) {
+ if (MMPLAYER_IS_LIVE_STREAMING (player)) {
+ LOGE ("Should not send seek event during live playback");
+ return TRUE;
+ }
+ }
+
if (player->play_subtitle && !player->use_textoverlay)
event2 = gst_event_copy((const GstEvent *)event);
/* 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 (GST_EVENT_TYPE(event) == GST_EVENT_SEEK) {
if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PAUSED) {
LOGD("RTSP seek completed, after pause state..\n");
player->doing_seek = FALSE;
result = _mmplayer_sync_subtitle_pipeline(player);
} else
result = __mmplayer_change_external_subtitle_language(player, filepath);
+
+ player->is_external_subtitle_added_now = TRUE;
}
MMPLAYER_FLEAVE();
projects / platform / core / multimedia / libmm-player.git / commitdiff