gboolean handled;
gboolean marshalled;
- GHook **called_probes;
+ gulong *called_probes;
guint n_called_probes;
guint called_probes_size;
gboolean retry;
/* 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)
* will be assigned.
* This function makes a copy of the name so you can safely free the name.
*
- * Returns: (transfer floating) (nullable): a new #GstPad, or %NULL in
- * case of an error.
+ * Returns: (transfer floating): a new #GstPad.
*
* MT safe.
*/
* will be assigned.
* This function makes a copy of the name so you can safely free the name.
*
- * Returns: (transfer floating) (nullable): a new #GstPad, or %NULL in
- * case of an error.
+ * Returns: (transfer floating): a new #GstPad.
*/
GstPad *
gst_pad_new_from_template (GstPadTemplate * templ, const gchar * name)
* will be assigned.
* This function makes a copy of the name so you can safely free the name.
*
- * Returns: (transfer floating) (nullable): a new #GstPad, or %NULL in
- * case of an error.
+ * Returns: (transfer floating): a new #GstPad.
*/
GstPad *
gst_pad_new_from_static_template (GstStaticPadTemplate * templ,
{
GstPadProbeType type;
+ GST_DEBUG_OBJECT (pad,
+ "cleaning up hook %lu with flags %08x", hook->hook_id, hook->flags);
+
if (!G_HOOK_IS_VALID (hook))
return;
*
* Sets the given unlink function for the pad. It will be called
* when the pad is unlinked.
+ *
+ * Note that the pad's lock is already held when the unlink
+ * function is called, so most pad functions cannot be called
+ * from within the callback.
*/
void
gst_pad_set_unlink_function_full (GstPad * pad, GstPadUnlinkFunction unlink,
/* Default latency implementation */
typedef struct
{
- guint count;
gboolean live;
GstClockTime min, max;
} LatencyFoldData;
GST_LOG_OBJECT (pad, "got latency live:%s min:%" G_GINT64_FORMAT
" max:%" G_GINT64_FORMAT, live ? "true" : "false", min, max);
- /* FIXME : Why do we only take values into account if it's live ? */
- if (live || fold_data->count == 0) {
+ if (live) {
if (min > fold_data->min)
fold_data->min = min;
else if (max < fold_data->max)
fold_data->max = max;
- fold_data->live = live;
+ fold_data->live = TRUE;
}
- fold_data->count += 1;
} else if (peer) {
GST_DEBUG_OBJECT (pad, "latency query failed");
g_value_set_boolean (ret, FALSE);
g_value_init (&ret, G_TYPE_BOOLEAN);
retry:
- fold_data.count = 0;
fold_data.live = FALSE;
fold_data.min = 0;
fold_data.max = GST_CLOCK_TIME_NONE;
ret = gst_pad_query_latency_default (pad, query);
forward = FALSE;
break;
+ case GST_QUERY_BITRATE:
+ /* FIXME: better default handling */
+ forward = TRUE;
+ break;
case GST_QUERY_POSITION:
case GST_QUERY_SEEKING:
case GST_QUERY_FORMATS:
* 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) {
+ if (data->called_probes[i] == hook->hook_id) {
GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
"hook %lu already called", hook->hook_id);
return;
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);
+ g_renew (gulong, data->called_probes, data->called_probes_size);
} else {
- GHook **tmp = data->called_probes;
+ gulong *tmp = data->called_probes;
data->called_probes_size *= 2;
- data->called_probes = g_new (GHook *, data->called_probes_size);
+ data->called_probes = g_new (gulong, data->called_probes_size);
memcpy (data->called_probes, tmp,
- N_STACK_ALLOCATE_PROBES * sizeof (GHook *));
+ N_STACK_ALLOCATE_PROBES * sizeof (gulong));
}
}
- data->called_probes[data->n_called_probes++] = hook;
+ data->called_probes[data->n_called_probes++] = hook->hook_id;
flags = hook->flags >> G_HOOK_FLAG_USER_SHIFT;
type = info->type;
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 (original_data != NULL && info->data == NULL) {
+ if ((flags & GST_PAD_PROBE_TYPE_IDLE))
+ pad->priv->idle_running--;
+
+ if (ret != GST_PAD_PROBE_HANDLED && 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;
data->dropped = TRUE;
ProbeMarshall data;
guint cookie;
gboolean is_block;
- GHook *called_probes[N_STACK_ALLOCATE_PROBES];
+ gulong called_probes[N_STACK_ALLOCATE_PROBES];
data.pad = pad;
data.info = info;
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))
projects / platform / upstream / gstreamer.git / blobdiff