Automatic update of common submodule

From 098c0d7 to 01a7a46
gnl: Properly set operations basetime

For operations (especially mixers) to be able to do proper
synchronization they need the segment from different sources to be in
the same running time context.

This commit makes sure that the basetime of the incoming segments of
operations will be the same, and equal to the duration of the
already "played" time of the operation at the position at which
the new portion of the composition starts.
gnlcomposition: Don't flush_start / flush_stop according to user's flags.

We do it ourselves when needed, doing so led the pipeline to lose state,
which was updating the base time.
fixes https://bugzilla.gnome.org/show_bug.cgi?id=701146
gnlcomposition: forward non time-resetting flush stops outside the composition,
except those consecutive to a seek event.

The 'reset-time' parameter has been added in 1.0, and we need it to be FALSE
outside the composition.

Related to https://bugzilla.gnome.org/show_bug.cgi?id=701146
composition: update operations base time even when we don't update the pipeline.
gnl: Rename media-start as inpoint

Rational described at https://bugzilla.gnome.org/show_bug.cgi?id=701287
gnl: Remove the notion of media-duration

Rational described at https://bugzilla.gnome.org/show_bug.cgi?id=701287
gnl: Remove trailling whitespaces and tabs in .c files
gnl: First implementation of the commit based API

Currently, the only safe way to modify a composition, or an object, is to pause
the pipeline first. We think that this limitation eliminates many use cases for
GNonLin. Few video editors let you create a draft of your video by applying
multi-cam technic. Also people could want to eventually consider doing live
video production, which obviously require being able to change the composition
in playing state (and increase compositon duration as we go).

This commit is a first step making GNL fully commit base. Objects, Operations and
Compositon keep a copy of modified values, and only apply those changes
when a commit is executed. This potentially allows making the changes
(or group of changes) fully 'atomic' without having to pause the pipeline.

Added API:
----------
  GnlObject::commit action signal

Removed API:
------------
  GnlComposition:update property

+ Fix the tests

https://bugzilla.gnome.org/show_bug.cgi?id=701287
gnlcomposition: Properly handle removing objects from the composition

We now commit our state (not recusively so we do not screw user) so we make sure the
pipeline is updated as needed, and we reset the gnlobject timing values so if it is readed
afterward the values are still correctly set.

We might want to avoid to release the object lock and commit in the exact same locking
section, it needs some more thinking, and we should find a proper solution for that.
gnl: Setting priority == MAXUINT32 does not mean "default object"

This was how expandables worked prior to the expandable property.

Using MAXUINT32 has some limitation and which are fully covered by the
expandable property. Drop this support, as we will plan on implementing
an automatic way of filling gaps.
gnlcomposition: Make the pipeline update protected from any child changes

When calling the gnl_object_commit method, we need to make sure that no
object can be changed and, it should be true until the pipeline has
fully been udpated.

We now need the update_pipeline function to be called with the
COMP_OBJECTS_LOCK taken, and we do not unlock that lock during the whole
pipeline updating process.
gnlcomposition: Remove uneeded indents
gnlcomposition: Remove support for gaps

The way we were handling gap was weird and not natural at all for
users, remove it for now.

In the long term, we should have a proper way of filling gaps in the
API and for now only emit an STREAM_ERROR message on the bus when a
gap is detected.

The user is now responsible for filling gaps in the composition

https://bugzilla.gnome.org/show_bug.cgi?id=701287
gnl: Move the commit signal from gnlobject to gnlcomposition

Commiting should be done trough the parent composition and the user should
not be able to commit to a particular gnlobject as it would result in some
possible races.

In the composition we do not need anymore to connect to children
positioning properties notify signals as we actually control those
ourself.

We make sure that it is possible to use gnlobject subclasses outside a
composition commiting the object state when going from NULL to READY
state.

Re update the tests to take into account the new behaviour/API
composition: More reliably compute outgoing segment base time

Currently we are simply accumulating segments one after the other
to set the base time of segment going outside the composition. This
will create issues in the case where an element is sending a new
segment only to update the one previouly set.

In this patch we make use of our knowledge of the segment that is
being played (as set by the user when seeking) and the start time
of the stack currently used in the pipeline.

Basically the base time is the difference between the segment
configured by the user seek (or default one) and the starting time
of the currently used stack (stop times in case of reverse playback)
gnlcomposition: Remove the FLUSH_LOCK, us atomic operations instead

It is easier to read and is a minor performance enhancement.
gnlcomposition: suffix callbacks with _cb