* flag these buffers with GST_BUFFER_FLAG_GAP and GST_BUFFER_FLAG_DROPPABLE
* to ease their identification and subsequent processing.
*
+ * * Subclasses must use (a subclass of) #GstAggregatorPad for both their
+ * sink and source pads.
+ * See gst_element_class_add_static_pad_template_with_gtype().
+ *
* This class used to live in gst-plugins-bad and was moved to core.
*
* Since: 1.14
* GstAggregator implementation *
*************************************/
static GstElementClass *aggregator_parent_class = NULL;
+static gint aggregator_private_offset = 0;
/* All members are protected by the object lock unless otherwise noted */
GstClockTime sub_latency_min; /* protected by src_lock */
GstClockTime sub_latency_max; /* protected by src_lock */
+ GstClockTime upstream_latency_min; /* protected by src_lock */
+
/* aggregate */
GstClockID aggregate_id; /* protected by src_lock */
GMutex src_lock;
} EventData;
#define DEFAULT_LATENCY 0
+#define DEFAULT_MIN_UPSTREAM_LATENCY 0
#define DEFAULT_START_TIME_SELECTION GST_AGGREGATOR_START_TIME_SELECTION_ZERO
#define DEFAULT_START_TIME (-1)
{
PROP_0,
PROP_LATENCY,
+ PROP_MIN_UPSTREAM_LATENCY,
PROP_START_TIME_SELECTION,
PROP_START_TIME,
PROP_LAST
GST_OBJECT_LOCK (self);
self->priv->send_stream_start = TRUE;
self->priv->send_segment = TRUE;
- gst_segment_init (&self->segment, GST_FORMAT_TIME);
+ gst_segment_init (&GST_AGGREGATOR_PAD (self->srcpad)->segment,
+ GST_FORMAT_TIME);
self->priv->first_buffer = TRUE;
GST_OBJECT_UNLOCK (self);
}
GST_INFO_OBJECT (self, "pushing stream start");
/* stream-start (FIXME: create id based on input ids) */
g_snprintf (s_id, sizeof (s_id), "agg-%08x", g_random_int ());
- if (!gst_pad_push_event (self->srcpad, gst_event_new_stream_start (s_id))) {
+ if (!gst_pad_push_event (GST_PAD (self->srcpad),
+ gst_event_new_stream_start (s_id))) {
GST_WARNING_OBJECT (self->srcpad, "Sending stream start event failed");
}
self->priv->send_stream_start = FALSE;
GST_INFO_OBJECT (self, "pushing caps: %" GST_PTR_FORMAT,
self->priv->srccaps);
- if (!gst_pad_push_event (self->srcpad,
+ if (!gst_pad_push_event (GST_PAD (self->srcpad),
gst_event_new_caps (self->priv->srccaps))) {
GST_WARNING_OBJECT (self->srcpad, "Sending caps event failed");
}
GST_OBJECT_LOCK (self);
if (self->priv->send_segment && !self->priv->flush_seeking) {
- segment = gst_event_new_segment (&self->segment);
+ segment =
+ gst_event_new_segment (&GST_AGGREGATOR_PAD (self->srcpad)->segment);
if (!self->priv->seqnum)
/* This code-path is in preparation to be able to run without a source
return res;
}
+typedef struct
+{
+ gboolean processed_event;
+ GstFlowReturn flow_ret;
+} DoHandleEventsAndQueriesData;
+
static gboolean
gst_aggregator_do_events_and_queries (GstElement * self, GstPad * epad,
gpointer user_data)
GstEvent *event = NULL;
GstQuery *query = NULL;
GstAggregatorClass *klass = NULL;
- gboolean *processed_event = user_data;
+ DoHandleEventsAndQueriesData *data = user_data;
do {
event = NULL;
if (event || query) {
gboolean ret;
- if (processed_event)
- *processed_event = TRUE;
+ data->processed_event = TRUE;
if (klass == NULL)
klass = GST_AGGREGATOR_GET_CLASS (self);
ret = klass->sink_event (aggregator, pad, event);
PAD_LOCK (pad);
- if (GST_EVENT_TYPE (event) == GST_EVENT_CAPS)
+ if (GST_EVENT_TYPE (event) == GST_EVENT_CAPS) {
pad->priv->negotiated = ret;
+ if (!ret)
+ pad->priv->flow_return = data->flow_ret = GST_FLOW_NOT_NEGOTIATED;
+ }
if (g_queue_peek_tail (&pad->priv->data) == event)
gst_event_unref (g_queue_pop_tail (&pad->priv->data));
gst_event_unref (event);
GST_LOG_OBJECT (self, "Checking aggregate");
while (priv->send_eos && priv->running) {
GstFlowReturn flow_return = GST_FLOW_OK;
- gboolean processed_event = FALSE;
+ DoHandleEventsAndQueriesData events_query_data = { FALSE, GST_FLOW_OK };
gst_element_foreach_sink_pad (GST_ELEMENT_CAST (self),
- gst_aggregator_do_events_and_queries, NULL);
+ gst_aggregator_do_events_and_queries, &events_query_data);
+
+ if ((flow_return = events_query_data.flow_ret) != GST_FLOW_OK)
+ goto handle_error;
if (self->priv->peer_latency_live)
gst_element_foreach_sink_pad (GST_ELEMENT_CAST (self),
if (!gst_aggregator_wait_and_check (self, &timeout))
continue;
+ events_query_data.processed_event = FALSE;
+ events_query_data.flow_ret = GST_FLOW_OK;
gst_element_foreach_sink_pad (GST_ELEMENT_CAST (self),
- gst_aggregator_do_events_and_queries, &processed_event);
+ gst_aggregator_do_events_and_queries, &events_query_data);
- if (processed_event)
+ if ((flow_return = events_query_data.flow_ret) != GST_FLOW_OK)
+ goto handle_error;
+
+ if (events_query_data.processed_event)
continue;
if (gst_pad_check_reconfigure (GST_AGGREGATOR_SRC_PAD (self))) {
gst_aggregator_push_eos (self);
}
+ handle_error:
GST_LOG_OBJECT (self, "flow return is %s", gst_flow_get_name (flow_return));
if (flow_return != GST_FLOW_OK) {
return FALSE;
}
+ if (self->priv->upstream_latency_min > min) {
+ GstClockTimeDiff diff =
+ GST_CLOCK_DIFF (min, self->priv->upstream_latency_min);
+
+ min += diff;
+ if (GST_CLOCK_TIME_IS_VALID (max)) {
+ max += diff;
+ }
+ }
+
if (min > max && GST_CLOCK_TIME_IS_VALID (max)) {
GST_ELEMENT_WARNING (self, CORE, CLOCK, (NULL),
("Impossible to configure latency: max %" GST_TIME_FORMAT " < min %"
&start, &stop_type, &stop);
GST_OBJECT_LOCK (self);
- gst_segment_do_seek (&self->segment, rate, fmt, flags, start_type, start,
- stop_type, stop, NULL);
+ gst_segment_do_seek (&GST_AGGREGATOR_PAD (self->srcpad)->segment, rate, fmt,
+ flags, start_type, start, stop_type, stop, NULL);
self->priv->seqnum = gst_event_get_seqnum (event);
self->priv->first_buffer = FALSE;
GST_OBJECT_UNLOCK (self);
} else {
ret = gst_pad_send_event (peer, gst_event_ref (evdata->event));
GST_DEBUG_OBJECT (pad, "return of event push is %d", ret);
- gst_object_unref (peer);
}
}
evdata->result &= ret;
+ if (peer)
+ gst_object_unref (peer);
+
/* Always send to all pads */
return FALSE;
}
priv->flush_seeking = TRUE;
}
- gst_segment_do_seek (&self->segment, rate, fmt, flags, start_type, start,
- stop_type, stop, NULL);
+ gst_segment_do_seek (&GST_AGGREGATOR_PAD (self->srcpad)->segment, rate, fmt,
+ flags, start_type, start, stop_type, stop, NULL);
/* Seeking sets a position */
self->priv->first_buffer = FALSE;
case PROP_LATENCY:
gst_aggregator_set_latency_property (agg, g_value_get_uint64 (value));
break;
+ case PROP_MIN_UPSTREAM_LATENCY:
+ SRC_LOCK (agg);
+ agg->priv->upstream_latency_min = g_value_get_uint64 (value);
+ SRC_UNLOCK (agg);
+ break;
case PROP_START_TIME_SELECTION:
agg->priv->start_time_selection = g_value_get_enum (value);
break;
case PROP_LATENCY:
g_value_set_uint64 (value, gst_aggregator_get_latency_property (agg));
break;
+ case PROP_MIN_UPSTREAM_LATENCY:
+ SRC_LOCK (agg);
+ g_value_set_uint64 (value, agg->priv->upstream_latency_min);
+ SRC_UNLOCK (agg);
+ break;
case PROP_START_TIME_SELECTION:
g_value_set_enum (value, agg->priv->start_time_selection);
break;
GstElementClass *gstelement_class = (GstElementClass *) klass;
aggregator_parent_class = g_type_class_peek_parent (klass);
- g_type_class_add_private (klass, sizeof (GstAggregatorPrivate));
GST_DEBUG_CATEGORY_INIT (aggregator_debug, "aggregator",
GST_DEBUG_FG_MAGENTA, "GstAggregator");
+ if (aggregator_private_offset != 0)
+ g_type_class_adjust_private_offset (klass, &aggregator_private_offset);
+
klass->finish_buffer = gst_aggregator_default_finish_buffer;
klass->sink_event = gst_aggregator_default_sink_event;
"position (in nanoseconds)", 0, G_MAXUINT64,
DEFAULT_LATENCY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+ g_object_class_install_property (gobject_class, PROP_MIN_UPSTREAM_LATENCY,
+ g_param_spec_uint64 ("min-upstream-latency", "Buffer latency",
+ "When sources with a higher latency are expected to be plugged "
+ "in dynamically after the aggregator has started playing, "
+ "this allows overriding the minimum latency reported by the "
+ "initial source(s). This is only taken into account when superior "
+ "to the reported minimum latency.",
+ 0, G_MAXUINT64,
+ DEFAULT_LATENCY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
g_object_class_install_property (gobject_class, PROP_START_TIME_SELECTION,
g_param_spec_enum ("start-time-selection", "Start Time Selection",
"Decides which start time is output",
DEFAULT_START_TIME, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}
+static inline gpointer
+gst_aggregator_get_instance_private (GstAggregator * self)
+{
+ return (G_STRUCT_MEMBER_P (self, aggregator_private_offset));
+}
+
static void
gst_aggregator_init (GstAggregator * self, GstAggregatorClass * klass)
{
g_return_if_fail (klass->aggregate != NULL);
- self->priv =
- G_TYPE_INSTANCE_GET_PRIVATE (self, GST_TYPE_AGGREGATOR,
- GstAggregatorPrivate);
+ self->priv = gst_aggregator_get_instance_private (self);
priv = self->priv;
self->priv->peer_latency_min = self->priv->sub_latency_min = 0;
self->priv->peer_latency_max = self->priv->sub_latency_max = 0;
self->priv->has_peer_latency = FALSE;
- gst_aggregator_reset_flow_values (self);
self->srcpad = gst_pad_new_from_template (pad_template, "src");
+ gst_aggregator_reset_flow_values (self);
+
gst_pad_set_event_function (self->srcpad,
GST_DEBUG_FUNCPTR (gst_aggregator_src_pad_event_func));
gst_pad_set_query_function (self->srcpad,
gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
+ self->priv->upstream_latency_min = DEFAULT_MIN_UPSTREAM_LATENCY;
self->priv->latency = DEFAULT_LATENCY;
self->priv->start_time_selection = DEFAULT_START_TIME_SELECTION;
self->priv->start_time = DEFAULT_START_TIME;
_type = g_type_register_static (GST_TYPE_ELEMENT,
"GstAggregator", &info, G_TYPE_FLAG_ABSTRACT);
+
+ aggregator_private_offset =
+ g_type_add_instance_private (_type, sizeof (GstAggregatorPrivate));
+
g_once_init_leave (&type, _type);
}
return type;
if (self->priv->first_buffer) {
GstClockTime start_time;
+ GstAggregatorPad *srcpad = GST_AGGREGATOR_PAD (self->srcpad);
switch (self->priv->start_time_selection) {
case GST_AGGREGATOR_START_TIME_SELECTION_ZERO:
}
if (start_time != -1) {
- if (self->segment.position == -1)
- self->segment.position = start_time;
+ if (srcpad->segment.position == -1)
+ srcpad->segment.position = start_time;
else
- self->segment.position = MIN (start_time, self->segment.position);
+ srcpad->segment.position = MIN (start_time, srcpad->segment.position);
GST_DEBUG_OBJECT (self, "Selecting start time %" GST_TIME_FORMAT,
GST_TIME_ARGS (start_time));
/***********************************
* GstAggregatorPad implementation *
************************************/
-G_DEFINE_TYPE (GstAggregatorPad, gst_aggregator_pad, GST_TYPE_PAD);
+G_DEFINE_TYPE_WITH_PRIVATE (GstAggregatorPad, gst_aggregator_pad, GST_TYPE_PAD);
static void
gst_aggregator_pad_constructed (GObject * object)
{
GObjectClass *gobject_class = (GObjectClass *) klass;
- g_type_class_add_private (klass, sizeof (GstAggregatorPadPrivate));
-
gobject_class->constructed = gst_aggregator_pad_constructed;
gobject_class->finalize = gst_aggregator_pad_finalize;
gobject_class->dispose = gst_aggregator_pad_dispose;
static void
gst_aggregator_pad_init (GstAggregatorPad * pad)
{
- pad->priv =
- G_TYPE_INSTANCE_GET_PRIVATE (pad, GST_TYPE_AGGREGATOR_PAD,
- GstAggregatorPadPrivate);
+ pad->priv = gst_aggregator_pad_get_instance_private (pad);
g_queue_init (&pad->priv->data);
g_cond_init (&pad->priv->event_cond);
PAD_LOCK (pad);
+ if (pad->priv->flow_return != GST_FLOW_OK) {
+ PAD_UNLOCK (pad);
+ return NULL;
+ }
+
gst_aggregator_pad_clip_buffer_unlocked (pad);
buffer = pad->priv->clipped_buffer;
PAD_LOCK (pad);
+ if (pad->priv->flow_return != GST_FLOW_OK) {
+ PAD_UNLOCK (pad);
+ return NULL;
+ }
+
gst_aggregator_pad_clip_buffer_unlocked (pad);
if (pad->priv->clipped_buffer) {
}
/**
+ * gst_aggregator_pad_has_buffer:
+ * @pad: the pad to check the buffer on
+ *
+ * This checks if a pad has a buffer available that will be returned by
+ * a call to gst_aggregator_pad_peek_buffer() or
+ * gst_aggregator_pad_pop_buffer().
+ *
+ * Returns: %TRUE if the pad has a buffer available as the next thing.
+ *
+ * Since: 1.14.1
+ */
+gboolean
+gst_aggregator_pad_has_buffer (GstAggregatorPad * pad)
+{
+ gboolean has_buffer;
+
+ PAD_LOCK (pad);
+ gst_aggregator_pad_clip_buffer_unlocked (pad);
+ has_buffer = (pad->priv->clipped_buffer != NULL);
+ PAD_UNLOCK (pad);
+
+ return has_buffer;
+}
+
+/**
* gst_aggregator_pad_is_eos:
* @pad: an aggregator pad
*
if (params)
*params = self->priv->allocation_params;
}
+
+/**
+ * gst_aggregator_simple_get_next_time:
+ * @self: A #GstAggregator
+ *
+ * This is a simple #GstAggregator::get_next_time implementation that
+ * just looks at the #GstSegment on the srcpad of the aggregator and bases
+ * the next time on the running there there.
+ *
+ * This is the desired behaviour in most cases where you have a live source
+ * and you have a dead line based aggregator subclass.
+ *
+ * Returns: The running time based on the position
+ *
+ * Since: 1.16
+ */
+GstClockTime
+gst_aggregator_simple_get_next_time (GstAggregator * self)
+{
+ GstClockTime next_time;
+ GstAggregatorPad *srcpad = GST_AGGREGATOR_PAD (self->srcpad);
+ GstSegment *segment = &srcpad->segment;
+
+ GST_OBJECT_LOCK (self);
+ if (segment->position == -1 || segment->position < segment->start)
+ next_time = segment->start;
+ else
+ next_time = segment->position;
+
+ if (segment->stop != -1 && next_time > segment->stop)
+ next_time = segment->stop;
+
+ next_time = gst_segment_to_running_time (segment, GST_FORMAT_TIME, next_time);
+ GST_OBJECT_UNLOCK (self);
+
+ return next_time;
+}
projects / platform / upstream / gstreamer.git / blobdiff