static gboolean
gst_deinterleave_src_query (GstPad * pad, GstQuery * query)
{
GstDeinterleave *self = GST_DEINTERLEAVE (gst_pad_get_parent (pad));
gboolean res;
res = gst_pad_query_default (pad, 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 / self->channels);
} 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 / self->channels);
}
gst_object_unref (self);
return res;
}
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_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_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_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_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;
}
static gboolean
gst_midi_parse_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
{
gboolean res = TRUE;
GstMidiParse *midiparse = GST_MIDI_PARSE (parent);
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_DURATION:
gst_query_set_duration (query, GST_FORMAT_TIME,
midiparse->segment.duration);
break;
case GST_QUERY_POSITION:
gst_query_set_position (query, GST_FORMAT_TIME,
midiparse->segment.position);
break;
case GST_QUERY_FORMATS:
gst_query_set_formats (query, 1, GST_FORMAT_TIME);
break;
case GST_QUERY_SEGMENT:
gst_query_set_segment (query, midiparse->segment.rate,
midiparse->segment.format, midiparse->segment.start,
midiparse->segment.stop);
break;
case GST_QUERY_SEEKING:
gst_query_set_seeking (query, midiparse->segment.format,
FALSE, 0, midiparse->segment.duration);
break;
default:
res = gst_pad_query_default (pad, parent, query);
break;
}
return res;
}
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_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_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
gst_wildmidi_src_query (GstPad * pad, GstQuery * query)
{
gboolean res = TRUE;
GstWildmidi *wildmidi = GST_WILDMIDI (gst_pad_get_parent (pad));
GstFormat src_format, dst_format;
gint64 src_value, dst_value;
if (!wildmidi->song) {
gst_object_unref (wildmidi);
return FALSE;
}
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_DURATION:
gst_query_set_duration (query, GST_FORMAT_TIME,
gst_util_uint64_scale_int (wildmidi->o_len, GST_SECOND,
WILDMIDI_RATE));
break;
case GST_QUERY_POSITION:
gst_query_set_position (query, GST_FORMAT_TIME,
gst_util_uint64_scale_int (wildmidi->o_segment->last_stop, GST_SECOND,
WILDMIDI_RATE));
break;
case GST_QUERY_CONVERT:
gst_query_parse_convert (query, &src_format, &src_value,
&dst_format, NULL);
res =
gst_wildmidi_src_convert (wildmidi, src_format, src_value,
&dst_format, &dst_value);
if (res)
gst_query_set_convert (query, src_format, src_value, dst_format,
dst_value);
break;
case GST_QUERY_FORMATS:
gst_query_set_formats (query, 3,
GST_FORMAT_TIME, GST_FORMAT_BYTES, GST_FORMAT_DEFAULT);
break;
case GST_QUERY_SEGMENT:
gst_query_set_segment (query, wildmidi->o_segment->rate,
wildmidi->o_segment->format, wildmidi->o_segment->start,
wildmidi->o_segment->stop);
break;
case GST_QUERY_SEEKING:
gst_query_set_seeking (query, wildmidi->o_segment->format,
TRUE, 0, wildmidi->o_len);
break;
default:
res = FALSE;
break;
}
gst_object_unref (wildmidi);
return res;
}
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
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 gboolean
gst_timidity_src_query (GstPad * pad, GstQuery * query)
{
gboolean res = TRUE;
GstTimidity *timidity = GST_TIMIDITY (gst_pad_get_parent (pad));
GstFormat src_format, dst_format;
gint64 src_value, dst_value;
if (!timidity->song) {
gst_object_unref (timidity);
return FALSE;
}
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_DURATION:
gst_query_set_duration (query, GST_FORMAT_TIME,
GST_MSECOND * (gint64) mid_song_get_total_time (timidity->song));
break;
case GST_QUERY_POSITION:
gst_query_set_position (query, GST_FORMAT_TIME,
timidity->o_segment->last_stop * timidity->time_per_frame);
break;
case GST_QUERY_CONVERT:
gst_query_parse_convert (query, &src_format, &src_value,
&dst_format, NULL);
res =
gst_timidity_src_convert (timidity, src_format, src_value,
&dst_format, &dst_value);
if (res)
gst_query_set_convert (query, src_format, src_value, dst_format,
dst_value);
break;
case GST_QUERY_FORMATS:
gst_query_set_formats (query, 3,
GST_FORMAT_TIME, GST_FORMAT_BYTES, GST_FORMAT_DEFAULT);
break;
case GST_QUERY_SEGMENT:
gst_query_set_segment (query, timidity->o_segment->rate,
timidity->o_segment->format, timidity->o_segment->start,
timidity->o_segment->stop);
break;
case GST_QUERY_SEEKING:
gst_query_set_seeking (query, timidity->o_segment->format,
TRUE, 0, timidity->o_len);
break;
default:
res = FALSE;
break;
}
gst_object_unref (timidity);
return res;
}
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 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;
}
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_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;
}
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_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_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;
}
/* 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_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_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;
}
static gboolean
gst_live_adder_query_position (GstLiveAdder * adder, GstQuery * query)
{
GstFormat format;
gint64 max;
gboolean res;
/* parse format */
gst_query_parse_position (query, &format, NULL);
res = gst_live_adder_query_pos_dur (adder, format, TRUE, &max);
if (res) {
/* and store the max */
gst_query_set_position (query, format, max);
}
return res;
}
static gboolean
gst_gio_base_sink_query (GstBaseSink * bsink, GstQuery * query)
{
GstGioBaseSink *sink = GST_GIO_BASE_SINK (bsink);
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, format, 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)) {
gchar *uri;
uri = gst_uri_handler_get_uri (GST_URI_HANDLER (sink));
gst_query_set_uri (query, uri);
g_free (uri);
return TRUE;
}
return FALSE;
case GST_QUERY_SEEKING:
gst_query_parse_seeking (query, &format, NULL, NULL, NULL);
if (format == GST_FORMAT_BYTES || format == GST_FORMAT_DEFAULT) {
gst_query_set_seeking (query, format,
GST_GIO_STREAM_IS_SEEKABLE (sink->stream), 0, -1);
} else {
gst_query_set_seeking (query, format, FALSE, 0, -1);
}
return TRUE;
default:
return GST_BASE_SINK_CLASS (parent_class)->query (bsink, query);
}
}
static gboolean
gst_gme_dec_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
{
GstGmeDec *gme = GST_GME_DEC (parent);
gboolean result = TRUE;
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_DURATION:
{
GstFormat format;
gst_query_parse_duration (query, &format, NULL);
if (!gme->initialized || format != GST_FORMAT_TIME
|| gme->total_duration == GST_CLOCK_TIME_NONE) {
result = FALSE;
break;
}
gst_query_set_duration (query, GST_FORMAT_TIME, gme->total_duration);
break;
}
case GST_QUERY_POSITION:
{
GstFormat format;
gst_query_parse_position (query, &format, NULL);
if (!gme->initialized || format != GST_FORMAT_TIME) {
result = FALSE;
break;
}
gst_query_set_position (query, GST_FORMAT_TIME,
(gint64) gme_tell (gme->player) * GST_MSECOND);
break;
}
default:
result = gst_pad_query_default (pad, parent, query);
break;
}
return result;
}