/* if we already commited the state */
gboolean commited;
+ /* state change to playing ongoing */
+ gboolean to_playing;
/* when we received EOS */
gboolean received_eos;
static gboolean gst_base_sink_send_event (GstElement * element,
GstEvent * event);
-static gboolean gst_base_sink_query (GstElement * element, GstQuery * query);
+static gboolean default_element_query (GstElement * element, GstQuery * query);
static const GstQueryType *gst_base_sink_get_query_types (GstElement * element);
static GstCaps *gst_base_sink_get_caps (GstBaseSink * sink, GstCaps * caps);
static GstStateChangeReturn gst_base_sink_change_state (GstElement * element,
GstStateChange transition);
+static gboolean gst_base_sink_sink_query (GstPad * pad, GstQuery * query);
static GstFlowReturn gst_base_sink_chain (GstPad * pad, GstBuffer * buffer);
static GstFlowReturn gst_base_sink_chain_list (GstPad * pad,
GstBufferList * list);
static gboolean gst_base_sink_pad_activate_pull (GstPad * pad, gboolean active);
static gboolean gst_base_sink_event (GstPad * pad, GstEvent * event);
+static gboolean default_sink_query (GstBaseSink * sink, GstQuery * query);
+
static gboolean gst_base_sink_negotiate_pull (GstBaseSink * basesink);
static GstCaps *gst_base_sink_pad_getcaps (GstPad * pad, GstCaps * filter);
static void gst_base_sink_pad_fixate (GstPad * pad, GstCaps * caps);
gstelement_class->change_state =
GST_DEBUG_FUNCPTR (gst_base_sink_change_state);
gstelement_class->send_event = GST_DEBUG_FUNCPTR (gst_base_sink_send_event);
- gstelement_class->query = GST_DEBUG_FUNCPTR (gst_base_sink_query);
+ gstelement_class->query = GST_DEBUG_FUNCPTR (default_element_query);
gstelement_class->get_query_types =
GST_DEBUG_FUNCPTR (gst_base_sink_get_query_types);
klass->get_times = GST_DEBUG_FUNCPTR (gst_base_sink_get_times);
klass->activate_pull =
GST_DEBUG_FUNCPTR (gst_base_sink_default_activate_pull);
+ klass->query = GST_DEBUG_FUNCPTR (default_sink_query);
/* Registering debug symbols for function pointers */
GST_DEBUG_REGISTER_FUNCPTR (gst_base_sink_pad_getcaps);
gst_base_sink_pad_activate_push);
gst_pad_set_activatepull_function (basesink->sinkpad,
gst_base_sink_pad_activate_pull);
+ gst_pad_set_query_function (basesink->sinkpad, gst_base_sink_sink_query);
gst_pad_set_event_function (basesink->sinkpad, gst_base_sink_event);
gst_pad_set_chain_function (basesink->sinkpad, gst_base_sink_chain);
gst_pad_set_chain_list_function (basesink->sinkpad, gst_base_sink_chain_list);
/* 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);
if (basesink->priv->async_enabled) {
gst_element_lost_state (GST_ELEMENT_CAST (basesink));
} else {
+ /* start time reset in above case as well;
+ * arranges for a.o. proper position reporting when flushing in PAUSED */
+ gst_element_set_start_time (GST_ELEMENT_CAST (basesink), 0);
basesink->priv->have_latency = TRUE;
}
gst_base_sink_set_last_buffer (basesink, NULL);
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;
else
gst_object_ref (clock);
+ /* mainloop might be querying position when going to playing async,
+ * while (audio) rendering might be quickly advancing stream position,
+ * so use clock asap rather than last reported position */
+ if (in_paused && with_clock && g_atomic_int_get (&basesink->priv->to_playing)) {
+ GST_DEBUG_OBJECT (basesink, "going to PLAYING, so not PAUSED");
+ in_paused = FALSE;
+ }
+
/* collect all data we need holding the lock */
if (GST_CLOCK_TIME_IS_VALID (segment->time))
time = segment->time;
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;
}
}
static gboolean
-gst_base_sink_query (GstElement * element, GstQuery * query)
+default_element_query (GstElement * element, GstQuery * query)
{
gboolean res = FALSE;
/* 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) {
return res;
}
+
+static gboolean
+default_sink_query (GstBaseSink * basesink, GstQuery * query)
+{
+ gboolean res;
+ GstBaseSinkClass *bclass;
+
+ bclass = GST_BASE_SINK_GET_CLASS (basesink);
+
+ switch (GST_QUERY_TYPE (query)) {
+ case GST_QUERY_ALLOCATION:
+ {
+ if (bclass->setup_allocation)
+ res = bclass->setup_allocation (basesink, query);
+ else
+ res = FALSE;
+ break;
+ }
+ default:
+ res = gst_pad_query_default (basesink->sinkpad, query);
+ break;
+ }
+ return res;
+}
+
+static gboolean
+gst_base_sink_sink_query (GstPad * pad, GstQuery * query)
+{
+ GstBaseSink *basesink;
+ GstBaseSinkClass *bclass;
+ gboolean res;
+
+ basesink = GST_BASE_SINK_CAST (gst_pad_get_parent (pad));
+ if (G_UNLIKELY (basesink == NULL)) {
+ gst_query_unref (query);
+ return FALSE;
+ }
+
+ bclass = GST_BASE_SINK_GET_CLASS (basesink);
+
+ if (bclass->query)
+ res = bclass->query (basesink, query);
+ else
+ res = FALSE;
+
+ gst_object_unref (basesink);
+
+ return res;
+}
+
static GstStateChangeReturn
gst_base_sink_change_state (GstElement * element, GstStateChange transition)
{
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
GST_BASE_SINK_PREROLL_LOCK (basesink);
+ g_atomic_int_set (&basesink->priv->to_playing, TRUE);
if (!gst_base_sink_needs_preroll (basesink)) {
GST_DEBUG_OBJECT (basesink, "PAUSED to PLAYING, don't need preroll");
/* no preroll needed anymore now. */
}
switch (transition) {
+ case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
+ /* completed transition, so need not be marked any longer
+ * And it should be unmarked, since e.g. losing our position upon flush
+ * does not really change state to PAUSED ... */
+ g_atomic_int_set (&basesink->priv->to_playing, FALSE);
+ break;
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
+ g_atomic_int_set (&basesink->priv->to_playing, FALSE);
GST_DEBUG_OBJECT (basesink, "PLAYING to PAUSED");
/* FIXME, make sure we cannot enter _render first */