gl: mark library as API unstable

libs:uridownloader: Properly declare APIs as UNSTABLE

libs:video: Properly declare APIs as UNSTABLE

libs:base: Properly declare APIs as UNSTABLE

waylandsink: Fix compiler warning

gstwaylandsink.c:480:14: error: comparison of constant -1 with expression of
      type 'enum wl_shm_format' is always false
      [-Werror,-Wtautological-constant-out-of-range-compare]
  if (format == -1)
      ~~~~~~ ^  ~~

tsdemux: Update comments to the new reality and remove unused variables

libs:video: Add -I$(top_srcdir)/gst-libs to fix distcheck

libs:base: Fix includedir

aggregator: Fix requested pad name

libs: videoaggregato: Do not import videoconvert.h in gstvideoaggregatorpad.h

+ Add a Private structure to the GstVideoAggregatorPad
+ Add some padding

Final fix compilation

build: remove gst-libs/gst/video/ from CRUFT_DIRS

It was gone, but now it's back.

libs:video:Fix compilation

gl:glvideomixer: Add the Compositor in the element metadata class

So it is possible to pick one compositing element from the registry

compositor: Add a new compositor based on the new GstVideoAggregator base class

It is a replacement for videomixer with a similare API

Co-Authored by: Thibault Saunier <tsaunier@gnome.org>

https://bugzilla.gnome.org/show_bug.cgi?id=731919

gl: Port glmixer to the GstVideoAggregator baseclass

https://bugzilla.gnome.org/show_bug.cgi?id=731921

videoaggregator: Create a new GstVideoAggregator baseclass

This base class has been added to a newly created libgstbadvideo library

Co-Authored by: Thibault Saunier <tsaunier@gnome.org>

https://bugzilla.gnome.org/show_bug.cgi?id=731918

aggregator: Add new GstAggregator base class

This base class has been added to a newly created libgstbadbase library

Co-Authored by: Mathieu Duponchelle <mathieu.duponchelle@opencreed.com>

https://bugzilla.gnome.org/show_bug.cgi?id=731917

androidmedia: Clear exceptions also when we did not provide a GError

androidmedia: Also don't report warnings for queue/dequeue errors during flushing in error cases

... and fix a case where we released an invalid buffer index.

androidmedia: Don't consider input buffer queueing failures as an error during flushing

androidmedia: Clean up flushing code and don't consider output buffer releasing failures during flushing as an error

uridownloader: Include the debug string in the error messages we propagate from t source

hlsdemux: Include the debug string in the error messages we propagate from the
source

hlsdemux: Include a more descriptive error message

hlsdemux: Propagate error messages from the source element up in the hierarchy

Instead of inventing our own generic error strings which are mostly useless.

hlsdemux: Directly convert GErrors to error messages

This will make sure that we don't leak debug information into the actual
error message string and keep it behind the debug string.

gstsrtpenc: unref event when needed

Fixes https://bugzilla.gnome.org/show_bug.cgi?id=731768

srtpenc: improve property comments

Add a Note to the allow-repeat-tx property because it is potentially
insecure when used incorrectly.

Fixes https://bugzilla.gnome.org/show_bug.cgi?id=731714

gstsrtpenc: add allow-repeat-tx property

opengl: add element for transforming video geometry

* add graphene as soft dependency for linear algebra

pnm: link against libgstbase for GstAdapter

https://bugzilla.gnome.org/show_bug.cgi?id=730523

glframebuffer: don't segfault needlessly with GLES2

gst_gl_framebuffer_use_v2 was using a function that is not available
with GLES2

glfiltershader: port to GLES2

Provide a time variable

win32: update exports for changed h264 codec parser API

pnmdec: Added PBM Support

https://bugzilla.gnome.org/show_bug.cgi?id=730523

wayland: add unstable API guards to wayland library header

gst-libs: fix uninstalled build of new wayland lib

waylandsink/wldisplay: verify that all the required interfaces have been found on the compositor

This allows waylandsink to fail gracefully before going to READY
in case one of the required interfaces does not exist. Not all
interfaces are necessary for all modes of operation, but it is
better imho to fail before going to READY if at least one feature
is not supported, than to fail and/or crash at some later point.

In the future we may want to relax this restriction and allow certain
interfaces not to be present under certain circumstances, for example
if there is an alternative similar interface available (for instance,
xdg_shell instead of wl_shell), but for now let's require them all.
Weston supports them all, which is enough for us now. Other compositors
should really implement them if they don't already. I don't like the
idea of supporting many different compositors with different sets of
interfaces implemented. wl_subcompositor, wl_shm and wl_scaler are
really essential for having a nice video sink. Enough said.

waylandsink: remove the buffer from the surface when going PAUSED -> READY

This essentially hides the video and allows the application to
potentially draw a black background or whatever else it wants.
This allows to differentiate the "paused" and "stopped" modes
from the user's point of view.

Also reworded a comment there to make my thinking more clear,
since the "reason for keeping the display around" is not really
the exposed() calls, as there is no buffer shown in READY/NULL
anymore.

wayland: install .pc file

waylandsink/wlwindow: do not commit a resize when it happens due to a video info change

1) We know that gst_wayland_sink_render() will commit the surface
   in the same thread a little later, as gst_wl_window_set_video_info()
   is always called from there, so we can save the compositor from
   some extra calculations.
2) We should not commit a resize with the new video info while we are still
   showing the buffer of the previous video, with the old caps, as that
   would probably be a visible resize glitch.

waylandsink/wlwindow: take into account the video aspect ratio when determining the size of the surface

waylandsink: improve the way the video size is passed to wlwindow and also improve the code for window creation

waylandsink: rename pause/resume_rendering to begin/end_geometry_change and update their documentation

waylandsink: remove the manual synchronization from pause/resume_rendering and use subsurface sync/desync

Previously, in order to change the surface size we had to let the pipeline
redraw it, which at first also involved re-negotiating caps, etc, so a
synchronization with the pipeline was absolutely necessary.

At the moment, we are using wl_viewport, which separates the surface size
from the buffer size and it also allows us to commit a surface resize without
attaching a new buffer, so it is enough to just do:

gst_wayland_video_pause_rendering():
wl_subsurface_set_sync()
gst_video_overlay_set_render_rectangle():
wl_subsurface_set_position()
wl_viewport_set_destination()
wl_surface_damage()
wl_surface_commit()
... commit the parent surface ...
gst_wayland_video_resume_rendering():
wl_subsurface_set_desync()

This is enough to synchronize a surface resize and the pipeline can continue
drawing independently. Now of course, the names pause/resume_rendering are
bad. I will rename them in another commit.

waylandsink: protect access to properties with the OBJECT_LOCK

waylandsink: protect access to the display with a new display_lock

Access is protected only for setting/creating/destroying the display
handle. set_caps() for example is not protected because it cannot be
called before changing state to READY, at which point there will be
a display handle available and which cannot change by any thread at
that point

waylandsink: remove the OBJECT_LOCK from set_caps()

It's not really necessary, this method is protected from GstBaseSink with the PREROLL_LOCK

waylandsink: Replace the OBJECT_LOCK with a private render_lock to lock render operations

This is because:
* GST_ELEMENT_WARNING/ERROR do lock the OBJECT_LOCK and we deadlock instantly
* In future commits I want to make use of GstBaseSink functions that also
  lock the OBJECT_LOCK inside this code

waylandsink: move surface resizing logic to the GstWlWindow and make it be called from the main thread

waylandsink: cleanup GstWlWindow a bit after the overlaying semantics change

* own_surface is not needed anymore
* gst_wl_window_from_surface is not used externally anymore
* many initializations to 0 are not needed (GObject does them)

wayland: remove gst_wayland_video_set_surface_size()

Not needed anymore, since we use gst_video_overlay_set_render_rectangle()

waylandsink: create and maintain the subsurface inside the sink

This means that the given surface in set_window_handle can now be
the window's top-level surface on top of which waylandsink creates
its own subsurface for rendering the video.

This has many advantages:
* We can maintain aspect ratio by overlaying the subsurface in
  the center of the given area and fill the parent surface's area
  black in case we need to draw borders (instead of adding another
  subsurface inside the subsurface given from the application,
  so, less subsurfaces)
* We can more easily support toolkits without subsurfaces (see gtk)
* We can get properly use gst_video_overlay_set_render_rectangle
  as our api to set the video area size from the application and
  therefore remove gst_wayland_video_set_surface_size.

wayland: add public API for creating & using the display handle GstContext

waylandsink: get the external display handle using GstContext

This drops the ugly GstWaylandWindowHandle structure and is much
more elegant because we can now request the display separately
from the window handle. Therefore the window handle can be requested
in render(), i.e. when it is really needed and we can still open
the correct display for getting caps and creating the pool earlier.

This change also separates setting the wl_surface from setting its size.
Applications should do that by calling two functions in sequence:

  gst_video_overlay_set_window_handle (overlay, surface);
  gst_wayland_video_set_surface_size (overlay, w, h);

waylandsink: drop width/height arguments from gst_wl_window_new_from_surface()

waylandsink: add G_BEGIN/END_DECLS on all headers for consistency

waylandsink: fix assertion failure when stopping immediately after starting, without displaying anything

This was triggered in scenarios like
filesrc location=nonexistent_file ! decodebin ! waylandsink

waylandsink: Update wl_scaler to version 2

wayland/Makefile.am: link with gstvideo to avoid introspection errors

waylandsink/Makefile.am: Fix scaler-client-protocol.h generation

waylandsink: remove unused functions

waylandsink: Add myself to the authors list

waylandsink/wldisplay: bind to the latest available wl_compositor version

waylandsink: create/destroy the display when entering/leaving the READY state instead of PAUSED

This is the only way to get the negotiation working with the dynamic
detection of formats from the display, because the pipeline needs
to know the supported formats in the READY state and the supported
formats can only be known if we open the display.

Unfortunately,in wayland we cannot have a separate connection to
the display from the rest of the application, so we need to ask for a
window handle when going to READY in order to get the display from it.

And since it's too early to create a top level window from the state
change to READY, create it in render() when there is no other window.

This also changes set_window_handle() to not support window handle
changes in PAUSED/PLAYING (because it's complex to handle and useless
in practice) and make sure that there is always a valid display pointer
around in the READY state.

waylandsink: Support all video formats supported by the display

waylandsink: fix crash in case there is no pool because of a caps negotiation error

waylandsink: set an empty input region on the video surface

waylandsink/wlwindow: reuse code between the two constructors

waylandsink: increase debug messages

waylandsink: Use a boolean in combination with render_cond to comply with GCond's usage documentation

waylandsink: Implement expose() and handle resizing properly in non-PLAYING states

waylandsink: Use wl_scaler/wl_viewport to scale the surface in the compositor/hardware

waylandsink: Build bindings for the unstable wl_scaler spec

waylandsink: Set external surfaces and their child objects to use our own event queue

This fixes weird freezes because of frame_redraw_callback() not being
called from the main thread when it should with weston's toy toolkit.

It's also safer to know that frame_redraw_callback() will always be
called from our display thread... Otherwise it could be called after
the sink has been destroyed for example.

waylandsink: Wait for the frame_cb to redraw and drop frames meanwhile

We are not supposed to redraw until we receive a frame callback and this
is especially useful to avoid allocating too many buffers while the
window is not visible, because the compositor may not call wl_buffer.release
until the window becomes visible (ok, this is a wayland bug, but...).

waylandsink: Handle wl_buffer::release and don't reuse buffers that are not released

This is achieved by adding an extra reference on the buffers, which does
not allow them to return to the pool. When they are released, this reference
is dropped.

The rest complexity of this patch (hash table, mutex, flag, explicit release calls)
merely exists to allow a safe, guaranteed and deadlock-free destruction sequence.
See the added comment on gstwaylandsink.c for details.

waylandsink/waylandpool: remove useless munmap call

This data pointer is part of a bigger mmap'ed region,
it has not been returned from mmap itself.

waylandsink/waylandpool: call the start/stop methods of the parent class

start() makes sure that the minimum ammount of buffers requested is allocated.

stop() makes sure that buffers are actually destroyed and prevents
filling the file system when resizing the surface a lot, because the
wayland-shm-* files will stay on the file system as long as the wl_buffers
created out of them are alive.

waylandsink/waylandpool: unlink mmaped shm files so that they don't remain on the file system

waylandsink: implement the GstVideoOverlay & GstWaylandVideo interfaces

This is the initial implementation, without the GstVideoOverlay.expose()
method. It only implements using an external (sub)surface and resizing
it with GstWaylandVideo.

waylandsink: implement with stubs the GstWaylandVideo & GstVideoOverlay interfaces

wayland: Add new gst-wayland library containing a new GstWaylandVideo interface

This interface is needed to be able to embed waylandsink into
other wayland surfaces. Due to the special nature of wayland,
GstVideoOverlay is not enough for this job.

waylandsink: handle the list of supported formats properly

enum wl_shm_format is not a flags enum, as it may have been in the past,
so multiple formats cannot be stored in a bitfield. Use an array instead.

waylandsink/wlvideoformat: add mappings for many common formats

waylandsink: unref the buffer pool

waylandsink/waylandpool: ref the display instead of the sink to avoid cyclic references

The reference to the sink is not really needed anyway in waylandpool,
what matters basically is that the display is active as long as the
pool is active, so we really want to reference the display object
instead of the sink.

waylandsink: make the display property useful

Let the display property control the name of the display,
like in x(v)imagesink.

waylandsink: access sink->pool in a more atomic fashion

waylandsink: remove the useless wayland_lock

waylandsink: apply the same debug category to all the subobjects

waylandsink: cleanup header includes

waylandsink: split window-related code out to a new GstWlWindow class

GstWlWindow also has API ready to support subsurfaces.

waylandsink: remove callback and redraw_pending variables from the window structure

waylandsink/waylandpool: improve debug message

waylandsink/waylandpool: find the video format from the GstVideoInfo instead of accessing the sink

For the sake of isolation only. The format should be the same.

waylandsink/waylandpool: refactor code

* make use of GstBufferPool::start/stop functions to allocate/deallocate memory
* get rid of struct shm_pool and do all operations cleanly inside WaylandBufferPool
* store a GstVideoInfo during configuration instead of the width & height
  and use the stride from the video info instead of hardcoding its value

waylandsink: split video format related functions out to a separate file

waylandsink/waylandpool: move code around for better readability