/* 'pos' parameter is in milliseconds. */
int video_seek(int pos, int flags)
{
gint64 len, cur;
GstFormat fmt = GST_FORMAT_TIME;
GstElement *sink = get_sink();
if (!sink) return VIDEO_ERROR;
if (!(gst_element_query(sink, GST_QUERY_POSITION, &fmt, &cur) &&
gst_element_query(sink, GST_QUERY_TOTAL, &fmt, &len)))
return VIDEO_ERROR;
if (flags & VIDEO_SEEK_RELATIVE)
cur += pos * GST_SECOND;
else
cur = pos * GST_SECOND;
if (cur >= len) return video_stop();
if (cur <= 0) cur = 0;
if (!gst_element_seek(
sink,
GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH | GST_FORMAT_TIME,
cur))
return VIDEO_ERROR;
return VIDEO_OK;
}
bool GstPipe::speed(gdouble speed) {
g_debug("GstPipeliner::speed %f", speed);
speed_ = speed;
GstQuery *query;
gboolean res;
// query position
query = gst_query_new_position(GST_FORMAT_TIME);
res = gst_element_query(pipeline_, query);
gint64 cur_pos = 0;
if (res) {
gst_query_parse_position(query, nullptr, &cur_pos);
g_debug("cur pos = %" GST_TIME_FORMAT "\n", GST_TIME_ARGS(cur_pos));
} else {
g_warning("position query failed...");
}
gst_query_unref(query);
gboolean ret;
ret = gst_element_seek(pipeline_,
speed,
GST_FORMAT_TIME,
(GstSeekFlags) (GST_SEEK_FLAG_FLUSH |
GST_SEEK_FLAG_ACCURATE),
GST_SEEK_TYPE_SET,
cur_pos, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
if (!ret)
g_debug("speed not handled\n");
return true;
}
static gboolean
play_do_seek (GstElement * pipeline, gint64 pos, gdouble rate,
GstPlayTrickMode mode)
{
GstSeekFlags seek_flags;
GstQuery *query;
GstEvent *seek;
gboolean seekable = FALSE;
query = gst_query_new_seeking (GST_FORMAT_TIME);
if (!gst_element_query (pipeline, query)) {
gst_query_unref (query);
return FALSE;
}
gst_query_parse_seeking (query, NULL, &seekable, NULL, NULL);
gst_query_unref (query);
if (!seekable)
return FALSE;
seek_flags = GST_SEEK_FLAG_FLUSH;
switch (mode) {
case GST_PLAY_TRICK_MODE_DEFAULT:
seek_flags |= GST_SEEK_FLAG_TRICKMODE;
break;
case GST_PLAY_TRICK_MODE_DEFAULT_NO_AUDIO:
seek_flags |= GST_SEEK_FLAG_TRICKMODE | GST_SEEK_FLAG_TRICKMODE_NO_AUDIO;
break;
case GST_PLAY_TRICK_MODE_KEY_UNITS:
seek_flags |= GST_SEEK_FLAG_TRICKMODE_KEY_UNITS;
break;
case GST_PLAY_TRICK_MODE_KEY_UNITS_NO_AUDIO:
seek_flags |=
GST_SEEK_FLAG_TRICKMODE_KEY_UNITS | GST_SEEK_FLAG_TRICKMODE_NO_AUDIO;
break;
case GST_PLAY_TRICK_MODE_NONE:
default:
break;
}
if (rate >= 0)
seek = gst_event_new_seek (rate, GST_FORMAT_TIME,
seek_flags | GST_SEEK_FLAG_ACCURATE,
/* start */ GST_SEEK_TYPE_SET, pos,
/* stop */ GST_SEEK_TYPE_SET, GST_CLOCK_TIME_NONE);
else
seek = gst_event_new_seek (rate, GST_FORMAT_TIME,
seek_flags | GST_SEEK_FLAG_ACCURATE,
/* start */ GST_SEEK_TYPE_SET, 0,
/* stop */ GST_SEEK_TYPE_SET, pos);
if (!gst_element_send_event (pipeline, seek))
return FALSE;
cur_rate = rate;
trick_mode = mode;
return TRUE;
}
static void
check_uri_for_location (GstElement * e, const gchar * location,
const gchar * uri)
{
GstQuery *query;
gchar *query_uri = NULL;
g_object_set (e, "location", location, NULL);
query = gst_query_new_uri ();
fail_unless (gst_element_query (e, query));
gst_query_parse_uri (query, &query_uri);
gst_query_unref (query);
if (uri != NULL) {
fail_unless_equals_string (query_uri, uri);
} else {
gchar *fn;
fail_unless (gst_uri_is_valid (query_uri));
fn = g_filename_from_uri (query_uri, NULL, NULL);
fail_unless (g_path_is_absolute (fn));
fail_unless (fn != NULL);
g_free (fn);
}
g_free (query_uri);
}
P_INVOKE gboolean
bp_can_seek (BansheePlayer *player)
{
GstQuery *query;
gboolean can_seek = TRUE;
g_return_val_if_fail (IS_BANSHEE_PLAYER (player), FALSE);
if (player->playbin == NULL) {
return FALSE;
}
query = gst_query_new_seeking (GST_FORMAT_TIME);
if (!gst_element_query (player->playbin, query)) {
// This will probably fail, 100% of the time, because it's apparently
// very unimplemented in GStreamer... when it's fixed
// we will return FALSE here, and show the warning
// g_warning ("Could not query pipeline for seek ability");
return bp_get_duration (player) > 0;
}
gst_query_parse_seeking (query, NULL, &can_seek, NULL, NULL);
gst_query_unref (query);
return can_seek && bp_get_duration (player) > 0;
}
float MediaPlayerPrivate::currentTime() const
{
if (!m_playBin)
return 0;
if (m_errorOccured)
return 0;
float ret = 0.0;
GstQuery* query = gst_query_new_position(GST_FORMAT_TIME);
if (!gst_element_query(m_playBin, query)) {
LOG_VERBOSE(Media, "Position query failed...");
gst_query_unref(query);
return ret;
}
gint64 position;
gst_query_parse_position(query, 0, &position);
ret = (float) (position / 1000000000.0);
LOG_VERBOSE(Media, "Position %" GST_TIME_FORMAT, GST_TIME_ARGS(position));
gst_query_unref(query);
return ret;
}
static void
check_uri_for_uri (GstElement * e, const gchar * in_uri, const gchar * uri)
{
GstQuery *query;
gchar *query_uri = NULL;
gst_uri_handler_set_uri (GST_URI_HANDLER (e), in_uri, NULL);
query = gst_query_new_uri ();
fail_unless (gst_element_query (e, query));
gst_query_parse_uri (query, &query_uri);
gst_query_unref (query);
if (uri != NULL) {
fail_unless_equals_string (query_uri, uri);
} else {
gchar *fn;
fail_unless (gst_uri_is_valid (query_uri));
fn = g_filename_from_uri (query_uri, NULL, NULL);
fail_unless (g_path_is_absolute (fn));
fail_unless (fn != NULL);
g_free (fn);
}
g_free (query_uri);
}
static void handle_message (CustomData *data, GstMessage *msg) {
GError *err;
gchar *debug_info;
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_ERROR:
gst_message_parse_error (msg, &err, &debug_info);
g_printerr ("Error received from element %s: %s\n", GST_OBJECT_NAME (msg->src), err->message);
g_printerr ("Debugging information: %s\n", debug_info ? debug_info : "none");
g_clear_error (&err);
g_free (debug_info);
data->terminate = TRUE;
break;
case GST_MESSAGE_EOS:
g_print ("End-Of-Stream reached.\n");
data->terminate = TRUE;
break;
case GST_MESSAGE_DURATION:
/* The duration has changed, mark the current one as invalid */
data->duration = GST_CLOCK_TIME_NONE;
break;
case GST_MESSAGE_STATE_CHANGED: {
GstState old_state, new_state, pending_state;
gst_message_parse_state_changed (msg, &old_state, &new_state, &pending_state);
if (GST_MESSAGE_SRC (msg) == GST_OBJECT (data->playbin2)) {
g_print ("Pipeline state changed from %s to %s:\n",
gst_element_state_get_name (old_state), gst_element_state_get_name (new_state));
/* Remember whether we are in the PLAYING state or not */
data->playing = (new_state == GST_STATE_PLAYING);
if (data->playing) {
/* We just moved to PLAYING. Check if seeking is possible */
GstQuery *query;
gint64 start, end;
query = gst_query_new_seeking (GST_FORMAT_TIME);
if (gst_element_query (data->playbin2, query)) {
gst_query_parse_seeking (query, NULL, &data->seek_enabled, &start, &end);
if (data->seek_enabled) {
g_print ("Seeking is ENABLED from %" GST_TIME_FORMAT " to %" GST_TIME_FORMAT "\n",
GST_TIME_ARGS (start), GST_TIME_ARGS (end));
} else {
g_print ("Seeking is DISABLED for this stream.\n");
}
}
else {
g_printerr ("Seeking query failed.");
}
gst_query_unref (query);
}
}
} break;
default:
/* We should not reach here */
g_printerr ("Unexpected message received.\n");
break;
}
gst_message_unref (msg);
}
int video_get_pos_frames(unsigned long *_pos, unsigned long *_len)
{
gint64 len, pos;
GstFormat fmt = GST_FORMAT_DEFAULT;
GstElement *sink = get_sink();
if (!sink) return VIDEO_ERROR;
if (gst_element_query (sink, GST_QUERY_POSITION, &fmt, &pos) &&
gst_element_query (sink, GST_QUERY_TOTAL, &fmt, &len))
{
*_pos = pos;
*_len = len;
return VIDEO_OK;
}
return VIDEO_ERROR;
}
int video_get_pos_msec(unsigned long *_pos, unsigned long *_len)
{
gint64 len, pos;
GstFormat fmt = GST_FORMAT_TIME;
GstElement *sink = get_sink();
if (!sink) return VIDEO_ERROR;
if (gst_element_query (sink, GST_QUERY_POSITION, &fmt, &pos) &&
gst_element_query (sink, GST_QUERY_TOTAL, &fmt, &len))
{
*_pos = ((pos) / GST_MSECOND);
*_len = ((len) / GST_MSECOND);
return VIDEO_OK;
}
return VIDEO_ERROR;
}
uint64_t ofGstUtils::getMaxLatencyNanos(){
GstClockTime minlat=0, maxlat=0;
GstQuery * q = gst_query_new_latency();
if (gst_element_query (gstPipeline, q)) {
gboolean live;
gst_query_parse_latency (q, &live, &minlat, &maxlat);
}
gst_query_unref (q);
return maxlat;
}
static void
query_in_thread(gpointer data, G_GNUC_UNUSED gpointer user_data)
{
ThreadData *thread_data = (ThreadData *)data;
QueryData *query_data;
query_data = &(thread_data->data.query_data);
query_data->result = gst_element_query(thread_data->element,
query_data->query);
notify(thread_data);
}
void test_nonseeking()
{
GstElement *src;
GstQuery *seeking_query;
gint pipe_fd[2];
gchar data[4096];
gboolean seekable;
xmlfile = "fdsrc_test_nonseeking";
std_log(LOG_FILENAME_LINE, "Test Started test_nonseeking");
fail_if (pipe (pipe_fd) < 0);
src = setup_fdsrc ();
g_object_set (G_OBJECT (src), "num-buffers", 3, NULL);
g_object_set (G_OBJECT (src), "fd", pipe_fd[0], NULL);
fail_unless (gst_element_set_state (src,
GST_STATE_PAUSED) == GST_STATE_CHANGE_SUCCESS,
"could not set to paused");
memset (data, 0, 4096);
fail_if (write (pipe_fd[1], data, 256) < 0);
/* Test that fdsrc is non-seekable with a pipe */
fail_unless ((seeking_query = gst_query_new_seeking (GST_FORMAT_BYTES))
!= NULL);
fail_unless (gst_element_query (src, seeking_query) == TRUE);
gst_query_parse_seeking (seeking_query, NULL, &seekable, NULL, NULL);
fail_unless (seekable == FALSE);
gst_query_unref (seeking_query);
fail_unless (gst_element_set_state (src,
GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
/* cleanup */
cleanup_fdsrc (src);
close (pipe_fd[0]);
close (pipe_fd[1]);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
static void
test_position (InsanityTest * test, GstBuffer * buf)
{
GstQuery *query;
GstClockTimeDiff diff;
if (GST_BUFFER_PTS_IS_VALID (buf) == FALSE)
return;
if (GST_CLOCK_TIME_IS_VALID (glob_first_pos_point) == FALSE) {
glob_first_pos_point = gst_segment_to_stream_time (&glob_last_segment,
glob_last_segment.format, GST_BUFFER_PTS (buf));
}
glob_expected_pos = gst_segment_to_stream_time (&glob_last_segment,
glob_last_segment.format, GST_BUFFER_PTS (buf));
diff = ABS (GST_CLOCK_DIFF (glob_expected_pos, glob_first_pos_point));
if (diff < glob_playback_duration * GST_SECOND)
return;
query = gst_query_new_position (GST_FORMAT_TIME);
if (gst_element_query (glob_pipeline, query)) {
gint64 pos;
GstFormat fmt;
GstClockTimeDiff diff;
gst_query_parse_position (query, &fmt, &pos);
diff = ABS (GST_CLOCK_DIFF (glob_expected_pos, pos));
if (diff <= POSITION_THRESHOLD) {
insanity_test_validate_checklist_item (test, "position-detection", TRUE,
NULL);
} else {
gchar *validate_msg = g_strdup_printf ("Found position: %" GST_TIME_FORMAT
" expected: %" GST_TIME_FORMAT, GST_TIME_ARGS (pos),
GST_TIME_ARGS (glob_expected_pos));
insanity_test_validate_checklist_item (test, "position-detection",
FALSE, validate_msg);
g_free (validate_msg);
}
} else {
LOG (test,
"%s Does not handle position queries (position-detection \"SKIP\")",
gst_element_factory_get_metadata (gst_element_get_factory
(glob_demuxer), GST_ELEMENT_METADATA_LONGNAME));
}
next_test (test);
}
unsigned MediaPlayerPrivateGStreamerBase::videoDecodedByteCount() const
{
GstQuery* query = gst_query_new_position(GST_FORMAT_BYTES);
gint64 position = 0;
if (gst_element_query(m_webkitVideoSink.get(), query))
gst_query_parse_position(query, 0, &position);
gst_query_unref(query);
return static_cast<unsigned>(position);
}
void test_seeking()
{
GstElement *src;
gint in_fd;
GstQuery *seeking_query;
gboolean seekable;
xmlfile = "fdsrc_test_seeking";
std_log(LOG_FILENAME_LINE, "Test Started test_seeking");
#ifndef TESTFILE
#error TESTFILE not defined
#endif
in_fd = errno ;
fail_if ((in_fd = open ("c:\\data\\gstreamer\\warning.wav", O_RDONLY)) < 0);
src = setup_fdsrc ();
g_object_set (G_OBJECT (src), "fd", in_fd, NULL);
fail_unless (gst_element_set_state (src,
GST_STATE_PAUSED) == GST_STATE_CHANGE_SUCCESS,
"could not set to paused");
/* Test that fdsrc is seekable with a file fd */
fail_unless ((seeking_query = gst_query_new_seeking (GST_FORMAT_BYTES))
!= NULL);
fail_unless (gst_element_query (src, seeking_query) == TRUE);
gst_query_parse_seeking (seeking_query, NULL, &seekable, NULL, NULL);
fail_unless (seekable == TRUE);
gst_query_unref (seeking_query);
fail_unless (gst_element_set_state (src,
GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
/* cleanup */
cleanup_fdsrc (src);
close (in_fd);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
static void
pragha_backend_evaluate_if_can_seek(PraghaBackend *backend)
{
GstQuery *query;
PraghaBackendPrivate *priv = backend->priv;
query = gst_query_new_seeking (GST_FORMAT_TIME);
if (gst_element_query (priv->pipeline, query))
gst_query_parse_seeking (query, NULL, &priv->can_seek, NULL, NULL);
gst_query_unref (query);
}
static gboolean
print_position (GstValidateMonitor * monitor)
{
GstQuery *query;
gint64 position, duration;
JsonBuilder *jbuilder;
GstElement *pipeline =
GST_ELEMENT (GST_VALIDATE_MONITOR_GET_OBJECT (monitor));
gdouble rate = 1.0;
GstFormat format = GST_FORMAT_TIME;
if (!gst_element_query_position (pipeline, format, &position)) {
GST_DEBUG_OBJECT (monitor, "Could not query position");
return TRUE;
}
format = GST_FORMAT_TIME;
if (!gst_element_query_duration (pipeline, format, &duration)) {
GST_DEBUG_OBJECT (monitor, "Could not query duration");
return TRUE;
}
query = gst_query_new_segment (GST_FORMAT_DEFAULT);
if (gst_element_query (pipeline, query))
gst_query_parse_segment (query, &rate, NULL, NULL, NULL);
gst_query_unref (query);
jbuilder = json_builder_new ();
json_builder_begin_object (jbuilder);
json_builder_set_member_name (jbuilder, "type");
json_builder_add_string_value (jbuilder, "position");
json_builder_set_member_name (jbuilder, "position");
json_builder_add_int_value (jbuilder, position);
json_builder_set_member_name (jbuilder, "duration");
json_builder_add_int_value (jbuilder, duration);
json_builder_set_member_name (jbuilder, "speed");
json_builder_add_double_value (jbuilder, rate);
json_builder_end_object (jbuilder);
gst_validate_send (json_builder_get_root (jbuilder));
g_object_unref (jbuilder);
gst_validate_printf (NULL,
"<position: %" GST_TIME_FORMAT " duration: %" GST_TIME_FORMAT
" speed: %f />\r", GST_TIME_ARGS (position), GST_TIME_ARGS (duration),
rate);
return TRUE;
}
bool SourceObject::IsSeekable () const
{
std::shared_ptr<GstQuery> query (gst_query_new_seeking (GST_FORMAT_TIME), gst_query_unref);
if (!gst_element_query (GST_ELEMENT (Dec_), query.get ()))
return false;
gboolean seekable = false;
GstFormat format;
gint64 start = 0, stop = 0;
gst_query_parse_seeking (query.get (), &format, &seekable, &start, &stop);
return seekable;
}
static gboolean
impl_seekable (RBPlayer *player)
{
RBPlayerGst *mp = RB_PLAYER_GST (player);
gboolean can_seek = TRUE;
GstQuery *query;
if (mp->priv->playbin == NULL)
return FALSE;
query = gst_query_new_seeking (GST_FORMAT_TIME);
if (gst_element_query (mp->priv->playbin, query)) {
gst_query_parse_seeking (query, NULL, &can_seek, NULL, NULL);
} else {
gst_query_unref (query);
query = gst_query_new_duration (GST_FORMAT_TIME);
can_seek = gst_element_query (mp->priv->playbin, query);
}
gst_query_unref (query);
return can_seek;
}
static gboolean
time_tick_cb (GstElement * audiosink)
{
GstFormat format = GST_FORMAT_TIME;
guint64 total, pos;
if (gst_element_query (audiosink, GST_QUERY_TOTAL, &format, &total)
&& gst_element_query (audiosink, GST_QUERY_POSITION, &format, &pos)) {
guint t_min, t_sec, p_min, p_sec;
gchar *s;
t_min = (guint) (total / (GST_SECOND * 60));
t_sec = (guint) ((total % (GST_SECOND * 60)) / GST_SECOND);
p_min = (guint) (pos / (GST_SECOND * 60));
p_sec = (guint) ((pos % (GST_SECOND * 60)) / GST_SECOND);
s = g_strdup_printf ("%u:%02u / %u:%02u", p_min, p_sec, t_min, t_sec);
gtk_label_set_text (GTK_LABEL (poslabel), s);
g_free (s);
}
return TRUE; /* call again */
}
static void
relative_seek (GstPlay * play, gdouble percent)
{
GstQuery *query;
gboolean seekable = FALSE;
gint64 dur = -1, pos = -1, step;
g_return_if_fail (percent >= -1.0 && percent <= 1.0);
if (!gst_element_query_position (play->playbin, GST_FORMAT_TIME, &pos))
goto seek_failed;
query = gst_query_new_seeking (GST_FORMAT_TIME);
if (!gst_element_query (play->playbin, query)) {
gst_query_unref (query);
goto seek_failed;
}
gst_query_parse_seeking (query, NULL, &seekable, NULL, &dur);
gst_query_unref (query);
if (!seekable || dur <= 0)
goto seek_failed;
step = dur * percent;
if (ABS (step) < GST_SECOND)
step = (percent < 0) ? -GST_SECOND : GST_SECOND;
pos = pos + step;
if (pos > dur) {
if (!play_next (play)) {
g_print ("\n%s\n", _("Reached end of play list."));
g_main_loop_quit (play->loop);
}
} else {
if (pos < 0)
pos = 0;
play_do_seek (play, pos, play->rate, play->trick_mode);
}
return;
seek_failed:
{
g_print ("\nCould not seek.\n");
}
}
static void
relative_seek (GstPlay * play, gdouble percent)
{
GstQuery *query;
gboolean seekable = FALSE;
gint64 dur = -1, pos = -1;
g_return_if_fail (percent >= -1.0 && percent <= 1.0);
if (!gst_element_query_position (play->playbin, GST_FORMAT_TIME, &pos))
goto seek_failed;
query = gst_query_new_seeking (GST_FORMAT_TIME);
if (!gst_element_query (play->playbin, query)) {
gst_query_unref (query);
goto seek_failed;
}
gst_query_parse_seeking (query, NULL, &seekable, NULL, &dur);
gst_query_unref (query);
if (!seekable || dur <= 0)
goto seek_failed;
pos = pos + dur * percent;
if (pos > dur) {
if (!play_next (play)) {
g_print ("\nReached end of play list.\n");
g_main_loop_quit (play->loop);
}
} else {
if (pos < 0)
pos = 0;
if (!gst_element_seek_simple (play->playbin, GST_FORMAT_TIME,
GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT, pos))
goto seek_failed;
}
return;
seek_failed:
{
g_print ("\nCould not seek.\n");
}
}
static gboolean
display_current_fps (gpointer data)
{
GstFPSDisplaySink *self = GST_FPS_DISPLAY_SINK (data);
gint64 current_ts;
/* if query failed try again on next timer tick */
if (!gst_element_query (self->video_sink, self->query))
return TRUE;
gst_query_parse_position (self->query, NULL, ¤t_ts);
if (GST_CLOCK_TIME_IS_VALID (self->last_ts)) {
gdouble rr, dr, average_fps;
gchar fps_message[256];
gdouble time_diff = (gdouble) (current_ts - self->last_ts) / GST_SECOND;
rr = (gdouble) (self->frames_rendered -
self->last_frames_rendered) / time_diff;
dr = (gdouble) (self->frames_dropped -
self->last_frames_dropped) / time_diff;
average_fps = self->frames_rendered / (gdouble) (current_ts / GST_SECOND);
if (dr == 0.0) {
g_snprintf (fps_message, 255, "current: %.2f\naverage: %.2f", rr,
average_fps);
} else {
g_snprintf (fps_message, 255, "fps: %.2f\ndrop rate: %.2f", rr, dr);
}
if (self->use_text_overlay) {
g_object_set (self->text_overlay, "text", fps_message, NULL);
} else {
g_print ("%s\n", fps_message);
}
}
self->last_frames_rendered = self->frames_rendered;
self->last_frames_dropped = self->frames_dropped;
self->last_ts = current_ts;
return TRUE;
}
void LinVideoDisplayForm::updateProgress()
{
if (ui->seekSlider->isSliderDown())
{
// The user is moving the slider, so don't update it:
return;
}
GstQuery *query;
// Determine the duration of the stream:
gint64 duration = dataDialog->getDuration();
if (duration == 0)
{
// Duration not available; no point in continuing any further.
return;
}
gint64 position = 0;
// Determine the position of the stream:
query = gst_query_new_position(GST_FORMAT_TIME);
if (gst_element_query(runningElement, query))
{
gst_query_parse_position(query, NULL, &position);
}
gst_query_unref(query);
// Determine the percentage:
int percentage = (position * 100) / duration;
/*
QString percentString;
percentString.setNum(percentage);
percentString.append("%");
ui->percentageLabel->setText(percentString);
*/
ui->seekSlider->setValue(percentage);
}
bool GstVideoPlayerBackend::isSeekable() const
{
if (!m_pipeline)
return false;
GstQuery *query = gst_query_new_seeking(GST_FORMAT_TIME);
gboolean re = gst_element_query(m_pipeline, query);
if (re)
{
gboolean seekable;
gst_query_parse_seeking(query, 0, &seekable, 0, 0);
re = seekable;
}
else
qDebug() << "gstreamer: Failed to query seeking properties of the stream";
gst_query_unref(query);
return re;
}
static double
em_buffer_size_get(void *video)
{
Emotion_Gstreamer_Video *ev;
GstQuery *query;
gboolean busy;
gint percent;
ev = video;
if (!ev->pipeline) return 0.0;
query = gst_query_new_buffering(GST_FORMAT_DEFAULT);
if (gst_element_query(ev->pipeline, query))
gst_query_parse_buffering_percent(query, &busy, &percent);
else
percent = 100;
gst_query_unref(query);
return ((float)(percent)) / 100.0;
}
void
_bp_dvd_elements_process_message (BansheePlayer *player, GstMessage *message)
{
g_return_if_fail (IS_BANSHEE_PLAYER (player));
g_return_if_fail (message != NULL);
player->is_menu = FALSE;
// Get available command to know if player is in menu
GstQuery *query = gst_navigation_query_new_commands();
guint n_cmds, i;
if (!player->navigation) {
_bp_dvd_find_navigation (player);
}
if (!(gst_element_query (GST_ELEMENT_CAST (player->navigation), query)
&& gst_navigation_query_parse_commands_length (query, &n_cmds))) {
gst_query_unref (query);
return;
}
for (i = 0; i < n_cmds; i++) {
GstNavigationCommand cmd;
if (gst_navigation_query_parse_commands_nth (query, i, &cmd)) {
switch (cmd) {
case GST_NAVIGATION_COMMAND_ACTIVATE:
case GST_NAVIGATION_COMMAND_LEFT:
case GST_NAVIGATION_COMMAND_RIGHT:
case GST_NAVIGATION_COMMAND_UP:
case GST_NAVIGATION_COMMAND_DOWN:
player->is_menu = TRUE;
break;
default:
break;
}
}
}
gst_query_unref (query);
}
static gboolean
print_position (GstValidateMonitor * monitor)
{
GstQuery *query;
gint64 position, duration;
GstElement *pipeline =
GST_ELEMENT (GST_VALIDATE_MONITOR_GET_OBJECT (monitor));
gdouble rate = 1.0;
GstFormat format = GST_FORMAT_TIME;
if (!gst_element_query_position (pipeline, format, &position)) {
GST_DEBUG_OBJECT (monitor, "Could not query position");
return TRUE;
}
format = GST_FORMAT_TIME;
if (!gst_element_query_duration (pipeline, format, &duration)) {
GST_DEBUG_OBJECT (monitor, "Could not query duration");
return TRUE;
}
query = gst_query_new_segment (GST_FORMAT_DEFAULT);
if (gst_element_query (pipeline, query))
gst_query_parse_segment (query, &rate, NULL, NULL, NULL);
gst_query_unref (query);
gst_validate_printf (NULL,
"<position: %" GST_TIME_FORMAT " duration: %" GST_TIME_FORMAT
" speed: %f />\r", GST_TIME_ARGS (position), GST_TIME_ARGS (duration),
rate);
return TRUE;
}
float MediaPlayerPrivate::currentTime() const
{
if (!m_playBin)
return 0;
// Necessary as sometimes, gstreamer return 0:00 at the EOS
if (m_isEndReached)
return m_endTime;
float ret;
GstQuery* query = gst_query_new_position(GST_FORMAT_TIME);
if (gst_element_query(m_playBin, query)) {
gint64 position;
gst_query_parse_position(query, NULL, &position);
ret = (float) (position / 1000000000.0);
LOG_VERBOSE(Media, "Position %" GST_TIME_FORMAT, GST_TIME_ARGS(position));
} else {
LOG_VERBOSE(Media, "Position query failed...");
ret = 0.0;
}
gst_query_unref(query);
return ret;
}
