static gboolean gst_gio_base_sink_query (GstPad * pad, GstQuery * query) { GstGioBaseSink *sink = GST_GIO_BASE_SINK (GST_PAD_PARENT (pad)); GstFormat format; switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: gst_query_parse_position (query, &format, NULL); switch (format) { case GST_FORMAT_BYTES: case GST_FORMAT_DEFAULT: gst_query_set_position (query, GST_FORMAT_BYTES, sink->position); return TRUE; default: return FALSE; } case GST_QUERY_FORMATS: gst_query_set_formats (query, 2, GST_FORMAT_DEFAULT, GST_FORMAT_BYTES); return TRUE; case GST_QUERY_URI: if (GST_IS_URI_HANDLER (sink)) { const gchar *uri; uri = gst_uri_handler_get_uri (GST_URI_HANDLER (sink)); gst_query_set_uri (query, uri); return TRUE; } return FALSE; default: return gst_pad_query_default (pad, query); } }
static gboolean gst_vdp_mpeg_dec_src_query (GstPad * pad, GstQuery * query) { GstVdpMpegDec *mpeg_dec = GST_VDP_MPEG_DEC (gst_pad_get_parent (pad)); gboolean res; switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: { GstFormat format; if ((res = gst_pad_query_default (pad, query))) goto done; gst_query_parse_position (query, &format, NULL); if (format == GST_FORMAT_TIME && GST_CLOCK_TIME_IS_VALID (mpeg_dec->next_timestamp)) { gst_query_set_position (query, GST_FORMAT_TIME, mpeg_dec->next_timestamp); res = TRUE; } break; } case GST_QUERY_DURATION: { GstFormat format; if ((res = gst_pad_query_default (pad, query))) goto done; gst_query_parse_duration (query, &format, NULL); if (format == GST_FORMAT_TIME) { gint64 bytes; format = GST_FORMAT_BYTES; if (gst_pad_query_duration (pad, &format, &bytes) && format == GST_FORMAT_BYTES) { gint64 duration; if (gst_vdp_mpeg_dec_convert (mpeg_dec, GST_FORMAT_BYTES, bytes, GST_FORMAT_TIME, &duration)) { GST_DEBUG ("duration: %" GST_TIME_FORMAT, GST_TIME_ARGS (duration)); gst_query_set_duration (query, GST_FORMAT_TIME, duration); res = TRUE; } } } break; } default: res = gst_pad_query_default (pad, query); } done: gst_object_unref (mpeg_dec); return res; }
static gboolean gst_file_sink_query (GstPad * pad, GstQuery * query) { GstFileSink *self; GstFormat format; self = GST_FILE_SINK (GST_PAD_PARENT (pad)); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: gst_query_parse_position (query, &format, NULL); switch (format) { case GST_FORMAT_DEFAULT: case GST_FORMAT_BYTES: gst_query_set_position (query, GST_FORMAT_BYTES, self->current_pos); return TRUE; default: return FALSE; } case GST_QUERY_FORMATS: gst_query_set_formats (query, 2, GST_FORMAT_DEFAULT, GST_FORMAT_BYTES); return TRUE; case GST_QUERY_URI: gst_query_set_uri (query, self->uri); return TRUE; default: return gst_pad_query_default (pad, query); } }
static gboolean gst_gnome_vfs_sink_query (GstPad * pad, GstQuery * query) { GstGnomeVFSSink *sink; GstFormat format; sink = GST_GNOME_VFS_SINK (GST_PAD_PARENT (pad)); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: gst_query_parse_position (query, &format, NULL); switch (format) { case GST_FORMAT_DEFAULT: case GST_FORMAT_BYTES: gst_query_set_position (query, GST_FORMAT_BYTES, sink->current_pos); return TRUE; default: return FALSE; } case GST_QUERY_FORMATS: gst_query_set_formats (query, 2, GST_FORMAT_DEFAULT, GST_FORMAT_BYTES); return TRUE; case GST_QUERY_URI: gst_query_set_uri (query, sink->uri_name); return TRUE; default: return gst_pad_query_default (pad, query); } }
static gboolean gst_nsfdec_src_query (GstPad * pad, GstQuery * query) { gboolean res = TRUE; GstNsfDec *nsfdec; nsfdec = GST_NSFDEC (gst_pad_get_parent (pad)); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: { GstFormat format; gint64 current; gst_query_parse_position (query, &format, NULL); /* we only know about our bytes, convert to requested format */ res &= gst_nsfdec_src_convert (pad, GST_FORMAT_BYTES, nsfdec->total_bytes, &format, ¤t); if (res) { gst_query_set_position (query, format, current); } break; } default: res = gst_pad_query_default (pad, query); break; } gst_object_unref (nsfdec); return res; }
static gboolean gst_multi_file_src_query (GstBaseSrc * src, GstQuery * query) { gboolean res; GstMultiFileSrc *mfsrc; mfsrc = GST_MULTI_FILE_SRC (src); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: { GstFormat format; gst_query_parse_position (query, &format, NULL); switch (format) { case GST_FORMAT_BUFFERS: case GST_FORMAT_DEFAULT: gst_query_set_position (query, GST_FORMAT_BUFFERS, mfsrc->index); res = TRUE; break; default: res = GST_BASE_SRC_CLASS (parent_class)->query (src, query); break; } break; } default: res = GST_BASE_SRC_CLASS (parent_class)->query (src, query); break; } return res; }
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; }
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 gboolean gst_interleave_src_query (GstPad * pad, GstObject * parent, GstQuery * query) { GstInterleave *self = GST_INTERLEAVE (parent); gboolean res = FALSE; switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: { GstFormat format; gst_query_parse_position (query, &format, NULL); switch (format) { case GST_FORMAT_TIME: /* FIXME, bring to stream time, might be tricky */ gst_query_set_position (query, format, self->timestamp); res = TRUE; break; case GST_FORMAT_BYTES: gst_query_set_position (query, format, self->offset * self->channels * self->width); res = TRUE; break; case GST_FORMAT_DEFAULT: gst_query_set_position (query, format, self->offset); res = TRUE; break; default: break; } break; } case GST_QUERY_DURATION: res = gst_interleave_src_query_duration (self, query); break; case GST_QUERY_LATENCY: res = gst_interleave_src_query_latency (self, query); break; case GST_QUERY_CAPS: { GstCaps *filter, *caps; gst_query_parse_caps (query, &filter); caps = gst_interleave_sink_getcaps (pad, parent, filter); gst_query_set_caps_result (query, caps); gst_caps_unref (caps); res = TRUE; } default: /* FIXME, needs a custom query handler because we have multiple * sinkpads */ res = gst_pad_query_default (pad, parent, query); break; } return res; }
static gboolean gst_schro_dec_src_query (GstPad *pad, GstQuery *query) { GstSchroDec *dec; gboolean res = FALSE; dec = GST_SCHRO_DEC (gst_pad_get_parent(pad)); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: { GstFormat format; gint64 time; gint64 value; gst_query_parse_position (query, &format, NULL); time = gst_util_uint64_scale (granulepos_to_frame (dec->granulepos), dec->fps_n, dec->fps_d); //time -= dec->segment.start; time += dec->segment.time; GST_DEBUG("query position %lld", time); res = gst_schro_dec_src_convert (pad, GST_FORMAT_TIME, time, &format, &value); if (!res) goto error; gst_query_set_position (query, format, value); break; } case GST_QUERY_DURATION: res = gst_pad_query (GST_PAD_PEER (dec->sinkpad), query); if (!res) goto error; break; case GST_QUERY_CONVERT: { GstFormat src_fmt, dest_fmt; gint64 src_val, dest_val; gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val); res = gst_schro_dec_src_convert (pad, src_fmt, src_val, &dest_fmt, &dest_val); if (!res) goto error; gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val); break; } default: res = gst_pad_query_default (pad, query); break; } done: gst_object_unref (dec); return res; error: GST_DEBUG_OBJECT (dec, "query failed"); goto done; }
static gboolean speex_dec_src_query (GstPad * pad, GstQuery * query) { GstSpeexDec *dec; gboolean res = FALSE; dec = GST_SPEEX_DEC (gst_pad_get_parent (pad)); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION:{ GstSegment segment; GstFormat format; gint64 cur; gst_query_parse_position (query, &format, NULL); GST_PAD_STREAM_LOCK (dec->sinkpad); segment = dec->segment; GST_PAD_STREAM_UNLOCK (dec->sinkpad); if (segment.format != GST_FORMAT_TIME) { GST_DEBUG_OBJECT (dec, "segment not initialised yet"); break; } if ((res = speex_dec_convert (dec->srcpad, GST_FORMAT_TIME, segment.last_stop, &format, &cur))) { gst_query_set_position (query, format, cur); } break; } case GST_QUERY_DURATION:{ GstFormat format = GST_FORMAT_TIME; gint64 dur; /* get duration from demuxer */ if (!gst_pad_query_peer_duration (dec->sinkpad, &format, &dur)) break; gst_query_parse_duration (query, &format, NULL); /* and convert it into the requested format */ if ((res = speex_dec_convert (dec->srcpad, GST_FORMAT_TIME, dur, &format, &dur))) { gst_query_set_duration (query, format, dur); } break; } default: res = gst_pad_query_default (pad, query); break; } gst_object_unref (dec); return res; }
static VALUE position_parse(VALUE self) { GstFormat format; gint64 cur; gst_query_parse_position(RVAL2GST_QUERY(self), &format, &cur); return rb_ary_new3(2, GST_FORMAT2RVAL(format), LL2NUM(cur)); }
gboolean gst_splitmux_part_reader_src_query (GstSplitMuxPartReader * part, GstPad * src_pad, GstQuery * query) { GstPad *target = NULL; gboolean ret; GList *cur; SPLITMUX_PART_LOCK (part); /* Find the pad corresponding to the visible output target pad */ for (cur = g_list_first (part->pads); cur != NULL; cur = g_list_next (cur)) { GstSplitMuxPartPad *part_pad = SPLITMUX_PART_PAD_CAST (cur->data); if (part_pad->target == src_pad) { target = gst_object_ref (GST_OBJECT_CAST (part_pad)); break; } } SPLITMUX_PART_UNLOCK (part); if (target == NULL) return FALSE; ret = gst_pad_peer_query (target, query); gst_object_unref (GST_OBJECT_CAST (target)); if (ret == FALSE) goto out; /* Post-massaging of queries */ switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION:{ GstFormat fmt; gint64 position; gst_query_parse_position (query, &fmt, &position); if (fmt != GST_FORMAT_TIME) return FALSE; SPLITMUX_PART_LOCK (part); position += part->start_offset; GST_LOG_OBJECT (part, "Position %" GST_TIME_FORMAT, GST_TIME_ARGS (position)); SPLITMUX_PART_UNLOCK (part); gst_query_set_position (query, fmt, position); break; } default: break; } out: gst_object_unref (target); return ret; }
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); }
static gboolean gst_fd_sink_query (GstBaseSink * bsink, GstQuery * query) { gboolean res = FALSE; GstFdSink *fdsink; fdsink = GST_FD_SINK (bsink); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: { GstFormat format; gst_query_parse_position (query, &format, NULL); switch (format) { case GST_FORMAT_DEFAULT: case GST_FORMAT_BYTES: gst_query_set_position (query, GST_FORMAT_BYTES, fdsink->current_pos); res = TRUE; break; default: break; } break; } case GST_QUERY_FORMATS: gst_query_set_formats (query, 2, GST_FORMAT_DEFAULT, GST_FORMAT_BYTES); res = TRUE; break; case GST_QUERY_URI: gst_query_set_uri (query, fdsink->uri); res = TRUE; break; case GST_QUERY_SEEKING:{ GstFormat format; gst_query_parse_seeking (query, &format, NULL, NULL, NULL); if (format == GST_FORMAT_BYTES || format == GST_FORMAT_DEFAULT) { gst_query_set_seeking (query, GST_FORMAT_BYTES, fdsink->seekable, 0, -1); } else { gst_query_set_seeking (query, format, FALSE, 0, -1); } res = TRUE; break; } default: res = GST_BASE_SINK_CLASS (parent_class)->query (bsink, query); break; } return res; }
static gboolean gst_rtmp_src_query (GstBaseSrc * basesrc, GstQuery * query) { gboolean ret = FALSE; GstRTMPSrc *src = GST_RTMP_SRC (basesrc); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_URI: gst_query_set_uri (query, src->uri); ret = TRUE; break; case GST_QUERY_POSITION:{ GstFormat format; gst_query_parse_position (query, &format, NULL); if (format == GST_FORMAT_TIME) { gst_query_set_position (query, format, src->last_timestamp); ret = TRUE; } break; } case GST_QUERY_DURATION:{ GstFormat format; gdouble duration; gst_query_parse_duration (query, &format, NULL); if (format == GST_FORMAT_TIME && src->rtmp) { duration = RTMP_GetDuration (src->rtmp); if (duration != 0.0) { gst_query_set_duration (query, format, duration * GST_SECOND); ret = TRUE; } } break; } case GST_QUERY_SCHEDULING:{ gst_query_set_scheduling (query, GST_SCHEDULING_FLAG_SEQUENTIAL | GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED, 1, -1, 0); gst_query_add_scheduling_mode (query, GST_PAD_MODE_PUSH); ret = TRUE; break; } default: ret = FALSE; break; } if (!ret) ret = GST_BASE_SRC_CLASS (parent_class)->query (basesrc, query); return ret; }
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); }
static gboolean gst_audio_aggregator_src_query (GstAggregator * agg, GstQuery * query) { GstAudioAggregator *aagg = GST_AUDIO_AGGREGATOR (agg); gboolean res = FALSE; switch (GST_QUERY_TYPE (query)) { case GST_QUERY_DURATION: res = gst_audio_aggregator_query_duration (aagg, query); break; case GST_QUERY_POSITION: { GstFormat format; gst_query_parse_position (query, &format, NULL); GST_OBJECT_LOCK (aagg); switch (format) { case GST_FORMAT_TIME: gst_query_set_position (query, format, gst_segment_to_stream_time (&agg->segment, GST_FORMAT_TIME, agg->segment.position)); res = TRUE; break; case GST_FORMAT_BYTES: if (GST_AUDIO_INFO_BPF (&aagg->info)) { gst_query_set_position (query, format, aagg->priv->offset * GST_AUDIO_INFO_BPF (&aagg->info)); res = TRUE; } break; case GST_FORMAT_DEFAULT: gst_query_set_position (query, format, aagg->priv->offset); res = TRUE; break; default: break; } GST_OBJECT_UNLOCK (aagg); break; } default: res = GST_AGGREGATOR_CLASS (gst_audio_aggregator_parent_class)->src_query (agg, query); break; } return res; }
static gboolean gst_vcd_parse_src_query (GstPad * pad, GstQuery * query) { GstVcdParse *vcd = GST_VCD_PARSE (gst_pad_get_parent (pad)); gboolean res = FALSE; switch (GST_QUERY_TYPE (query)) { case GST_QUERY_DURATION:{ GstFormat format; gint64 dur; /* first try upstream */ if (!gst_pad_query_default (pad, query)) break; /* we can only handle BYTES */ gst_query_parse_duration (query, &format, &dur); if (format != GST_FORMAT_BYTES) break; gst_query_set_duration (query, GST_FORMAT_BYTES, gst_vcd_parse_get_out_offset (dur)); res = TRUE; break; } case GST_QUERY_POSITION:{ GstFormat format; gint64 pos; /* first try upstream */ if (!gst_pad_query_default (pad, query)) break; /* we can only handle BYTES */ gst_query_parse_position (query, &format, &pos); if (format != GST_FORMAT_BYTES) break; gst_query_set_position (query, GST_FORMAT_BYTES, gst_vcd_parse_get_out_offset (pos)); res = TRUE; break; } default: res = gst_pad_query_default (pad, query); break; } gst_object_unref (vcd); return res; }
static gboolean gst_tta_parse_query (GstPad * pad, GstQuery * query) { GstTtaParse *ttaparse = GST_TTA_PARSE (gst_pad_get_parent (pad)); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: { GstFormat format; gint64 cur; gst_query_parse_position (query, &format, NULL); switch (format) { case GST_FORMAT_TIME: cur = ttaparse->index[ttaparse->current_frame].time; break; default: format = GST_FORMAT_BYTES; cur = ttaparse->index[ttaparse->current_frame].pos; break; } gst_query_set_position (query, format, cur); break; } case GST_QUERY_DURATION: { GstFormat format; gint64 end; gst_query_parse_duration (query, &format, NULL); switch (format) { case GST_FORMAT_TIME: end = ((gdouble) ttaparse->data_length / (gdouble) ttaparse->samplerate) * GST_SECOND; break; default: format = GST_FORMAT_BYTES; end = ttaparse->index[ttaparse->num_frames].pos + ttaparse->index[ttaparse->num_frames].size; break; } gst_query_set_duration (query, format, end); break; } default: return FALSE; break; } return TRUE; }
static gboolean gst_base_video_decoder_src_query (GstPad * pad, GstQuery * query) { GstBaseVideoDecoder *dec; gboolean res = TRUE; dec = GST_BASE_VIDEO_DECODER (gst_pad_get_parent (pad)); switch GST_QUERY_TYPE (query) { case GST_QUERY_POSITION: { GstFormat format; gint64 time; gst_query_parse_position (query, &format, NULL); GST_DEBUG ("query in format %d", format); if (format != GST_FORMAT_TIME) { goto error; } time = dec->last_timestamp; time = gst_segment_to_stream_time (&dec->segment, GST_FORMAT_TIME, time); gst_query_set_position (query, format, time); res = TRUE; break; } case GST_QUERY_DURATION: /* FIXME: approximate using bitrate if upstream doesn't answear */ res = gst_pad_query (dec->sinkpad, query); break; default: res = gst_pad_query_default (pad, query); } gst_object_unref (dec); return res; error: GST_ERROR_OBJECT (dec, "query failed"); gst_object_unref (dec); return res; }
static gboolean gst_type_find_handle_src_query (GstPad * pad, GstQuery * query) { GstTypeFindElement *typefind; gboolean res = FALSE; GstPad *peer; typefind = GST_TYPE_FIND_ELEMENT (GST_PAD_PARENT (pad)); peer = gst_pad_get_peer (typefind->sink); if (peer == NULL) return FALSE; res = gst_pad_query (peer, query); if (!res) goto out; switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: { gint64 peer_pos; GstFormat format; if (typefind->store == NULL) goto out; gst_query_parse_position (query, &format, &peer_pos); /* FIXME: this code assumes that there's no discont in the queue */ switch (format) { case GST_FORMAT_BYTES: peer_pos -= GST_BUFFER_SIZE (typefind->store); break; default: /* FIXME */ break; } gst_query_set_position (query, format, peer_pos); break; } default: break; } out: gst_object_unref (peer); return res; }
/* FIXME operating in TIME rather than BYTES could remove this altogether * and be more convenient elsewhere */ static gboolean gst_mms_query (GstBaseSrc * src, GstQuery * query) { GstMMS *mmssrc = GST_MMS (src); gboolean res = TRUE; GstFormat format; gint64 value; switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: gst_query_parse_position (query, &format, &value); if (format != GST_FORMAT_BYTES) { res = FALSE; break; } value = (gint64) mmsx_get_current_pos (mmssrc->connection); gst_query_set_position (query, format, value); break; case GST_QUERY_DURATION: if (!mmsx_get_seekable (mmssrc->connection)) { res = FALSE; break; } gst_query_parse_duration (query, &format, &value); switch (format) { case GST_FORMAT_BYTES: value = (gint64) mmsx_get_length (mmssrc->connection); gst_query_set_duration (query, format, value); break; case GST_FORMAT_TIME: value = mmsx_get_time_length (mmssrc->connection) * GST_SECOND; gst_query_set_duration (query, format, value); break; default: res = FALSE; } break; default: /* chain to parent */ res = GST_BASE_SRC_CLASS (parent_class)->query (GST_BASE_SRC (src), query); break; } return res; }
static gboolean gst_deinterleave_src_query (GstPad * pad, GstObject * parent, GstQuery * query) { GstDeinterleave *self = GST_DEINTERLEAVE (parent); gboolean res; res = gst_pad_query_default (pad, parent, query); if (res && GST_QUERY_TYPE (query) == GST_QUERY_DURATION) { GstFormat format; gint64 dur; gst_query_parse_duration (query, &format, &dur); /* Need to divide by the number of channels in byte format * to get the correct value. All other formats should be fine */ if (format == GST_FORMAT_BYTES && dur != -1) gst_query_set_duration (query, format, dur / GST_AUDIO_INFO_CHANNELS (&self->audio_info)); } else if (res && GST_QUERY_TYPE (query) == GST_QUERY_POSITION) { GstFormat format; gint64 pos; gst_query_parse_position (query, &format, &pos); /* Need to divide by the number of channels in byte format * to get the correct value. All other formats should be fine */ if (format == GST_FORMAT_BYTES && pos != -1) gst_query_set_position (query, format, pos / GST_AUDIO_INFO_CHANNELS (&self->audio_info)); } else if (res && GST_QUERY_TYPE (query) == GST_QUERY_CAPS) { GstCaps *filter, *caps; gst_query_parse_caps (query, &filter); caps = gst_deinterleave_sink_getcaps (pad, parent, filter); gst_query_set_caps_result (query, caps); gst_caps_unref (caps); } return res; }
static gboolean gst_mve_demux_handle_src_query (GstPad * pad, GstQuery * query) { gboolean res = FALSE; switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION:{ GstFormat format; gst_query_parse_position (query, &format, NULL); /* we only support TIME */ if (format == GST_FORMAT_TIME) { GstMveDemuxStream *s = gst_pad_get_element_private (pad); if (s != NULL) { GST_OBJECT_LOCK (s); gst_query_set_position (query, GST_FORMAT_TIME, s->last_ts); GST_OBJECT_UNLOCK (s); res = TRUE; } } break; } case GST_QUERY_SEEKING:{ GstFormat format; gst_query_parse_seeking (query, &format, NULL, NULL, NULL); if (format == GST_FORMAT_TIME) { gst_query_set_seeking (query, GST_FORMAT_TIME, FALSE, 0, -1); res = TRUE; } break; } case GST_QUERY_DURATION:{ /* FIXME: really should implement/estimate this somehow */ res = FALSE; break; } default: res = gst_pad_query_default (pad, query); break; } return res; }
static gboolean gst_mms_src_query (GstPad * pad, GstQuery * query) { GstMMS *mmssrc = GST_MMS (gst_pad_get_parent (pad)); gboolean res = TRUE; GstFormat format; gint64 value; switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: gst_query_parse_position (query, &format, &value); if (format != GST_FORMAT_BYTES) { res = FALSE; break; } if (mmssrc->connection) { value = (gint64) mms_get_current_pos (mmssrc->connection); } else { value = (gint64) mmsh_get_current_pos (mmssrc->connection_h); } gst_query_set_position (query, format, value); break; case GST_QUERY_DURATION: gst_query_parse_duration (query, &format, &value); if (format != GST_FORMAT_BYTES) { res = FALSE; break; } if (mmssrc->connection) { value = (gint64) mms_get_length (mmssrc->connection); } else { value = (gint64) mmsh_get_length (mmssrc->connection_h); } gst_query_set_duration (query, format, value); break; default: res = FALSE; break; } gst_object_unref (mmssrc); return res; }
static gboolean gst_rtmp_src_query (GstBaseSrc * basesrc, GstQuery * query) { gboolean ret = FALSE; GstRTMPSrc *src = GST_RTMP_SRC (basesrc); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_URI: gst_query_set_uri (query, src->uri); ret = TRUE; break; case GST_QUERY_POSITION:{ GstFormat format; gst_query_parse_position (query, &format, NULL); if (format == GST_FORMAT_TIME) { gst_query_set_duration (query, format, src->last_timestamp); ret = TRUE; } break; } case GST_QUERY_DURATION:{ GstFormat format; gdouble duration; gst_query_parse_duration (query, &format, NULL); if (format == GST_FORMAT_TIME && src->rtmp) { duration = RTMP_GetDuration (src->rtmp); if (duration != 0.0) { gst_query_set_duration (query, format, duration * GST_SECOND); ret = TRUE; } } break; } default: ret = FALSE; break; } if (!ret) ret = GST_BASE_SRC_CLASS (parent_class)->query (basesrc, query); return ret; }
static gboolean gst_adder_query (GstPad * pad, GstQuery * query) { GstAdder *adder = GST_ADDER (gst_pad_get_parent (pad)); gboolean res = FALSE; switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: { GstFormat format; gst_query_parse_position (query, &format, NULL); switch (format) { case GST_FORMAT_TIME: /* FIXME, bring to stream time, might be tricky */ gst_query_set_position (query, format, adder->timestamp); res = TRUE; break; case GST_FORMAT_DEFAULT: gst_query_set_position (query, format, adder->offset); res = TRUE; break; default: break; } break; } case GST_QUERY_DURATION: res = gst_adder_query_duration (adder, query); break; case GST_QUERY_LATENCY: res = gst_adder_query_latency (adder, query); break; default: /* FIXME, needs a custom query handler because we have multiple * sinkpads */ res = gst_pad_query_default (pad, query); break; } gst_object_unref (adder); return res; }
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; }
static gboolean gst_spc_dec_src_query (GstPad * pad, GstQuery * query) { GstSpcDec *spc = GST_SPC_DEC (gst_pad_get_parent (pad)); gboolean result = TRUE; switch (GST_QUERY_TYPE (query)) { case GST_QUERY_DURATION: { GstFormat format; gst_query_parse_duration (query, &format, NULL); if (!spc->initialized || format != GST_FORMAT_TIME) { result = FALSE; break; } gst_query_set_duration (query, GST_FORMAT_TIME, gst_spc_duration (spc) + gst_spc_fadeout (spc)); break; } case GST_QUERY_POSITION: { GstFormat format; gst_query_parse_position (query, &format, NULL); if (!spc->initialized || format != GST_FORMAT_TIME) { result = FALSE; break; } gst_query_set_position (query, GST_FORMAT_TIME, (gint64) gst_util_uint64_scale (spc->byte_pos, GST_SECOND, 32000 * 2 * 2)); break; } default: result = gst_pad_query_default (pad, query); break; } gst_object_unref (spc); return result; }