/* FILL ME */
};
-#define GST_PAD_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_PAD, GstPadPrivate))
-
#define _PAD_PROBE_TYPE_ALL_BOTH_AND_FLUSH (GST_PAD_PROBE_TYPE_ALL_BOTH | GST_PAD_PROBE_TYPE_EVENT_FLUSH)
/* we have a pending and an active event on the pad. On source pads only the
gint using;
guint probe_list_cookie;
- guint probe_cookie;
/* counter of how many idle probes are running directly from the add_probe
* call. Used to block any data flowing in the pad while the idle callback
typedef struct
{
GHook hook;
- guint cookie;
} GstProbe;
-#define PROBE_COOKIE(h) (((GstProbe *)(h))->cookie)
#define GST_PAD_IS_RUNNING_IDLE_PROBE(p) \
(((GstPad *)(p))->priv->idle_running > 0)
gboolean pass;
gboolean handled;
gboolean marshalled;
- guint cookie;
+
+ GHook **called_probes;
+ guint n_called_probes;
+ guint called_probes_size;
+ gboolean retry;
} ProbeMarshall;
static void gst_pad_dispose (GObject * object);
}
#define gst_pad_parent_class parent_class
-G_DEFINE_TYPE_WITH_CODE (GstPad, gst_pad, GST_TYPE_OBJECT, _do_init);
+G_DEFINE_TYPE_WITH_CODE (GstPad, gst_pad, GST_TYPE_OBJECT,
+ G_ADD_PRIVATE (GstPad) _do_init);
static void
gst_pad_class_init (GstPadClass * klass)
gobject_class = G_OBJECT_CLASS (klass);
gstobject_class = GST_OBJECT_CLASS (klass);
- g_type_class_add_private (klass, sizeof (GstPadPrivate));
-
gobject_class->dispose = gst_pad_dispose;
gobject_class->finalize = gst_pad_finalize;
gobject_class->set_property = gst_pad_set_property;
static void
gst_pad_init (GstPad * pad)
{
- pad->priv = GST_PAD_GET_PRIVATE (pad);
+ pad->priv = gst_pad_get_instance_private (pad);
GST_PAD_DIRECTION (pad) = GST_PAD_UNKNOWN;
if (G_UNLIKELY (ev->event == NULL))
goto next;
- /* take aditional ref, func might release the lock */
+ /* take additional ref, func might release the lock */
ev_ret.event = gst_event_ref (ev->event);
ev_ret.received = ev->received;
/* should be called with LOCK */
static GstEvent *
-_apply_pad_offset (GstPad * pad, GstEvent * event, gboolean upstream)
+_apply_pad_offset (GstPad * pad, GstEvent * event, gboolean upstream,
+ gint64 pad_offset)
{
gint64 offset;
GST_DEBUG_OBJECT (pad, "apply pad offset %" GST_STIME_FORMAT,
- GST_STIME_ARGS (pad->offset));
+ GST_STIME_ARGS (pad_offset));
if (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT) {
GstSegment segment;
gst_event_copy_segment (event, &segment);
gst_event_unref (event);
- gst_segment_offset_running_time (&segment, segment.format, pad->offset);
+ gst_segment_offset_running_time (&segment, segment.format, pad_offset);
event = gst_event_new_segment (&segment);
}
event = gst_event_make_writable (event);
offset = gst_event_get_running_time_offset (event);
if (upstream)
- offset -= pad->offset;
+ offset -= pad_offset;
else
- offset += pad->offset;
+ offset += pad_offset;
gst_event_set_running_time_offset (event, offset);
return event;
apply_pad_offset (GstPad * pad, GstEvent * event, gboolean upstream)
{
if (G_UNLIKELY (pad->offset != 0))
- return _apply_pad_offset (pad, event, upstream);
+ return _apply_pad_offset (pad, event, upstream, pad->offset);
return event;
}
-
/* should be called with the OBJECT_LOCK */
static GstCaps *
get_pad_caps (GstPad * pad)
GstPad *
gst_pad_new_from_template (GstPadTemplate * templ, const gchar * name)
{
+ GType pad_type =
+ GST_PAD_TEMPLATE_GTYPE (templ) ==
+ G_TYPE_NONE ? GST_TYPE_PAD : GST_PAD_TEMPLATE_GTYPE (templ);
+
g_return_val_if_fail (GST_IS_PAD_TEMPLATE (templ), NULL);
- return g_object_new (GST_TYPE_PAD,
+ return g_object_new (pad_type,
"name", name, "direction", templ->direction, "template", templ, NULL);
}
{
switch (new_mode) {
case GST_PAD_MODE_NONE:
+ GST_OBJECT_LOCK (pad);
+ pad->priv->in_activation = FALSE;
+ g_cond_broadcast (&pad->priv->activation_cond);
+ GST_OBJECT_UNLOCK (pad);
+
/* ensures that streaming stops */
GST_PAD_STREAM_LOCK (pad);
GST_DEBUG_OBJECT (pad, "stopped streaming");
GST_OBJECT_LOCK (pad);
- pad->priv->in_activation = FALSE;
- g_cond_broadcast (&pad->priv->activation_cond);
remove_events (pad);
GST_OBJECT_UNLOCK (pad);
GST_PAD_STREAM_UNLOCK (pad);
GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "adding probe for mask 0x%08x",
mask);
- /* when no contraints are given for the types, assume all types are
+ /* when no constraints are given for the types, assume all types are
* acceptable */
if ((mask & _PAD_PROBE_TYPE_ALL_BOTH_AND_FLUSH) == 0)
mask |= GST_PAD_PROBE_TYPE_ALL_BOTH;
hook->func = callback;
hook->data = user_data;
hook->destroy = destroy_data;
- PROBE_COOKIE (hook) = (pad->priv->probe_cookie - 1);
/* add the probe */
g_hook_append (&pad->probes, hook);
pad->num_probes++;
- /* incremenent cookie so that the new hook get's called */
+ /* incremenent cookie so that the new hook gets called */
pad->priv->probe_list_cookie++;
/* get the id of the hook, we return this and it can be used to remove the
* Gets the peer of @pad. This function refs the peer pad so
* you need to unref it after use.
*
- * Returns: (transfer full): the peer #GstPad. Unref after usage.
+ * Returns: (transfer full) (nullable): the peer #GstPad. Unref after usage.
*
* MT safe.
*/
return ret;
}
+#define N_STACK_ALLOCATE_PROBES (16)
+
static void
probe_hook_marshal (GHook * hook, ProbeMarshall * data)
{
GstPadProbeCallback callback;
GstPadProbeReturn ret;
gpointer original_data;
+ guint i;
- /* if we have called this callback, do nothing */
- if (PROBE_COOKIE (hook) == data->cookie) {
- GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
- "hook %lu, cookie %u already called", hook->hook_id,
- PROBE_COOKIE (hook));
- return;
+ /* if we have called this callback, do nothing. But only check
+ * if we're actually calling probes a second time */
+ if (data->retry) {
+ for (i = 0; i < data->n_called_probes; i++) {
+ if (data->called_probes[i] == hook) {
+ GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
+ "hook %lu already called", hook->hook_id);
+ return;
+ }
+ }
}
- PROBE_COOKIE (hook) = data->cookie;
+ /* reallocate on the heap if we had more than 16 probes */
+ if (data->n_called_probes == data->called_probes_size) {
+ if (data->called_probes_size > N_STACK_ALLOCATE_PROBES) {
+ data->called_probes_size *= 2;
+ data->called_probes =
+ g_renew (GHook *, data->called_probes, data->called_probes_size);
+ } else {
+ GHook **tmp = data->called_probes;
+
+ data->called_probes_size *= 2;
+ data->called_probes = g_new (GHook *, data->called_probes_size);
+ memcpy (data->called_probes, tmp,
+ N_STACK_ALLOCATE_PROBES * sizeof (GHook *));
+ }
+ }
+ data->called_probes[data->n_called_probes++] = hook;
flags = hook->flags >> G_HOOK_FLAG_USER_SHIFT;
type = info->type;
goto no_match;
GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
- "hook %lu, cookie %u with flags 0x%08x matches", hook->hook_id,
- PROBE_COOKIE (hook), flags);
+ "hook %lu with flags 0x%08x matches", hook->hook_id, flags);
data->marshalled = TRUE;
info->id = hook->hook_id;
+ if ((flags & GST_PAD_PROBE_TYPE_IDLE))
+ pad->priv->idle_running++;
+
GST_OBJECT_UNLOCK (pad);
ret = callback (pad, info, hook->data);
GST_OBJECT_LOCK (pad);
+ if ((flags & GST_PAD_PROBE_TYPE_IDLE))
+ pad->priv->idle_running--;
+
if (original_data != NULL && info->data == NULL) {
GST_DEBUG_OBJECT (pad, "data item in pad probe info was dropped");
info->type = GST_PAD_PROBE_TYPE_INVALID;
no_match:
{
GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
- "hook %lu, cookie %u with flags 0x%08x does not match %08x",
- hook->hook_id, PROBE_COOKIE (hook), flags, info->type);
+ "hook %lu with flags 0x%08x does not match %08x",
+ hook->hook_id, flags, info->type);
return;
}
}
ProbeMarshall data;
guint cookie;
gboolean is_block;
+ GHook *called_probes[N_STACK_ALLOCATE_PROBES];
data.pad = pad;
data.info = info;
data.handled = FALSE;
data.marshalled = FALSE;
data.dropped = FALSE;
- data.cookie = ++pad->priv->probe_cookie;
+
+ /* We stack-allocate for N_STACK_ALLOCATE_PROBES hooks as a first step. If more are needed,
+ * we will re-allocate with g_malloc(). This should usually never be needed
+ */
+ data.called_probes = called_probes;
+ data.n_called_probes = 0;
+ data.called_probes_size = N_STACK_ALLOCATE_PROBES;
+ data.retry = FALSE;
is_block =
(info->type & GST_PAD_PROBE_TYPE_BLOCK) == GST_PAD_PROBE_TYPE_BLOCK;
}
again:
- GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
- "do probes cookie %u", data.cookie);
+ GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "do probes");
cookie = pad->priv->probe_list_cookie;
g_hook_list_marshal (&pad->probes, TRUE,
(GHookMarshaller) probe_hook_marshal, &data);
- /* if the list changed, call the new callbacks (they will not have their
- * cookie set to data.cookie */
+ /* if the list changed, call the new callbacks (they will not be in
+ * called_probes yet) */
if (cookie != pad->priv->probe_list_cookie) {
GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
"probe list changed, restarting");
+ data.retry = TRUE;
goto again;
}
GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_BLOCKING);
GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "We got unblocked");
- /* if the list changed, call the new callbacks (they will not have their
- * cookie set to data.cookie */
+ /* if the list changed, call the new callbacks (they will not be in
+ * called_probes yet) */
if (cookie != pad->priv->probe_list_cookie) {
GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
"probe list changed, restarting");
+ data.retry = TRUE;
goto again;
}
}
}
+ if (data.called_probes_size > N_STACK_ALLOCATE_PROBES)
+ g_free (data.called_probes);
+
return defaultval;
/* ERRORS */
flushing:
{
GST_DEBUG_OBJECT (pad, "pad is flushing");
+ if (data.called_probes_size > N_STACK_ALLOCATE_PROBES)
+ g_free (data.called_probes);
return GST_FLOW_FLUSHING;
}
dropped:
{
GST_DEBUG_OBJECT (pad, "data is dropped");
+ if (data.called_probes_size > N_STACK_ALLOCATE_PROBES)
+ g_free (data.called_probes);
return GST_FLOW_CUSTOM_SUCCESS;
}
passed:
{
/* FIXME : Should we return FLOW_OK or the defaultval ?? */
GST_DEBUG_OBJECT (pad, "data is passed");
+ if (data.called_probes_size > N_STACK_ALLOCATE_PROBES)
+ g_free (data.called_probes);
return GST_FLOW_OK;
}
handled:
{
GST_DEBUG_OBJECT (pad, "data was handled");
+ if (data.called_probes_size > N_STACK_ALLOCATE_PROBES)
+ g_free (data.called_probes);
return GST_FLOW_CUSTOM_SUCCESS_1;
}
}
} else {
data->ret = gst_pad_push_event_unchecked (pad, gst_event_ref (event),
GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM);
+ if (data->ret == GST_FLOW_CUSTOM_SUCCESS_1)
+ data->ret = GST_FLOW_OK;
}
switch (data->ret) {
GstFlowReturn ret;
GstPad *peerpad;
GstEventType event_type;
+ gint64 old_pad_offset = pad->offset;
/* pass the adjusted event on. We need to do this even if
* there is no peer pad because of the probes. */
events_foreach (pad, sticky_changed, &data);
}
+ /* the pad offset might've been changed by any of the probes above. It
+ * would've been taken into account when repushing any of the sticky events
+ * above but not for our current event here */
+ if (G_UNLIKELY (old_pad_offset != pad->offset)) {
+ event =
+ _apply_pad_offset (pad, event, GST_PAD_IS_SINK (pad),
+ pad->offset - old_pad_offset);
+ }
+
/* now check the peer pad */
peerpad = GST_PAD_PEER (pad);
if (peerpad == NULL)
GstPadEventFunction eventfunc;
GstPadEventFullFunction eventfullfunc = NULL;
GstObject *parent;
+ gint64 old_pad_offset;
GST_OBJECT_LOCK (pad);
+ old_pad_offset = pad->offset;
event = apply_pad_offset (pad, event, GST_PAD_IS_SRC (pad));
if (GST_PAD_IS_SINK (pad))
PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_PUSH, event, probe_stopped);
+ /* the pad offset might've been changed by any of the probes above. It
+ * would've been taken into account when repushing any of the sticky events
+ * above but not for our current event here */
+ if (G_UNLIKELY (old_pad_offset != pad->offset)) {
+ event =
+ _apply_pad_offset (pad, event, GST_PAD_IS_SRC (pad),
+ pad->offset - old_pad_offset);
+ }
+
eventfullfunc = GST_PAD_EVENTFULLFUNC (pad);
eventfunc = GST_PAD_EVENTFUNC (pad);
if (G_UNLIKELY (eventfunc == NULL && eventfullfunc == NULL))
* Gets the private data of a pad.
* No locking is performed in this function.
*
- * Returns: (transfer none): a #gpointer to the private data.
+ * Returns: (transfer none) (nullable): a #gpointer to the private data.
*/
gpointer
gst_pad_get_element_private (GstPad * pad)
if (task == NULL)
goto no_task;
res = gst_task_set_state (task, GST_TASK_PAUSED);
+ /* unblock activation waits if any */
+ pad->priv->in_activation = FALSE;
+ g_cond_broadcast (&pad->priv->activation_cond);
GST_OBJECT_UNLOCK (pad);
/* wait for task function to finish, this lock is recursive so it does nothing
goto no_task;
GST_PAD_TASK (pad) = NULL;
res = gst_task_set_state (task, GST_TASK_STOPPED);
+ /* unblock activation waits if any */
+ pad->priv->in_activation = FALSE;
+ g_cond_broadcast (&pad->priv->activation_cond);
GST_OBJECT_UNLOCK (pad);
GST_PAD_STREAM_LOCK (pad);
* gst_pad_probe_info_get_event:
* @info: a #GstPadProbeInfo
*
- * Returns: (transfer none): The #GstEvent from the probe
+ * Returns: (transfer none) (nullable): The #GstEvent from the probe
*/
GstEvent *
* gst_pad_probe_info_get_query:
* @info: a #GstPadProbeInfo
*
- * Returns: (transfer none): The #GstQuery from the probe
+ * Returns: (transfer none) (nullable): The #GstQuery from the probe
*/
GstQuery *
* gst_pad_probe_info_get_buffer:
* @info: a #GstPadProbeInfo
*
- * Returns: (transfer none): The #GstBuffer from the probe
+ * Returns: (transfer none) (nullable): The #GstBuffer from the probe
*/
GstBuffer *
* gst_pad_probe_info_get_buffer_list:
* @info: a #GstPadProbeInfo
*
- * Returns: (transfer none): The #GstBufferList from the probe
+ * Returns: (transfer none) (nullable): The #GstBufferList from the probe
*/
GstBufferList *
projects / platform / upstream / gstreamer.git / blobdiff