/* '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; }