project: Properly handle NULL project asset ID

structured: Enhance error message when no clip duration set

structured-interface: Avoid setting invalid clip duration

track: Add a getter for restriction_caps

launch: Set user restriction caps even when loading projects

track: Enhance restriction capsfilter name

xml-formatter: Serialize DiscovererStreamInfo

We do not use it yet but it gives interesting information to
users

formatter: Plug lists of TimedValue leak

formatter: Better document metadata registration

And fix xges mimetype to match typefind mimetype

doc: Do not require the GStreamer cache generator

gesdemux: Compute sinkpad caps based on formatter mimetypes

Implement lazy loading asset cache so gesdemux use the formatters
assets while GES hasn't been initialized.

And set extensions to temporary files as some formatters require
the information (otio)

formatter: Add a method to retrieve the best formatter for a givent URI

Uses the file extension as hint falling back to the default formatter
if none is found

Make use of that function in when saving a project and not formatter
is specified.

Implement a formatter based on [OpenTimelineIO]

[OpenTimelineIO]: http://opentimeline.io/

formatter: Handle coma separated extensions in formatter metas

formatter: Duplicate const gchar* for metadatas

project: Expose the ges_project_add_formatter method

This method is useful when implementing a formatter outside
GES that end up converting to xges and uses the default formatter
to finally load the timeline.

Mark nested timeline assets as such

Adding a property to let the application know

Also make sure that the duration of nested timeline assets is reported
as CLOCK_TIME_NONE as those are extended as necessary.

And make a difference between asset duration and their max duration
As nested timelines can be extended 'infinitely' those max duration
is GST_CLOCK_TIME_NONE, but their duration is the real duration of
the timeline.

formatter: Enhance error reporting

And add a "loading-error" signal in GESProject so we can report
issue when loading async elements for the timeline.

xml-formatter: Fix loading sources

And fix the project file which couldn't be load now that we
properly check clips coherency

gesdemux: Add a testsrc to timelines if parent nleobject duration is too long

ges:validate: Properly error when editing container fails

nle: Handle nested timelines update when file changes

When we have nested timelines, we need to make sure the underlying
formatted file is reloaded when commiting the main composition to
take into account the new timeline.

In other to make the implementation as simple as possible we make
sure that whenever the toplevel composition is commited, the decodebin
holding the gesdemux is torn down so that a new demuxer is created
with the new content of the timeline.

To do that a we do a NleCompositionQueryNeedsTearDown query to which
gesdemux answers leading to a full nlecomposition stack
deactivation/activation cycle.

ges:validate: Add a way to execute actions on serialized timelines

This way we can modify nested timelines.

ges: Implement our own idle_add which uses the thread local maincontext

validate: Allow passing 'uri' to 'load-project'

The action type was thought to allow that but it wasn't implemented.

xml-formatter: Lower down borring debug to _LOG

project: Use asset ID as URI if possible

It was making no sense to consider it an empty timeline when the user
had passed the project URI when requesting the asset. Usually user
use `ges_project_new` with the URI but it is also valid to use
`ges_asset_request` with the uri as ID so let's handle that properly.

python: Add a better asset __repr__

ges: Implement subprojects

Subprojects simply consist of adding the GESProject
to the main project asset list. Then those are recursively
serialized in the main project in the <asset> not, when deserializing,
temporary files are created and those will be used in clips
as necessary

project: Fix our asset cache

It was not talking into account the fact that you can have
several assets with a same ID but different exactractable types.

asset: Handle trying to proxy an asset to itself

And avoid infinite recursion

gesdemux: Detect recursively loading the same project file

And error out when it is the case.

gesdemux: Create proper stream-ids

nle: Check seeking on deeply nested composition

track: Disable last gap by default

And let the GESPipeline logic handle that

nlecomposition: Drop all group-done but the last one

validate: Allow scenarios to set track types

tests: Add ges-sample-path-recurse with projects location

So that project files are found when using nested timelines

validate: Add a way to use validate configs with scenarios

Config files should have the-scenario-name.scenario.config to be picked automatically

validate: Use proper sink and give them good names

validate: Create folders as needed when serializing timelines

nlesource: Wait for the seek to actualy happen before removing the probe

Make sure that an event resulting from the seek happens before removing
the pad probe, dropping anything while it is not the case.

This guarantees that the seek happens before `nlesource` outputs
anything. This was not necessary as with decodebin or usual source
flushing seeks lead to synchronous flush_start/flush_stop and we could
safely assume that once the seek is sent, it was happenning.
With nested `nlecomposition` this assumption is simply not true as
in the composition seeks are basically cached and happen later in
the composition updating thread.

This fixes races where we ended up removing the blocking probe before
the seek actually started to be executed in the nlecomposition
nested inside an nlesource which leaded to data from *before* the seek
to be outputed which means we could display wrong frames,
and it was leading to interesting deadlocks.

nlecomposition: Minor debugging enhancements

uri-asset: Fix retrieving a relocated asset sync twice

Add a simple test for that.

timeline: Make adding/removing track MT safe

It was almost the case already so make it happen fully

nlecomposition: Ensure flushes after seek have the right seqnum

Seeks that lead to a stack change lead to deactivating the current
stack. At that point we explicitely flush downstream as a reaction to
the flushing seek. Until now those flushes had a random seqnum, this
fails if we are a nested compostion as the parent composition will end
up dropping that flush which in turns might lead to deadlocks. For
example, the flush goes through a `compositor` which wants to flush
downstream to stop its srcpad task, but that flush wouldn't have
"released" its srcpad thread if the composition srcpad drops it, meaning
it won't be able to stop the task ever.

nlecomposition: Shutdown children when setting state to NULL

Otherwise if we shutdown a composition whith an nested composition
(inside a source in the test) and leak it, we end up with the nested
composition task still running (in READY) which is bad.

Add a test for that which leaks the pipeline on purpose.

nle: Parent the GstTask to ourself

This allows accessing the nlecomposition in gdb when a task is
'dangling' making debugging easier.

tests: Implement nested timelines tests

nlecomposition: Properly set seqnum on flush events

timeline: Drop ASYNC_/START/DONE messages

When we have nested timelines, we do not want those messages to pop
to the parent timelines as we handle the sequence ourself in the
timeline.

demux: Create timeline from the streaming thread

First marshilling it to the main thread is dangerous as it is a blocking
operation and it should never happen there.

The asset cache is MT safe now so it is possible to load the timeline
from that thread directly

uri-asset: Implement multi threading support

Making sure to have 1 GstDiscoverer per thread.

Use that new feature in gesdemux by loading the timeline directly from
the streaming thread. Modifying the timeline is not supported allowed
anyway.

nle: Add a seeking test for nested composition

Use the new GstDiscoverer caching feature

timeline: Do not post upstream translated composition update messages

In the case of nested timeline in the toplevel timeline we ended up
with CompositionUpdate for seeks sent by our own composition to
granchildren composition. This was not causing essential issues
if all tracks where containing nested timelines but in cases
where one of the tracks only had a nested timelines, then we
were waiting forever for a `CompositionUpdateDone`.

CompositionUpdate translated into ASYNC_START/ASYNC_DONE should
be kept inside the GESTimeline and not travel up (possibly to some
parent GESTimeline).

structured-interface: Handle track-types in clip addition

The field was already expected in the launcher

Implement and use the GstStream API

timeline: Create stable stream IDs

docs: Generate ges plugin doc

plugins:ges: Factor out a GESBaseBin class

And use it in both gesdemux and gessrc

gesdemux: Emit no-more-pad as required

nlecomposition: Respect seek seqnum in output EOS/SEGMENT

Allowing a proper seek EOS handling with nested compositions

gesdemux: Properly combine flows

plugin: Make use of G_DECLARE

And remove useless .h files

xml-formatter: Plug some leaks

xml-formatter: Refactor the way we handle loading state

xml-formatter: Cleanup removing all now useless pending fields

xml-formatter: Load assets before their proxies

Paving the way to removing pending fields to make the code
simpler to follow.

assets: Recurse in the chain of proxies

When linking loaded proxies and trying to setup their targets

docs: Add gstges plugin

validate: Add action type to copy/paste clips

container: Handle children pasting failures

clip: Fix layer managament when copying a clip that was pasted

element: Properly handle the fact that pasting can return NULL

And fix paste annotation

meson: Bump minimal GLib version to 2.44

This means we can use some newer features and get rid of some
boilerplate code using the G_DECLARE_* macros.

As discussed on IRC, 2.44 is old enough by now to start depending on it.

doc: remove xml from comments

video-transition: When using non crossfade effect use 'over' operations

For smptealph element to work as expected the following compositing
element should mix with the default "over" operator, as described
in its documentation.

launcher: Remove duplicated track types option

docs: Minor documentation fixes

overrides: Make sure overrides are in hierarchy order

Otherwise method order resolution will not be correct

ges: Minor reorganisation of timeline-element.c

ges: Cleanup timeline-element.h indentation

project: Add a signal to notify when a new timeline is starting to load

tools: Initialize GStreamer before parsin options

We need it to be initialized to be able to parse our options

tools: Use a proper implementation of get_flags_from_string

tests: Simply include ges-internal.h instead of redefining the same macros

docs: Stop building the doc cache by default

And update the cache

Fixes https://gitlab.freedesktop.org/gstreamer/gst-docs/issues/36

timeline-element: Mark edit() as Since: 1.18

ges: Sprinkle around some Since: 1.16 markers

ges: Deprecate ges_play_sink_convert_frame

It has nothing to do in our namespace/API

More porting to markdown

title-clip: Enhance documentation

doc: Build documentation with hotdoc

docs: Minor fixes

doc: ges-track: Add ges_track_set_create_element_for_gap_func

launch: Fix caps restriction short names

python: Avoid warning about using deprecated methods

Fixes https://gitlab.freedesktop.org/gstreamer/gst-editing-services/issues/69

element: Make return value of setters mean something

Setters return values should return %FALSE **only** when the value
could not be set, not when unchanged or when the subclass handled
it itself!

This patches makes it so the return value is meaningul by allowing
subclasses return anything different than `TRUE` or `FALSE` (convention
is -1) to let the subclass now that it took care of everything and
no signal should be emited.

ges: Move `ges_container_edit` to GESTimelineElement

Now that the notion of layer has been moved down to #GESTimelineElement
(through the new #ges_timeline_element_get_layer_priority method), this
method make much more sense directly in the base class.