asset: Avoid dereferencing NULL pointer

CID 1461286

basebin: Do not set stream_group if upstream didn't provide it

CID: 1461278

framepositionner: Fix wrong old size check condition

CID: 1461277

validate: Avoid dereferencing NULL pointer

CID: 1461266

timeline: Ensure setting framerate in timeline_get_framerate

CID: 1461250, 1461288

tests: Check that linking pads works

CID: 1456061

structured-interface: Properly check that setting keyframe works

Fixes CID: 1455490

gesdemux: Check result of g_stat

CID: 1455489, 1455521

test: tempochange: Plug leak

CID: 1455448

ges: Cast to signed int to compare agasint 0

The check made sense but we were not casting to be able to check
signess of subtraction result.

CID: 1444923

timeline: Do not compare unsigned with 0

Layer priorities are always positive the check was making no
sense in any case.

Fixes CID: 1444922, 1461284

ges: Always check return value of `ges_container_add`

Making coverity happy

CIDs: 1461460, 1461461, 1461462, 1461463, 1461464, 1461465, 1461466, 1461468,

ges: Fix sending EOS on testclip when using timeoverlay

Basically when using timeoverlay we where waiting for input-selector
to receive EOS on its active on the output-selector streaming thread
but... EOS was being sent from that same thread waiting for input-selector
to unblock to send EOS on its other pad.

In our specific use case we want EOS to be sent only on the active pad.

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

ges: Update documentation

And start generating TrackElement children property with a stupid
simple script

ges: Add the foreground color child property

ges: Fix reloading UriClipAsset synchronously

And add tests for that

ges: Rework the way we ensure core elements are not wrongly moved between clips

Instead of focusing on the instances of the clips and their children,
we relax the check to allow moving track element clip between clips
that share a common asset. This makes it as correct conceptually but
more flexible, and the code becomes simpler.

group: tidied timeline membership in copy-paste

Previously, the GESContainer ->paste method and GESGroup ->paste methods
were unnecessarily setting the timeline of groups, even though this is
handled by the GESGroup ->child_added method. This could result in the
group being added multiple times.

timeline-tree: fix overlap check

Previously, the code was not able to detect that an element overlaps on
its end, nor could it detect that an element overlaps two elements that
already overlap.

clip: tidy grouping

Make the grouping of clips cleaner by checking that the clips share the
same asset.

clip: secure adding clip to layer

Add more checks when adding a clip to a layer, or moving a clip to a new
layer. Also, mark the "layer" property as explicit-notify.

uri-clip: match children by track

When the asset of a uri clip is reset, its core children are removed and
replaced by the new core children. When replacing, the `set_asset`
method attempts to copy children properties from the previous children
to the new children. However, the children were matched by track-type
only. This would not function as intended when a URI contains multiple
audio or video streams. Instead, we now match children by the tracks
themselves. This should work better, provided the user's
select-tracks-for-object is well behaved.

Also, fix a memory problem in `set_mute` for when a child is not in a
track.

timeline-element: only copy read-write properties

Only copy the properties that can be both read and written, and are not
construct only. Similarly for child properties when a track-element is
deep copied.

timeline: return sunk element on pasting

Technically, an element can still be floating on the return from
`->paste` (e.g. a clip not in a layer). Since the return of the `_paste`
methods are (return full) a non-floating object is probably expected in
all cases.

auto-transition: select track directly

By-pass the select-tracks-for-object signal for auto-transitions since
their track element must land in the same track as the elements it is
the auto-transition for.

timeline: re-handle clip children track selection

The way a clip's track elements are added to tracks was re-handled. This
doesn't affect the normal usage of a simple audio-video timeline, where
the tracks are added before any clips, but usage for multi-track
timelines has improved. The main changes are:

+ We can now handle a track being selected for more than one track,
  including a full copy of their children properties and bindings.
  (Previously broken.)
+ When a clip is split, we copy the new elements directly into the same
  track, avoiding select-tracks-for-object.
+ When a clip is grouped or ungrouped, we avoid moving the elements to
  or from tracks.
+ Added API to allow users to copy the core elements of a clip directly
  into a track, complementing select-tracks-for-object.
+ Enforced the rule that a clip can only contain one core child in a
  track, and all the non-core children must be added to tracks that
  already contains a core child. This extends the previous condition
  that two sources from the same clip should not be added to the same
  track.
+ Made ges_track_add_element check that the newly added track element
  does not break the configuration rules of the timeline.
+ When adding a track to a timeline, we only use
  select-tracks-for-object to check whether track elements should be
  added to the new track, not existing ones.
+ When removing a track from a timeline, we empty it of all the track
  elements that are controlled by a clip. Thus, we ensure that a clip
  only contains elements that are in the tracks of the same timeline, or
  no track. Similarly, when removing a clip from a timeline.
+ We can now avoid unsupported timeline configurations when a layer is
  added to a timeline, and already contains clips.
+ We can now avoid unsupported timeline configurations when a track is
  added to a timeline, and the timeline already contains clips.

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

timeline: stop connecting to track-element-added

This was used to connect to the track element's notify::start signal in
order to update the duration of the timeline (it is not clear why the
notify::duration signal was not also connected to for the same reason).
However, this is already covered by the timeline_tree_move method, which
is always called to update the start of a track element, even if it is not
part of a clip (and similarly for timeline_tree_trim, which is called
when the duration is set).

clip: allow arbitrary max-duration when no core children

Before the max-duration could be set arbitrarily when the clip was empty,
to indicate what the max-duration would be once the core children were
created. Now, we can also do this whilst the clip only contains non-core
children.

track-element: change owner to creator

Rename the private "owners" to "creators" to avoid confusing this with
the owner of the track element's memory.

Also made the ungroup method for GESClip symmetric by making all the
children of the resulting clips share their creators, which allows them
to be added to any of the other ungrouped clips. Once the clips are
grouped back together, the tracks loose these extra creators.

container: change ownership when adding

Make sure we sink the child on adding, and keep it alive until the end
in case the method fails.

Also, since the child mappings hold a ref to the child, they should give
them up in their free method. This way, the ref will be given up on
disposing, even if ges_container_remove fails.

Also, reverse setting of the start of the container if adding fails.

ges: Fix build with GCC 10

gcc-10 defaults to -fno-common, which exposes a symbol conflict, so
use `static` correctly. Also we don't use `parent_extractable_iface`
in `ges-uri-clip.c`.
See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85678

ges: Fix trimming clip inside deeply nested groups

This broke in 6b7c658b6a551a5b9170987ba44592d1d819e1ae

uri-clip: Remove dead code

GES_TESTING_ASSETS_DIRECTORY is prehistoric and since then
new mechanism for asset relocation have been added, it makes
no sense to keep that unused code path

uri-clip: Remove ->create_track_element implementation

It is dead code

ges: Deprecate GESImageSource and GESMultiFileSource

Refactoring GESVideoSource so that #GESUriVideoSource can handle
still image in a simple way

MultiFileSource has been replaced with the new `imagesequencesrc`
element, this was totally broken anyway as `multifilesrc` can not seek
properly.

track-element: Create nleobject on GESExtractable::set_asset

This means that we have all the information about the asset
when constructing the underlying GstElements.

This also allows to cleanup some code all around

timeline:element: Refactor the way we 'copy'

Simplifying the implementation and making sure assets are set asap

ges: Use assets to instantiate track elements/group

And deprecate all GESTrackElement constructors, but the GESEffect one.
Those should **never** be created by users and should become internal
in the future.

Stop having docstring for the constructors that were internal.

tests: Cleanup test files handling

formatter: Serialize source properties

This way we ensure that the TrackElement 'active' property is
properly serialized

ges: Add a way to set layer activeness by track

a.k.a muting layers.

Adding unit tests and making sure serialization works properly

element: Add API safe guard against invalid position in edit()

validate: Refactor actions implementation

Making them simpler to read and avoiding leaks

structured-interface: Fix adding clip to layer error reporting

ges: Add a SourceClipAsset class

Cleaning up the way we use the default framerate for natural
frame rate.

launch: Add a way to disable validate at runtime

Also avoid to add useless bin in our sinks

ges: Plug some leaks

validate: Add support to seek in frames

ges: support test clips assets natural size/framerate

This way we can test this kind of behaviour without requiring
real sources.

Also add simple tests.

ges: Add APIs to have a sens of frame numbers

APIs:
   - ges_timeline_get_frame_time
   - ges_timeline_get_frame_at
   - ges_clip_asset_get_frame_time
   - ges_clip_get_timeline_time_from_source_frame

Extracting ges_util_structure_get_clocktime to internal utilities adding
support for specifying timing values in frames with the special
f<frame-number> synthax.

utils: fix argument sanitization

_sanitize_argument is supposed to wrap arguments in '"' quote marks such
that they can be parsed and copied into a GstStructure string. This
purpose is now supported more directly, which fixes some bugs, e.g.:
  arguments                before                  fix
+title my=title          +title my="title"       +title "my=title"
+title abc n=my=name     +title abc n="my="name" +title abc n="my=name"
+title my"title          +title "my"title"       +title "my\"title"
+title my\title          +title "my\title"       +title "my\\title"

launch: Fix memory management issue with the rendering format

validate: Rename edit-container to edit

Keeping the old version for backward compat

ges: Add a timeoverlay to video test sources

This is often very useful to have a timeoverlay inside test sources.
We do not want to use it as an effect as segments are not the sames
in GES when it comes to nleoperations.

element: Handle using own property as child property

Avoiding ref cycles

ges: Ensure GESClips assets are always ClipAssets

ges: Add API to retrieve the natural framerate of an element

ges: Some memory management fixes setting track mixing

Also fix 'mixing' property notifies

ges: Cleanup GESEdge and GESEditMode GEnum values

By duplicating the registered values, so that bindings have
better values to use

launch: Make command line provided sinks override scenario defined ones

framepositioner: Avoid dereferencing NULL pointer

validate: Initialize GValue before calling g_object_get_value

This is required with GLib < 2.60

ges: Use #pragma once everywhere

ges: Cleanup the way we declare object types

We create our own _DECLARE_ macro because we have instance structures

ges: Stop using hash_table_steal_extended

This appeard in GLib 2.58

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

clip: Allow setting max-duration clips without TrackElements

Otherwise this breaks quite a few assumption in user code, several
pitivi tests broke because of that.

ges: Make it so core elements can be re added to their 'owners'

The user might want to add/remove/add core children to clips and be able
to regroup ungrouped clip. This is needed for undo/redo in Pitivi for
example

container: Let subclass know adding child was interrupted

When the `child-added` signal emission was called, the
`GESContainer->child_added` vmethod was called (the signal is
`G_SIGNAL_RUN_FIRST`) so we need to call `GESContainer->child_removed`
ourself so subclasses know they do not control the child anymore.

timeline-element: make start and duration EXPLICIT_NOTIFY

The properties will only have their signal emitted when they change in
value, even when g_object_set, etc, methods are used.

The _set_start method already did this, but start was missing the
EXPLICIT_NOTIFY flag. There should be no need to check that the property
has changed in ->set_start or ->set_duration

timeline-element: make max-duration cap in-point

Do not allow the in-point to exceed the max-duration of any timeline
element.

clip: only allow children with the same timeline

Refuse the addition of children whose timeline is neither NULL nor the
clip's timeline.

clip: re-handle child in-point and max-duration

The in-point of a clip is kept in sync with its core children, unless they
have no has-internal-source.

The max-duration is defined as the minimum max-duration amongst the
clip's core children. If it is set to a new value, this sets the
max-duration of its core children to the same value if they have
has-internal-source set as TRUE.

Non-core children (such as effects on a source clip) do not influence
these values.

As part of this, we no longer track in-point in GESContainer. Unlike start
and duration, the in-point of a timeline element does not refer to its
extent in the timeline. As such, it has little meaning for most
collections of timeline-elements, in particular GESGroups. As such, there
is no generic way to relate the in-point of a container to its children.

timeline-element: make in-point and max-duration EXPLICIT_NOTIFY

As such, they only emit a signal if their value changes, either through
their _set_inpoint or _set_max_duration methods, or through
g_object_set, etc.

Also, we now require the ->set_max_duration method to be implemented.
This was added to GESGroup, which will only allow the max-duration to be
set to GST_CLOCK_TIME_NONE.

track-element: add has-internal-source property

Unless this property is set to TRUE, the in-point must be 0 and the
max-duration must be GST_CLOCK_TIME_NONE.

Also added EXPLICIT_NOTIFY flags to the active and track-type
properties such that their notifies are emitted only if the property
changes, even when the g_object_set, etc, methods are used.

Also added a missing notify signal to the set_active method.

clip: copy and paste control bindings

Previously the control bindings were not properly copied into the pasted
clip. Also changed the order so that elements are added to the clip
before the clip is added to the timeline.

timeline-element: add signals for child properties

Add the child-property-added and child-property-removed signals to
GESTimelineElement.

GESContainer is able to use this to keep their child properties in sync
with their children: if they are added or removed from the child, they
are also added or removed from the container.

container: freeze notifies during add and remove

Hold the notify signals for the container and the children until after
the child has been fully added or removed.

After the previous commit, this was used to ensure that the
notify::priority signal was sent for children of a clip *after* the
child-removed signal. This stopped being the case when the code in
->child_removed was moved to ->remove_child (the latter is called before
the child-removed signal is emitted, whilst the former is called
afterwards). Rather than undo this move of code, which was necessary to
ensure that ->add_child was always reversed, the notify::priority signal
is now simply delayed until after removing the child has completed. This
was done for all notify signals, as well as in the add method, to ensure
consistency.

This allows the test_clips.py test_signal_order_when_removing_effect to
pass.

Also make subclasses take a copy of the list of the children before
setting the start and duration, since this can potentially re-order the
children (if they have the SET_SIMPLE flag set).

clip: make remove_child a reverse of add_child

Previously, we relied on ->child_removed to reverse the priority changes
that occured in ->add_child. However, ->child_removed is not always
called (the signal child-removed is not always emitted) when a
->add_child needs to be removed. However, ->remove_child is always
called to reverse ->add_child, so the code was moved here. Otherwise, we
risk that the priorities of the clip will contain gaps, which will cause
problems when another child is added to the clip.

clip: tidy handling of child priorities

Handle the child priorities in a way that keeps the container children
list sorted by priority at all times. Also, no longer rely on the
control_mode of the container, since we have less control over its value,
compared to private variables.

Also fixed the changing of priorities in set_top_effect_index:
previously *all* children whose priority was above or below the new
priority were shifted, when we should have been only shifting priorities
for the children whose priority lied *between* the old and the new
priority of the effect. E.g.
  effect:   A   B   C   D   E   F
  index:    0   1   2   3   4   5
After moving effect E to index 1, previously, we would get
  effect:   A   B   C   D   E   F
  index:    0   2   3   4   1   6
(this would have also shifted the priority for the core children as
well!). Whereas now, we have the correct:
  effect:   A   B   C   D   E   F
  index:    0   2   3   4   1   5

clip: only allow core elements as children

Only allow elements that were created by ges_clip_create_track_elements
(or copied from such an element) to be added to a clip. This prevents
users from adding arbitrary elements to a clip.

As an exception, a user can add GESBaseEffects to clips whose class
supports it, i.e. to a GESSourceClip and a GESBaseEffectClip.

This change also introduces a distinction between the core elements of a
clip (created by ges_clip_create_track_elements) and non-core elements
(currently, only GESBaseEffects, for some classes). In particular,
GESBaseEffectClip will now distinguish between its core elements and
effects added by the user. This means that the core elements will always
have the lowest priority, and will not be listed as top effects. This is
desirable because it brings the behaviour of GESBaseEffectClip in line
with other clip types.

nle: Delay marking object as not in composition

Instead of doing it at the time of resetting `object->in_composition`
when user calls `gst_bin_remove` do it after we actually removed
it from the object thread, and do it in the `nle_object_reset`
method where it belongs

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

auto-transition: fix setting of SET_SIMPLE flag

Previously, the SET_SIMPLE flag was non unset for auto-transitions after
it had been set.

Fix build with Python 3.8 by also checking for python-3.X-embed.pc

Since Python 3.8 the normal checks don't include the Python libraries
anymore and linking of the Python formatters would fail.

See also https://github.com/mesonbuild/meson/issues/5629
and https://gitlab.freedesktop.org/gstreamer/gst-python/issues/28

validate: Handle checking/setting subprojects ges properties

project: Do not warn when resetting URI to the same one

ges: Make setting start/duration move or trim generic

We were implementing the logic for moving/trimming elements specific
to SourceClip but this was not correct ass the new timeline tree allows
us to handle that for all element types in a generic and nice way.

This make us need to have groups trimming properly implemented in the
timeline tree, leading to some fixes in the group tests.

This adds tests for the various cases known to not be handled properly
by the previous code.

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

group: Update priority when a child is removed

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

clip: Don't split clips at illegal position

Make sure that when we split a clip, the resulting timeline would
not be in an illegal state.

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

pipeline: don't link tracks unnecessarily

Unless the pipeline is in certain modes, we do not want to try and link
every track. The previous debug message implied this, but the method did
not actually end early.
Also, we always end early if we receive a track that is neither video
nor audio.

asset: fix handling of proxies

Previous usage of the property proxy-target seemed to alternate between
the two definitions:
+ The asset we are the default proxy of
+ The asset we are in the proxy list of
Now, the latter definition is used, which seems more useful to a user
since knowing the latter can easily allow you to find out the former.

The previous behaviour of ges_asset_set_proxy (asset, NULL) was not very
clear. It is now defined so that it clears all the proxies for 'asset'.
This means that after this call, the GESAsset:proxy property will indeed
be NULL.

Also fixed:
+ We can call ges_asset_set_proxy (asset, proxy) when 'proxy' is already
  in the proxy list of 'asset'.
+ Handling of removing the default proxy in ges_asset_unproxy. This was
  sending out the wrong notifies.
+ Prohibiting circular proxying. Before we could only prevent one case,
  we should now be able to prevent all cases. This will prevent a hang
  in ges_asset_request.

test: remove asset test that needs internal method

The test_proxy_asset test needs the internal method
ges_asset_finish_proxy. The test also uses the associated internal methods
ges_asset_try_proxy and ges_asset_cache_lookup. However, these are
marked with GES_API in ges-internal.h, which allows us access to them
here.
The new method is not marked as GES_API because it would not allow us to
remove the method in the future without removing it from the symbols list.
We do not want to add to the problem.

The test was simply commented out since we may wish to support tests
that access internal methods in the future using meson.

asset: fix ownership in ges_asset_request

Fix the ownership in ges_asset_request. This should be transfer-full,
but for proxies it would fail to add a reference. Also,
ges_asset_cache_put was leaking memory if the asset already existed.

asset: move set_proxy (NULL, proxy) behaviour to new method

We should not be accepting ges_asset_set_proxy (NULL, proxy) as part of
the API! This behaviour was used internally in combination with
ges_asset_try_proxy, which is called on a still loading asset, so it was
moved to ges_asset_finish_proxy.

asset: deprecate ->proxied method

This method was no longer called, so it has been deprecated.

asset: make proxy-target read only

We should not be able to set this property.

timeline: fix layer priority argument in trim

Previously, we tested that the given priority was `>0`, when it seems
that `>=0` was intended. A priority of `-1` means leave the priority
unchanged, whilst a priority of 0, or more, means move to this layer
priority.

timeline-element: use default ->list_children_properties

Stop overwriting the ->list_children_properties virtual method in
subclasses because the timeline element class handles everything itself
anyway.
Note that containers already automatically add the children properties of
their child elements in ges_container_add.

group: fix memory leak in child layer callback

We were leaking the sigids->layer argument because gst_clip_get_layer
returns a new reference.

container: fix child duration callback

Previously, we were setting the inpoint_offset using the start offset in
the duration callback!

Also added a notify for when the duration is changed in the child start
callback.

group: fix max layer priority

The maximum priority is `height - prio - 1`. Previously missing the -1.

Related to, but does not completely fix,
https://gitlab.freedesktop.org/gstreamer/gst-editing-services/issues/91