peer = gst_pad_get_peer (parse->sinkpad);
if (peer) {
- GstFormat pformat = GST_FORMAT_BYTES;
gboolean qres = FALSE;
gint64 ptot, dest_value;
- qres = gst_pad_query_duration (peer, &pformat, &ptot);
+ qres = gst_pad_query_duration (peer, GST_FORMAT_BYTES, &ptot);
gst_object_unref (GST_OBJECT (peer));
if (qres) {
- if (gst_base_parse_convert (parse, pformat, ptot,
+ if (gst_base_parse_convert (parse, GST_FORMAT_BYTES, ptot,
GST_FORMAT_TIME, &dest_value)) {
parse->priv->estimated_duration = dest_value;
GST_LOG_OBJECT (parse,
/* try harder to query upstream size if we didn't get it the first time */
if (seekable && stop == -1) {
- GstFormat fmt = GST_FORMAT_BYTES;
-
GST_DEBUG_OBJECT (parse, "doing duration query to fix up unset stop");
- gst_pad_query_peer_duration (parse->sinkpad, &fmt, &stop);
+ gst_pad_query_peer_duration (parse->sinkpad, GST_FORMAT_BYTES, &stop);
}
/* if upstream doesn't know the size, it's likely that it's not seekable in
static void
gst_base_parse_check_upstream (GstBaseParse * parse)
{
- GstFormat fmt = GST_FORMAT_TIME;
gint64 stop;
- if (gst_pad_query_peer_duration (parse->sinkpad, &fmt, &stop))
+ if (gst_pad_query_peer_duration (parse->sinkpad, GST_FORMAT_TIME, &stop))
if (GST_CLOCK_TIME_IS_VALID (stop) && stop) {
/* upstream has one, accept it also, and no further updates */
gst_base_parse_set_duration (parse, GST_FORMAT_TIME, stop, 0);
if (parse->priv->exact_position) {
offset = gst_base_parse_find_offset (parse, ts, TRUE, NULL);
} else {
- GstFormat dstformat = GST_FORMAT_BYTES;
-
if (!gst_pad_query_convert (parse->srcpad, GST_FORMAT_TIME, ts,
- &dstformat, &offset)) {
+ GST_FORMAT_BYTES, &offset)) {
GST_DEBUG_OBJECT (parse, "conversion failed, only BYTE based");
}
}
gboolean flush, update, res = TRUE, accurate;
gint64 cur, stop, seekpos, seekstop;
GstSegment seeksegment = { 0, };
- GstFormat dstformat;
GstClockTime start_ts;
gst_event_parse_seek (event, &rate, &format, &flags,
NULL);
} else {
start_ts = seeksegment.position;
- dstformat = GST_FORMAT_BYTES;
if (!gst_pad_query_convert (parse->srcpad, format, seeksegment.position,
- &dstformat, &seekpos))
+ GST_FORMAT_BYTES, &seekpos))
goto convert_failed;
if (!gst_pad_query_convert (parse->srcpad, format, seeksegment.stop,
- &dstformat, &seekstop))
+ GST_FORMAT_BYTES, &seekstop))
goto convert_failed;
}
/* FIXME: Casting to GstClockEntry only works because the types
* are the same */
if (G_LIKELY (sink->priv->cached_clock_id != NULL
- && GST_CLOCK_ENTRY_CLOCK ((GstClockEntry *) sink->
- priv->cached_clock_id) == clock)) {
+ && GST_CLOCK_ENTRY_CLOCK ((GstClockEntry *) sink->priv->
+ cached_clock_id) == clock)) {
if (!gst_clock_single_shot_id_reinit (clock, sink->priv->cached_clock_id,
time)) {
gst_clock_id_unref (sink->priv->cached_clock_id);
GstSeekType cur_type, stop_type;
gint64 cur, stop;
GstSeekFlags flags;
- GstFormat seek_format, dest_format;
+ GstFormat seek_format;
gdouble rate;
gboolean update;
gboolean res = TRUE;
gst_event_parse_seek (event, &rate, &seek_format, &flags,
&cur_type, &cur, &stop_type, &stop);
- dest_format = segment->format;
- if (seek_format == dest_format) {
+ if (seek_format == segment->format) {
gst_segment_do_seek (segment, rate, seek_format, flags,
cur_type, cur, stop_type, stop, &update);
return TRUE;
if (cur_type != GST_SEEK_TYPE_NONE) {
/* FIXME: Handle seek_cur & seek_end by converting the input segment vals */
res =
- gst_pad_query_convert (sink->sinkpad, seek_format, cur, &dest_format,
+ gst_pad_query_convert (sink->sinkpad, seek_format, cur, segment->format,
&cur);
cur_type = GST_SEEK_TYPE_SET;
}
if (res && stop_type != GST_SEEK_TYPE_NONE) {
/* FIXME: Handle seek_cur & seek_end by converting the input segment vals */
res =
- gst_pad_query_convert (sink->sinkpad, seek_format, stop, &dest_format,
- &stop);
+ gst_pad_query_convert (sink->sinkpad, seek_format, stop,
+ segment->format, &stop);
stop_type = GST_SEEK_TYPE_SET;
}
/* And finally, configure our output segment in the desired format */
- gst_segment_do_seek (segment, rate, dest_format, flags, cur_type, cur,
+ gst_segment_do_seek (segment, rate, segment->format, flags, cur_type, cur,
stop_type, stop, &update);
if (!res)
bclass = GST_BASE_SINK_GET_CLASS (basesink);
if (active) {
- GstFormat format;
gint64 duration;
/* we mark we have a newsegment here because pull based
* mode works just fine without having a newsegment before the
* first buffer */
- format = GST_FORMAT_BYTES;
-
- gst_segment_init (&basesink->segment, format);
- gst_segment_init (&basesink->clip_segment, format);
+ gst_segment_init (&basesink->segment, GST_FORMAT_BYTES);
+ gst_segment_init (&basesink->clip_segment, GST_FORMAT_BYTES);
GST_OBJECT_LOCK (basesink);
basesink->have_newsegment = TRUE;
GST_OBJECT_UNLOCK (basesink);
/* get the peer duration in bytes */
- result = gst_pad_query_peer_duration (pad, &format, &duration);
+ result = gst_pad_query_peer_duration (pad, GST_FORMAT_BYTES, &duration);
if (result) {
GST_DEBUG_OBJECT (basesink,
"setting duration in bytes to %" G_GINT64_FORMAT, duration);
{
GstClock *clock = NULL;
gboolean res = FALSE;
- GstFormat oformat, tformat;
+ GstFormat oformat;
GstSegment *segment;
GstClockTime now, latency;
GstClockTimeDiff base_time;
else
segment = &basesink->segment;
- /* our intermediate time format */
- tformat = GST_FORMAT_TIME;
/* get the format in the segment */
oformat = segment->format;
GST_TIME_ARGS (last));
*cur = last;
} else {
- if (oformat != tformat) {
+ if (oformat != GST_FORMAT_TIME) {
/* convert base, time and duration to time */
- if (!gst_pad_query_convert (basesink->sinkpad, oformat, base, &tformat,
- &base))
+ if (!gst_pad_query_convert (basesink->sinkpad, oformat, base,
+ GST_FORMAT_TIME, &base))
goto convert_failed;
if (!gst_pad_query_convert (basesink->sinkpad, oformat, duration,
- &tformat, &duration))
+ GST_FORMAT_TIME, &duration))
goto convert_failed;
- if (!gst_pad_query_convert (basesink->sinkpad, oformat, time, &tformat,
- &time))
+ if (!gst_pad_query_convert (basesink->sinkpad, oformat, time,
+ GST_FORMAT_TIME, &time))
goto convert_failed;
- if (!gst_pad_query_convert (basesink->sinkpad, oformat, last, &tformat,
- &last))
+ if (!gst_pad_query_convert (basesink->sinkpad, oformat, last,
+ GST_FORMAT_TIME, &last))
goto convert_failed;
/* assume time format from now on */
- oformat = tformat;
+ oformat = GST_FORMAT_TIME;
}
if (!in_paused && with_clock) {
if (oformat != format) {
/* convert to final format */
- if (!gst_pad_query_convert (basesink->sinkpad, oformat, *cur, &format, cur))
+ if (!gst_pad_query_convert (basesink->sinkpad, oformat, *cur, format, cur))
goto convert_failed;
}
gboolean res = FALSE;
if (basesink->pad_mode == GST_ACTIVATE_PULL) {
- GstFormat uformat = GST_FORMAT_BYTES;
gint64 uduration;
/* get the duration in bytes, in pull mode that's all we are sure to
* know. We have to explicitly get this value from upstream instead of
* using our cached value because it might change. Duration caching
* should be done at a higher level. */
- res = gst_pad_query_peer_duration (basesink->sinkpad, &uformat, &uduration);
+ res =
+ gst_pad_query_peer_duration (basesink->sinkpad, GST_FORMAT_BYTES,
+ &uduration);
if (res) {
basesink->segment.duration = uduration;
- if (format != uformat) {
+ if (format != GST_FORMAT_BYTES) {
/* convert to the requested format */
- res = gst_pad_query_convert (basesink->sinkpad, uformat, uduration,
- &format, dur);
+ res =
+ gst_pad_query_convert (basesink->sinkpad, GST_FORMAT_BYTES,
+ uduration, format, dur);
} else {
*dur = uduration;
}
/* we can handle a few things if upstream failed */
if (format == GST_FORMAT_PERCENT) {
gint64 dur = 0;
- GstFormat uformat = GST_FORMAT_TIME;
res = gst_base_sink_get_position (basesink, GST_FORMAT_TIME, &cur,
&upstream);
if (!res && upstream) {
- res = gst_pad_query_peer_position (basesink->sinkpad, &uformat,
+ res =
+ gst_pad_query_peer_position (basesink->sinkpad, GST_FORMAT_TIME,
&cur);
}
if (res) {
res = gst_base_sink_get_duration (basesink, GST_FORMAT_TIME, &dur,
&upstream);
if (!res && upstream) {
- res = gst_pad_query_peer_duration (basesink->sinkpad, &uformat,
- &dur);
+ res =
+ gst_pad_query_peer_duration (basesink->sinkpad,
+ GST_FORMAT_TIME, &dur);
}
}
if (res) {
/* convert to requested format */
res =
gst_pad_query_convert (src->srcpad, seg_format,
- position, &format, &position);
+ position, format, &position);
} else
res = TRUE;
* but we cannot answer the query, we must return FALSE. */
res =
gst_pad_query_convert (src->srcpad, seg_format,
- duration, &format, &duration);
+ duration, format, &duration);
} else {
/* The subclass did not configure a duration, we assume that the
* media has an unknown duration then and we return TRUE to report
* but report TRUE. */
if (format != GST_FORMAT_PERCENT && stop != -1) {
res = gst_pad_query_convert (src->srcpad, seg_format,
- stop, &format, &stop);
+ stop, format, &stop);
} else {
res = TRUE;
}
if (res && format != GST_FORMAT_PERCENT && start != -1)
res = gst_pad_query_convert (src->srcpad, seg_format,
- start, &format, &start);
+ start, format, &start);
gst_query_set_buffering_range (query, format, start, stop, estimated);
break;
if (cur_type != GST_SEEK_TYPE_NONE) {
/* FIXME: Handle seek_cur & seek_end by converting the input segment vals */
res =
- gst_pad_query_convert (src->srcpad, seek_format, cur, &dest_format,
+ gst_pad_query_convert (src->srcpad, seek_format, cur, dest_format,
&cur);
cur_type = GST_SEEK_TYPE_SET;
}
if (res && stop_type != GST_SEEK_TYPE_NONE) {
/* FIXME: Handle seek_cur & seek_end by converting the input segment vals */
res =
- gst_pad_query_convert (src->srcpad, seek_format, stop, &dest_format,
+ gst_pad_query_convert (src->srcpad, seek_format, stop, dest_format,
&stop);
stop_type = GST_SEEK_TYPE_SET;
}