GST_OPT_SCHEDULER_STATE_ERROR,
GST_OPT_SCHEDULER_STATE_RUNNING,
GST_OPT_SCHEDULER_STATE_INTERRUPTED
-} GstOptSchedulerState;
+}
+GstOptSchedulerState;
struct _GstOptScheduler
{
GST_OPT_SCHEDULER_CHAIN_DIRTY = (1 << 1),
GST_OPT_SCHEDULER_CHAIN_DISABLED = (1 << 2),
GST_OPT_SCHEDULER_CHAIN_RUNNING = (1 << 3),
-} GstOptSchedulerChainFlags;
+}
+GstOptSchedulerChainFlags;
#define GST_OPT_SCHEDULER_CHAIN_DISABLE(chain) ((chain)->flags |= GST_OPT_SCHEDULER_CHAIN_DISABLED)
#define GST_OPT_SCHEDULER_CHAIN_ENABLE(chain) ((chain)->flags &= ~GST_OPT_SCHEDULER_CHAIN_DISABLED)
GstOptSchedulerChainFlags flags;
- GSList *groups; /* the groups in this chain */
+ GSList *groups; /* the groups in this chain */
gint num_groups;
gint num_enabled;
};
*/
typedef enum
{
- GST_OPT_SCHEDULER_GROUP_DIRTY = (1 << 1), /* this group has been modified */
- GST_OPT_SCHEDULER_GROUP_COTHREAD_STOPPING = (1 << 2), /* the group's cothread stops after one iteration */
- GST_OPT_SCHEDULER_GROUP_DISABLED = (1 << 3), /* this group is disabled */
- GST_OPT_SCHEDULER_GROUP_RUNNING = (1 << 4), /* this group is running */
- GST_OPT_SCHEDULER_GROUP_SCHEDULABLE = (1 << 5), /* this group is schedulable */
- GST_OPT_SCHEDULER_GROUP_VISITED = (1 << 6), /* this group is visited when finding links */
-} GstOptSchedulerGroupFlags;
+ GST_OPT_SCHEDULER_GROUP_DIRTY = (1 << 1), /* this group has been modified */
+ GST_OPT_SCHEDULER_GROUP_COTHREAD_STOPPING = (1 << 2), /* the group's cothread stops after one iteration */
+ GST_OPT_SCHEDULER_GROUP_DISABLED = (1 << 3), /* this group is disabled */
+ GST_OPT_SCHEDULER_GROUP_RUNNING = (1 << 4), /* this group is running */
+ GST_OPT_SCHEDULER_GROUP_SCHEDULABLE = (1 << 5), /* this group is schedulable */
+ GST_OPT_SCHEDULER_GROUP_VISITED = (1 << 6), /* this group is visited when finding links */
+}
+GstOptSchedulerGroupFlags;
typedef enum
{
GST_OPT_SCHEDULER_GROUP_GET = 1,
GST_OPT_SCHEDULER_GROUP_LOOP = 2,
-} GstOptSchedulerGroupType;
+}
+GstOptSchedulerGroupType;
#define GST_OPT_SCHEDULER_GROUP_SET_FLAG(group,flag) ((group)->flags |= (flag))
#define GST_OPT_SCHEDULER_GROUP_UNSET_FLAG(group,flag) ((group)->flags &= ~(flag))
/* used to keep track of links with other groups */
struct _GstOptSchedulerGroupLink
{
- GstOptSchedulerGroup *group1; /* the group we are linked with */
- GstOptSchedulerGroup *group2; /* the group we are linked with */
- gint count; /* the number of links with the group */
+ GstOptSchedulerGroup *group1; /* the group we are linked with */
+ GstOptSchedulerGroup *group2; /* the group we are linked with */
+ gint count; /* the number of links with the group */
};
#define IS_GROUP_LINK(link, group1, group2) ((link->group1 == group1 && link->group2 == group2) || \
struct _GstOptSchedulerGroup
{
- GstOptSchedulerChain *chain; /* the chain this group belongs to */
- GstOptSchedulerGroupFlags flags; /* flags for this group */
- GstOptSchedulerGroupType type; /* flags for this group */
+ GstOptSchedulerChain *chain; /* the chain this group belongs to */
+ GstOptSchedulerGroupFlags flags; /* flags for this group */
+ GstOptSchedulerGroupType type; /* flags for this group */
gint refcount;
- GSList *elements; /* elements of this group */
+ GSList *elements; /* elements of this group */
gint num_elements;
gint num_enabled;
- GstElement *entry; /* the group's entry point */
+ GstElement *entry; /* the group's entry point */
- GSList *group_links; /* other groups that are linked with this group */
+ GSList *group_links; /* other groups that are linked with this group */
#ifdef USE_COTHREADS
- cothread *cothread; /* the cothread of this group */
+ cothread *cothread; /* the cothread of this group */
#else
GroupScheduleFunction schedulefunc;
#endif
typedef enum
{
- GST_OPT_SCHEDULER_CTX_DISABLED = (1 << 1), /* the element is disabled */
-} GstOptSchedulerCtxFlags;
+ GST_OPT_SCHEDULER_CTX_DISABLED = (1 << 1), /* the element is disabled */
+}
+GstOptSchedulerCtxFlags;
struct _GstOptSchedulerCtx
{
- GstOptSchedulerGroup *group; /* the group this element belongs to */
+ GstOptSchedulerGroup *group; /* the group this element belongs to */
- GstOptSchedulerCtxFlags flags; /* flags for this element */
+ GstOptSchedulerCtxFlags flags; /* flags for this element */
};
};
_gst_opt_scheduler_type = g_type_register_static (GST_TYPE_SCHEDULER,
- "GstOpt" COTHREADS_NAME_CAPITAL "Scheduler", &scheduler_info, 0);
+ "GstOpt" COTHREADS_NAME_CAPITAL "Scheduler", &scheduler_info, 0);
}
return _gst_opt_scheduler_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ITERATIONS,
g_param_spec_int ("iterations", "Iterations",
- "Number of groups to schedule in one iteration (-1 == until EOS/error)",
- -1, G_MAXINT, 1, G_PARAM_READWRITE));
+ "Number of groups to schedule in one iteration (-1 == until EOS/error)",
+ -1, G_MAXINT, 1, G_PARAM_READWRITE));
#ifndef USE_COTHREADS
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MAX_RECURSION,
g_param_spec_int ("max_recursion", "Max recursion",
- "Maximum number of recursions", 1, G_MAXINT, 100, G_PARAM_READWRITE));
+ "Maximum number of recursions", 1, G_MAXINT, 100, G_PARAM_READWRITE));
#endif
gstscheduler_class->setup = GST_DEBUG_FUNCPTR (gst_opt_scheduler_setup);
chain->num_enabled++;
GST_DEBUG ("enable group %p in chain %p, now %d groups enabled out of %d",
- group, chain, chain->num_enabled, chain->num_groups);
+ group, chain, chain->num_enabled, chain->num_groups);
/* OK to call even if the scheduler (cothread context / schedulerfunc) was
setup already -- will get destroyed when the group is destroyed */
chain->num_enabled--;
GST_DEBUG ("disable group %p in chain %p, now %d groups enabled out of %d",
- group, chain, chain->num_enabled, chain->num_groups);
+ group, chain, chain->num_enabled, chain->num_groups);
if (chain->num_enabled == 0) {
GST_DEBUG ("disable chain %p", chain);
links = g_slist_next (links);
chain_recursively_migrate_group (chain,
- (link->group1 == group ? link->group2 : link->group1));
+ (link->group1 == group ? link->group2 : link->group1));
}
}
group = g_new0 (GstOptSchedulerGroup, 1);
GST_LOG ("new group %p", group);
- group->refcount = 1; /* float... */
+ group->refcount = 1; /* float... */
group->flags = GST_OPT_SCHEDULER_GROUP_DISABLED;
group->type = type;
add_to_group (group, element);
add_to_chain (chain, group);
- group = unref_group (group); /* ...and sink. */
+ group = unref_group (group); /* ...and sink. */
/* group's refcount is now 2 (one for the element, one for the chain) */
if (GST_ELEMENT_IS_DECOUPLED (element)) {
GST_DEBUG ("element \"%s\" is decoupled, not adding to group %p",
- GST_ELEMENT_NAME (element), group);
+ GST_ELEMENT_NAME (element), group);
return group;
}
#ifdef USE_COTHREADS
if (!(group->flags & GST_OPT_SCHEDULER_GROUP_SCHEDULABLE)) {
do_cothread_create (group->cothread, osched->context,
- (cothread_func) wrapper, 0, (char **) group);
+ (cothread_func) wrapper, 0, (char **) group);
} else {
do_cothread_setfunc (group->cothread, osched->context,
- (cothread_func) wrapper, 0, (char **) group);
+ (cothread_func) wrapper, 0, (char **) group);
}
#else
group->schedulefunc = wrapper;
group->num_enabled++;
GST_DEBUG
- ("enable element %s in group %p, now %d elements enabled out of %d",
- GST_ELEMENT_NAME (element), group, group->num_enabled,
- group->num_elements);
+ ("enable element %s in group %p, now %d elements enabled out of %d",
+ GST_ELEMENT_NAME (element), group, group->num_enabled,
+ group->num_elements);
if (group->num_enabled == group->num_elements) {
if (!group->chain) {
- GST_DEBUG ("enable chainless group %p", group);
- GST_OPT_SCHEDULER_GROUP_ENABLE (group);
+ GST_DEBUG ("enable chainless group %p", group);
+ GST_OPT_SCHEDULER_GROUP_ENABLE (group);
} else {
- GST_LOG ("enable group %p", group);
- chain_group_set_enabled (group->chain, group, TRUE);
+ GST_LOG ("enable group %p", group);
+ chain_group_set_enabled (group->chain, group, TRUE);
}
}
} else {
group->num_enabled--;
GST_DEBUG
- ("disable element %s in group %p, now %d elements enabled out of %d",
- GST_ELEMENT_NAME (element), group, group->num_enabled,
- group->num_elements);
+ ("disable element %s in group %p, now %d elements enabled out of %d",
+ GST_ELEMENT_NAME (element), group, group->num_enabled,
+ group->num_elements);
if (group->num_enabled == 0) {
if (!group->chain) {
- GST_DEBUG ("disable chainless group %p", group);
- GST_OPT_SCHEDULER_GROUP_DISABLE (group);
+ GST_DEBUG ("disable chainless group %p", group);
+ GST_OPT_SCHEDULER_GROUP_DISABLE (group);
} else {
- GST_LOG ("disable group %p", group);
- chain_group_set_enabled (group->chain, group, FALSE);
+ GST_LOG ("disable group %p", group);
+ chain_group_set_enabled (group->chain, group, FALSE);
}
}
}
GstElement *e = (GstElement *) l->data;
if (e->pre_run_func)
- e->pre_run_func (e);
+ e->pre_run_func (e);
}
group->schedulefunc (group->argc, group->argv);
GstElement *e = (GstElement *) l->data;
if (e->post_run_func)
- e->post_run_func (e);
+ e->post_run_func (e);
}
}
#else
osched->recursion = 0;
if (!g_list_find (osched->runqueue, group)) {
- ref_group (group);
- osched->runqueue = g_list_append (osched->runqueue, group);
+ ref_group (group);
+ osched->runqueue = g_list_append (osched->runqueue, group);
}
gst_opt_scheduler_schedule_run_queue (osched);
#endif
continue;
GST_DEBUG ("doing get and push on pad \"%s:%s\" in group %p",
- GST_DEBUG_PAD_NAME (pad), group);
+ GST_DEBUG_PAD_NAME (pad), group);
data = GST_RPAD_GETFUNC (pad) (pad);
if (data) {
if (GST_EVENT_IS_INTERRUPT (data)) {
- gst_event_unref (GST_EVENT (data));
- break;
+ gst_event_unref (GST_EVENT (data));
+ break;
}
gst_pad_push (pad, data);
}
group_error_handler (group);
} else {
GST_LOG ("queueing data %p on %s:%s's bufpen", data,
- GST_DEBUG_PAD_NAME (peer));
+ GST_DEBUG_PAD_NAME (peer));
GST_PAD_BUFLIST (peer) = g_list_append (GST_PAD_BUFLIST (peer), data);
schedule_group (group);
}
ref_group (group);
if (!g_list_find (osched->runqueue, group)) {
- ref_group (group);
- osched->runqueue = g_list_append (osched->runqueue, group);
+ ref_group (group);
+ osched->runqueue = g_list_append (osched->runqueue, group);
}
GST_LOG ("recursing into scheduler group %p", group);
group = unref_group (group);
/* group is gone */
if (group == NULL) {
- /* if the group was gone we also might have to break out of the loop */
- disabled = TRUE;
+ /* if the group was gone we also might have to break out of the loop */
+ disabled = TRUE;
}
} else {
/* in this case, the group was running and we wanted to swtich to it,
data = GST_DATA (gst_event_new (GST_EVENT_INTERRUPT));
} else {
if (GST_PAD_BUFLIST (srcpad)) {
- data = GST_PAD_BUFLIST (srcpad)->data;
- GST_PAD_BUFLIST (srcpad) =
- g_list_remove (GST_PAD_BUFLIST (srcpad), data);
+ data = GST_PAD_BUFLIST (srcpad)->data;
+ GST_PAD_BUFLIST (srcpad) =
+ g_list_remove (GST_PAD_BUFLIST (srcpad), data);
} else if (disabled) {
- /* no buffer in queue and peer group was disabled */
- data = GST_DATA (gst_event_new (GST_EVENT_INTERRUPT));
+ /* no buffer in queue and peer group was disabled */
+ data = GST_DATA (gst_event_new (GST_EVENT_INTERRUPT));
}
}
}
GST_LOG ("parent \"%s\" changed state", GST_ELEMENT_NAME (element));
switch (transition) {
- case GST_STATE_PLAYING_TO_PAUSED:
- GST_INFO ("setting scheduler state to stopped");
- GST_SCHEDULER_STATE (sched) = GST_SCHEDULER_STATE_STOPPED;
- break;
- case GST_STATE_PAUSED_TO_PLAYING:
- GST_INFO ("setting scheduler state to running");
- GST_SCHEDULER_STATE (sched) = GST_SCHEDULER_STATE_RUNNING;
- break;
- default:
- GST_LOG ("no interesting state change, doing nothing");
+ case GST_STATE_PLAYING_TO_PAUSED:
+ GST_INFO ("setting scheduler state to stopped");
+ GST_SCHEDULER_STATE (sched) = GST_SCHEDULER_STATE_STOPPED;
+ break;
+ case GST_STATE_PAUSED_TO_PLAYING:
+ GST_INFO ("setting scheduler state to running");
+ GST_SCHEDULER_STATE (sched) = GST_SCHEDULER_STATE_RUNNING;
+ break;
+ default:
+ GST_LOG ("no interesting state change, doing nothing");
}
}
return res;
/* an element withut a group has to be an unlinked src, sink
* filter element */
if (!group) {
- GST_INFO ("element \"%s\" has no group", GST_ELEMENT_NAME (element));
- res = GST_STATE_FAILURE;
+ GST_INFO ("element \"%s\" has no group", GST_ELEMENT_NAME (element));
+ res = GST_STATE_FAILURE;
}
/* else construct the scheduling context of this group and enable it */
else {
- group_element_set_enabled (group, element, TRUE);
+ group_element_set_enabled (group, element, TRUE);
}
break;
case GST_STATE_PLAYING_TO_PAUSED:
/* if the element still has a group, we disable it */
if (group)
- group_element_set_enabled (group, element, FALSE);
+ group_element_set_enabled (group, element, FALSE);
break;
case GST_STATE_PAUSED_TO_READY:
{
GstOptSchedulerChain *chain;
GST_DEBUG ("creating new group to hold \"%s\" and \"%s\"",
- GST_ELEMENT_NAME (element1), GST_ELEMENT_NAME (element2));
+ GST_ELEMENT_NAME (element1), GST_ELEMENT_NAME (element2));
chain = create_chain (osched);
group = create_group (chain, element1, type);
/* the first element has a group */
else if (group1) {
GST_DEBUG ("adding \"%s\" to \"%s\"'s group",
- GST_ELEMENT_NAME (element2), GST_ELEMENT_NAME (element1));
+ GST_ELEMENT_NAME (element2), GST_ELEMENT_NAME (element1));
/* the second element also has a group, merge */
if (group2)
* group of element2 */
else {
GST_DEBUG ("adding \"%s\" to \"%s\"'s group",
- GST_ELEMENT_NAME (element1), GST_ELEMENT_NAME (element2));
+ GST_ELEMENT_NAME (element1), GST_ELEMENT_NAME (element2));
add_to_group (group2, element1);
group = group2;
}
/* we found a link to this group, increment the link count */
link->count++;
GST_LOG ("incremented group link count between %p and %p to %d",
- group1, group2, link->count);
+ group1, group2, link->count);
done = TRUE;
}
}
if (IS_GROUP_LINK (link, group1, group2)) {
link->count--;
GST_LOG ("link count between %p and %p is now %d",
- group1, group2, link->count);
+ group1, group2, link->count);
if (link->count == 0) {
- group1->group_links = g_slist_remove (group1->group_links, link);
- group2->group_links = g_slist_remove (group2->group_links, link);
- g_free (link);
- GST_DEBUG ("removed group link between %p and %p", group1, group2);
- res = TRUE;
+ group1->group_links = g_slist_remove (group1->group_links, link);
+ group2->group_links = g_slist_remove (group2->group_links, link);
+ g_free (link);
+ GST_DEBUG ("removed group link between %p and %p", group1, group2);
+ res = TRUE;
}
break;
}
GST_OPT_CHAIN_TO_CHAIN,
GST_OPT_CHAIN_TO_LOOP,
GST_OPT_LOOP_TO_LOOP,
-} LinkType;
+}
+LinkType;
/*
* Entry points for this scheduler.
group->entry = element;
GST_LOG ("added element \"%s\" as loop based entry",
- GST_ELEMENT_NAME (element));
+ GST_ELEMENT_NAME (element));
}
}
get_group (element, &group);
if (group && group->entry == element)
do_cothread_switch (do_cothread_get_main (((GstOptScheduler *) sched)->
- context));
+ context));
return FALSE;
#else
#ifdef USE_COTHREADS
do_cothread_switch (do_cothread_get_main (((GstOptScheduler *) sched)->
- context));
+ context));
return FALSE;
#else
{
else {
if (element1->loopfunc) {
if (GST_RPAD_CHAINFUNC (sinkpad))
- type = GST_OPT_LOOP_TO_CHAIN;
+ type = GST_OPT_LOOP_TO_CHAIN;
} else if (element2->loopfunc) {
if (GST_RPAD_GETFUNC (srcpad)) {
- type = GST_OPT_GET_TO_LOOP;
- /* this could be tricky, the get based source could
- * already be part of a loop based group in another pad,
- * we assert on that for now */
- if (GST_ELEMENT_SCHED_CONTEXT (element1) != NULL &&
- GST_ELEMENT_SCHED_GROUP (element1) != NULL) {
- GstOptSchedulerGroup *group = GST_ELEMENT_SCHED_GROUP (element1);
-
- /* if the loop based element is the entry point we're ok, if it
- * isn't then we have multiple loop based elements in this group */
- if (group->entry != element2) {
- g_error
- ("internal error: cannot schedule get to loop in multi-loop based group");
- return;
- }
- }
+ type = GST_OPT_GET_TO_LOOP;
+ /* this could be tricky, the get based source could
+ * already be part of a loop based group in another pad,
+ * we assert on that for now */
+ if (GST_ELEMENT_SCHED_CONTEXT (element1) != NULL &&
+ GST_ELEMENT_SCHED_GROUP (element1) != NULL) {
+ GstOptSchedulerGroup *group = GST_ELEMENT_SCHED_GROUP (element1);
+
+ /* if the loop based element is the entry point we're ok, if it
+ * isn't then we have multiple loop based elements in this group */
+ if (group->entry != element2) {
+ g_error
+ ("internal error: cannot schedule get to loop in multi-loop based group");
+ return;
+ }
+ }
} else
- type = GST_OPT_CHAIN_TO_LOOP;
+ type = GST_OPT_CHAIN_TO_LOOP;
} else {
if (GST_RPAD_GETFUNC (srcpad) && GST_RPAD_CHAINFUNC (sinkpad)) {
- type = GST_OPT_GET_TO_CHAIN;
- /* the get based source could already be part of a loop
- * based group in another pad, we assert on that for now */
- if (GST_ELEMENT_SCHED_CONTEXT (element1) != NULL &&
- GST_ELEMENT_SCHED_GROUP (element1) != NULL) {
- GstOptSchedulerGroup *group = GST_ELEMENT_SCHED_GROUP (element1);
-
- /* if the get based element is the entry point we're ok, if it
- * isn't then we have a mixed loop/chain based group */
- if (group->entry != element1) {
- g_error
- ("internal error: cannot schedule get to chain with mixed loop/chain based group");
- return;
- }
- }
+ type = GST_OPT_GET_TO_CHAIN;
+ /* the get based source could already be part of a loop
+ * based group in another pad, we assert on that for now */
+ if (GST_ELEMENT_SCHED_CONTEXT (element1) != NULL &&
+ GST_ELEMENT_SCHED_GROUP (element1) != NULL) {
+ GstOptSchedulerGroup *group = GST_ELEMENT_SCHED_GROUP (element1);
+
+ /* if the get based element is the entry point we're ok, if it
+ * isn't then we have a mixed loop/chain based group */
+ if (group->entry != element1) {
+ g_error
+ ("internal error: cannot schedule get to chain with mixed loop/chain based group");
+ return;
+ }
+ }
} else
- type = GST_OPT_CHAIN_TO_CHAIN;
+ type = GST_OPT_CHAIN_TO_CHAIN;
}
}
/* setup get/chain handlers */
GST_RPAD_GETHANDLER (srcpad) = GST_RPAD_GETFUNC (srcpad);
if (GST_ELEMENT_IS_EVENT_AWARE (element2))
- GST_RPAD_CHAINHANDLER (sinkpad) = GST_RPAD_CHAINFUNC (sinkpad);
+ GST_RPAD_CHAINHANDLER (sinkpad) = GST_RPAD_CHAINFUNC (sinkpad);
else
- GST_RPAD_CHAINHANDLER (sinkpad) = gst_opt_scheduler_chain_wrapper;
+ GST_RPAD_CHAINHANDLER (sinkpad) = gst_opt_scheduler_chain_wrapper;
/* the two elements should be put into the same group,
* this also means that they are in the same chain automatically */
group = group_elements (osched, element1, element2,
- GST_OPT_SCHEDULER_GROUP_GET);
+ GST_OPT_SCHEDULER_GROUP_GET);
/* if there is not yet an entry in the group, select the source
* element as the entry point */
if (!group->entry) {
- group->entry = element1;
+ group->entry = element1;
- GST_DEBUG ("setting \"%s\" as entry point of _get-based group %p",
- GST_ELEMENT_NAME (element1), group);
+ GST_DEBUG ("setting \"%s\" as entry point of _get-based group %p",
+ GST_ELEMENT_NAME (element1), group);
}
break;
}
GST_LOG ("loop/chain to chain based link");
if (GST_ELEMENT_IS_EVENT_AWARE (element2))
- GST_RPAD_CHAINHANDLER (sinkpad) = GST_RPAD_CHAINFUNC (sinkpad);
+ GST_RPAD_CHAINHANDLER (sinkpad) = GST_RPAD_CHAINFUNC (sinkpad);
else
- GST_RPAD_CHAINHANDLER (sinkpad) = gst_opt_scheduler_chain_wrapper;
+ GST_RPAD_CHAINHANDLER (sinkpad) = gst_opt_scheduler_chain_wrapper;
/* the two elements should be put into the same group,
* this also means that they are in the same chain automatically,
/* group2 is guaranteed to exist as it contains a loop-based element.
* group1 only exists if element1 is linked to some other element */
if (!group1) {
- /* create a new group for element1 as it cannot be merged into another group
- * here. we create the group in the same chain as the loop-based element. */
- GST_DEBUG ("creating new group for element %s",
- GST_ELEMENT_NAME (element1));
- group1 =
- create_group (group2->chain, element1,
- GST_OPT_SCHEDULER_GROUP_LOOP);
+ /* create a new group for element1 as it cannot be merged into another group
+ * here. we create the group in the same chain as the loop-based element. */
+ GST_DEBUG ("creating new group for element %s",
+ GST_ELEMENT_NAME (element1));
+ group1 =
+ create_group (group2->chain, element1,
+ GST_OPT_SCHEDULER_GROUP_LOOP);
} else {
- /* both elements are already in a group, make sure they are added to
- * the same chain */
- merge_chains (group1->chain, group2->chain);
+ /* both elements are already in a group, make sure they are added to
+ * the same chain */
+ merge_chains (group1->chain, group2->chain);
}
group_inc_link (group1, group2);
break;
/* links with decoupled elements are valid */
if (GST_ELEMENT_IS_DECOUPLED (parent)) {
- linked = TRUE;
+ linked = TRUE;
} else {
- /* for non-decoupled elements we need to check the group */
- get_group (parent, &parentgroup);
+ /* for non-decoupled elements we need to check the group */
+ get_group (parent, &parentgroup);
- /* if it's in the same group, we're still linked */
- if (parentgroup == group)
- linked = TRUE;
+ /* if it's in the same group, we're still linked */
+ if (parentgroup == group)
+ linked = TRUE;
}
}
}
/* if the group is marked as visited, we don't need to check here */
if (GST_OPT_SCHEDULER_GROUP_IS_FLAG_SET (group,
- GST_OPT_SCHEDULER_GROUP_VISITED)) {
+ GST_OPT_SCHEDULER_GROUP_VISITED)) {
GST_LOG ("already visited %p", group);
return FALSE;
}
if (GST_IS_REAL_PAD (pad) && GST_PAD_PEER (pad)) {
get_group (GST_PAD_PARENT (GST_PAD_PEER (pad)), &peer_group);
if (peer_group && peer_group != group)
- group_dec_link (group, peer_group);
+ group_dec_link (group, peer_group);
}
}
}
static void
-gst_opt_scheduler_pad_unlink (GstScheduler * sched, GstPad * srcpad,
- GstPad * sinkpad)
+gst_opt_scheduler_pad_unlink (GstScheduler * sched,
+ GstPad * srcpad, GstPad * sinkpad)
{
GstOptScheduler *osched = GST_OPT_SCHEDULER (sched);
GstElement *element1, *element2;
* about the link */
if (!group1 || !group2) {
GST_LOG
- ("one (or both) of the elements is not in a group, not interesting");
+ ("one (or both) of the elements is not in a group, not interesting");
return;
}
still_link = group_can_reach_group (group1, group2);
GST_DEBUG ("group %p %s reach group %p", group1,
- (still_link ? "can" : "can't"), group2);
+ (still_link ? "can" : "can't"), group2);
if (!still_link) {
- /* groups are really disconnected, migrate one group to a new chain */
- chain = create_chain (osched);
- chain_recursively_migrate_group (chain, group1);
+ /* groups are really disconnected, migrate one group to a new chain */
+ chain = create_chain (osched);
+ chain_recursively_migrate_group (chain, group1);
- GST_DEBUG ("migrated group %p to new chain %p", group1, chain);
+ GST_DEBUG ("migrated group %p to new chain %p", group1, chain);
}
} else {
GST_DEBUG ("group %p still has direct link with group %p", group1,
- group2);
+ group2);
}
}
/* hard part, groups are equal */
else {
gboolean still_link1, still_link2;
GstOptSchedulerGroup *group;
- GstElement *element = NULL; /* shut up gcc */
/* since group1 == group2, it doesn't matter which group we take */
group = group1;
GST_LOG ("elements still have links with other elements in the group");
while (group->elements)
- for (l = group->elements; l && l->data; l = l->next) {
- element = (GstElement *) l->data;
- if (GST_ELEMENT_IS_DECOUPLED (element))
- continue;
-
- linkcount = 0;
- GST_LOG ("Examining %s\n", GST_ELEMENT_NAME (element));
- for (m = GST_ELEMENT_PADS (element); m; m = m->next) {
- GstPad *peer, *pad;
- GstElement *parent;
- GstOptSchedulerGroup *peer_group;
-
- pad = (GstPad *) m->data;
- if (!pad || !GST_IS_REAL_PAD (pad))
- continue;
-
- peer = GST_PAD_PEER (pad);
- if (!peer || !GST_IS_REAL_PAD (peer))
- continue;
-
- parent = GST_PAD_PARENT (GST_PAD_PEER (pad));
- get_group (parent, &peer_group);
- if (peer_group && peer_group != group) {
- GST_LOG ("pad %s is linked with %s\n",
- GST_PAD_NAME (pad), GST_ELEMENT_NAME (parent));
- linkcount++;
- }
- }
-
- if (linkcount < 2) {
- group_dec_links_for_element (group, element);
- remove_from_group (group, element);
- }
- /* if linkcount == 2, it will be unlinked later on */
- else if (linkcount > 2) {
- g_warning
- ("opt: Can't handle element %s with 3 or more links, aborting",
- GST_ELEMENT_NAME (element));
- return;
- }
- }
+ for (l = group->elements; l && l->data; l = l->next) {
+ GstElement *element = (GstElement *) l->data;
+
+ if (GST_ELEMENT_IS_DECOUPLED (element))
+ continue;
+
+ linkcount = 0;
+ GST_LOG ("Examining %s\n", GST_ELEMENT_NAME (element));
+ for (m = GST_ELEMENT_PADS (element); m; m = m->next) {
+ GstPad *peer, *pad;
+ GstElement *parent;
+ GstOptSchedulerGroup *peer_group;
+
+ pad = (GstPad *) m->data;
+ if (!pad || !GST_IS_REAL_PAD (pad))
+ continue;
+
+ peer = GST_PAD_PEER (pad);
+ if (!peer || !GST_IS_REAL_PAD (peer))
+ continue;
+
+ parent = GST_PAD_PARENT (GST_PAD_PEER (pad));
+ get_group (parent, &peer_group);
+ if (peer_group && peer_group != group) {
+ GST_LOG ("pad %s is linked with %s\n",
+ GST_PAD_NAME (pad), GST_ELEMENT_NAME (parent));
+ linkcount++;
+ }
+ }
+
+ if (linkcount < 2) {
+ group_dec_links_for_element (group, element);
+ remove_from_group (group, element);
+ }
+ /* if linkcount == 2, it will be unlinked later on */
+ else if (linkcount > 2) {
+ g_warning
+ ("opt: Can't handle element %s with 3 or more links, aborting",
+ GST_ELEMENT_NAME (element));
+ return;
+ }
+ }
/* Peer element will be catched during next iteration */
return;
}
- if (!still_link1 && !still_link2)
- return;
-
/* now check which one of the elements we can remove from the group */
- if (still_link1) {
- element = element2;
- } else if (still_link2) {
- element = element1;
+ if (!still_link1) {
+ /* we only remove elements that are not the entry point of a loop based
+ * group and are not decoupled */
+ if (!(group->entry == element1 &&
+ group->type == GST_OPT_SCHEDULER_GROUP_LOOP) &&
+ !GST_ELEMENT_IS_DECOUPLED (element1)) {
+ GST_LOG ("el ement1 is separated from the group");
+
+ /* have to decrement links to other groups from other pads */
+ group_dec_links_for_element (group, element1);
+ remove_from_group (group, element1);
+ } else {
+ GST_LOG ("element1 is decoupled or entry in loop based group");
+ }
}
- /* we only remove elements that are not the entry point of a loop based
- * group and are not decoupled */
- if (!(group->entry == element &&
- group->type == GST_OPT_SCHEDULER_GROUP_LOOP) &&
- !GST_ELEMENT_IS_DECOUPLED (element)) {
- GST_LOG ("element is separated from the group");
-
- /* have to decrement links to other groups from other pads */
- group_dec_links_for_element (group, element);
- remove_from_group (group, element);
- } else {
- GST_LOG ("element is decoupled or entry in loop based group");
+ if (!still_link2) {
+ /* we only remove elements that are not the entry point of a loop based
+ * group and are not decoupled */
+ if (!(group->entry == element2 &&
+ group->type == GST_OPT_SCHEDULER_GROUP_LOOP) &&
+ !GST_ELEMENT_IS_DECOUPLED (element2)) {
+ GST_LOG ("element2 is separated from the group");
+
+ /* have to decrement links to other groups from other pads */
+ group_dec_links_for_element (group, element2);
+ remove_from_group (group, element2);
+ } else {
+ GST_LOG ("element2 is decoupled or entry in loop based group");
+ }
}
}
}
ref_chain (chain);
/* if the chain is not disabled, schedule it */
if (!GST_OPT_SCHEDULER_CHAIN_IS_DISABLED (chain)) {
- GST_LOG ("scheduling chain %p", chain);
- schedule_chain (chain);
- scheduled = TRUE;
+ GST_LOG ("scheduling chain %p", chain);
+ schedule_chain (chain);
+ scheduled = TRUE;
}
/* don't schedule any more chains when in error */
if (osched->state == GST_OPT_SCHEDULER_STATE_ERROR) {
- GST_ERROR_OBJECT (sched, "in error state");
- break;
+ GST_ERROR_OBJECT (sched, "in error state");
+ break;
} else if (osched->state == GST_OPT_SCHEDULER_STATE_INTERRUPTED) {
- GST_DEBUG_OBJECT (osched, "got interrupted, continue with next chain");
- osched->state = GST_OPT_SCHEDULER_STATE_RUNNING;
+ GST_DEBUG_OBJECT (osched, "got interrupted, continue with next chain");
+ osched->state = GST_OPT_SCHEDULER_STATE_RUNNING;
}
chains = g_slist_next (chains);
} else {
/* if chains were scheduled, return our current state */
if (scheduled)
- state = GST_SCHEDULER_STATE (sched);
+ state = GST_SCHEDULER_STATE (sched);
/* if no chains were scheduled, we say we are stopped */
else {
- state = GST_SCHEDULER_STATE_STOPPED;
- break;
+ state = GST_SCHEDULER_STATE_STOPPED;
+ break;
}
}
if (iterations > 0)
chains = g_slist_next (chains);
g_print ("+- chain %p: refcount %d, %d groups, %d enabled, flags %d\n",
- chain, chain->refcount, chain->num_groups, chain->num_enabled,
- chain->flags);
+ chain, chain->refcount, chain->num_groups, chain->num_enabled,
+ chain->flags);
while (groups) {
GstOptSchedulerGroup *group = (GstOptSchedulerGroup *) groups->data;
groups = g_slist_next (groups);
g_print
- (" +- group %p: refcount %d, %d elements, %d enabled, flags %d, entry %s, %s\n",
- group, group->refcount, group->num_elements, group->num_enabled,
- group->flags,
- (group->entry ? GST_ELEMENT_NAME (group->entry) : "(none)"),
- (group->type ==
- GST_OPT_SCHEDULER_GROUP_GET ? "get-based" : "loop-based"));
+ (" +- group %p: refcount %d, %d elements, %d enabled, flags %d, entry %s, %s\n",
+ group, group->refcount, group->num_elements, group->num_enabled,
+ group->flags,
+ (group->entry ? GST_ELEMENT_NAME (group->entry) : "(none)"),
+ (group->type ==
+ GST_OPT_SCHEDULER_GROUP_GET ? "get-based" : "loop-based"));
while (elements) {
- GstElement *element = (GstElement *) elements->data;
+ GstElement *element = (GstElement *) elements->data;
- elements = g_slist_next (elements);
+ elements = g_slist_next (elements);
- g_print (" +- element %s\n", GST_ELEMENT_NAME (element));
+ g_print (" +- element %s\n", GST_ELEMENT_NAME (element));
}
}
}
projects / platform / upstream / gstreamer.git / commitdiff