splitmuxsink: Do split-at-running-time splitting based on the time of the start of the GOP

If the start of the GOP is >= the requested running time, put it into a
new fragment. That is, split-at-running-time would always ensure that a
split happens as early as possible after the given running time.

Previously it was comparing against the current incoming timestamp,
which does not tell us what we actually want to know as it has no direct
relation to the GOP start/end.

splitmuxsink: Fix off-by-one in running time comparison for split-at-running-time

If we get a keyframe exactly at the requested running time we would only
split on the next keyframe afterwards due to wrong usage of > vs. >=.

rtspsrc: Properly set segments seqnums after seeks

flvdemux: Don't write an empty string as a tag

To stop warnings like:

GStreamer-WARNING **: 19:47:48.186: Trying to set empty string on
taglist field 'encoder'. Please file a bug.

v4l2bufferpool: request the maximum number of buffers for USERPTR

This is to match what we now do for DMABuf importation.

v4l2bufferpool: request the maximum number of buffers for DMABUF

There are often only two buffers queued in the kernel so no new buffers are
requested.

With every qbuf, the kernel receives a new DMABUF for the specified index.
This most likely differs from the last DMABUF and the old cached entry is
released. This results in a lot of map/unmap overhead if the kernel driver
needs a mapping for the buffer.

With a larger queue, it's quite likely, that both old and new DMABUFs are
also mapped for another index. So the map/unmap is skipped, because the
mapping is reference counted.

The corresponding allocated buffers don't contain any actual memory, so
allocating them is quite cheep. So the log message is updated to clarify
this.

rtspsrc: Avoid stack overflow recursing waiting for response

Instead of recursing, simply implement a loop with gotos, the same
way it was done before 812175288769d647ed6388755aed386378d9210c

Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/issues/710

qtmux: Add property for enforcing the creation of chunks in single-stream files

This is disabled by default as it unnecessarily creates bigger headers
but it is something that is required by some applications and most
notably the Apple ProRes spec.

flvmux: Fix invalid padlist accesses.

Request pads can released at any time, so make sure to hold
the object lock when iterating the element sinkpads list where
that's safe, or to use other safe pad iteration patterns in
other places.

When choosing a best pad, return a reference to the pad to make sure it
stays alive for output in the aggregator srcpad task.

Should fix a spurious valgrind error in the CI flvmux tests and some
other potential problems if the request sink pads are released while
the element is running..

Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/issues/714

qtmux: Add option to create a timecode trak in non-mov flavors

Even if timecode trak is officially unsupported in non-mov flavors,
some software still supports it, e.g. Final Cut Pro X:

https://developer.apple.com/library/archive/technotes/tn2174/_index.html

The user might still expect to see the timecode information in the
non-mov file despite it being officially unsupported , because other
software e.g. QuickTime will create a timecode trak even in mp4 files.
Furthermore, software that supports timecode trak in non-mov flavors
will also display the file duration in "timecode units" instead of real
clock time, which is not necessarily the same for 29.97 fps and friends.
This might confuse users, who see a different duration for the same
framerate and amount of frames depending on whether the container is mp4
or mov.

Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/issues/512

rtpLXXdepay: Set the UNPOSITIONED flag on the audio-info when configuring an unpositioned layout

Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/issues/688

rtpjpeg: Use gst_memory_map() instead of gst_buffer_map()

gst_buffer_map () results in memcopying when a GstBuffer contains
more than one GstMemory.
This has quite an impact on performance on systems with limited amount
of resources. With this patch the whole GstBuffer will not be mapped at
once, instead each individual GstMemory will be iterated and mapped
separately.

buffermemory: keep track of buffer size and current offset

Added the possibility to get current offset and the total size of the
buffer.

rtpopuspay: make depay ! pay work

There is a use-case for a server to re-payload opus going through it.

Problem was that the payloader requires channels in the caps, but
this is not something the depayloader can parse out of the stream, meaning
caps-negotiation would fail.

Removing the requirement of channels in the template-caps fixes this.

tests: Split splitmux test case

Since we are adding more and more tests into splitmux,
we need to split it to avoid CI timeout.

splitmuxsink: Don't send too many force key unit event

splitmuxsink should requst keyframe depending on configured
threshold and previously requested time in order to avoid too many
keyframe request.

matroska: Check the return value of gst_segment_do_seek()

gst_segment_do_seek() can fail.

qtdemux: Send instant-rate-change event if requested in the SEEK event

Handle an instant rate change seek immediately by reflecting
it downstream as an instant-rate-change event, and do no
further seek handling.

matroska-demux: Send instant-rate-change event if requested in the SEEK event

Short-circuit instant rate change events by generating
a downstream instant-rate-change event and doing no further
seek processing.

matroska: Update for video-hdr struct change

See the change of -base https://gitlab.freedesktop.org/gstreamer/gst-plugins-base/-/merge_requests/594

rtpbin: make warning messages more meaningful

rtpsession: rename RTCP thread

RTP session starts a new thread for RTCP and names it
"rtpsession-rtcp-thread" which happens to be longer than the maximum 16B
allowed by pthread_setname_np and causes the naming to fail.
See docs for more details.

This commit simply shortens the thread's name so it can actually be set.

rtpjitterbuffer: create specific API for appending buffers, events etc

To avoid specifying a bunch of mystic variables.

rtpjitterbuffer: various test-improvements

Mainly generalize all the latest tests that have found various stalls
in the jitterbuffer, so that they only consist of a series of packets
with various seqnum/rtptime/rtx combinations, arriving at a specific time.

This means future tests can be more easily written to prove certain
behavior does not cause stalls.

Also fix the warning on windows:
warning C4244: 'initializing': conversion from 'double' to 'gint', possible loss of data

rtpjitterbuffer: fix waiting timer/queue code

Changing the types from boolean to guint due to the ++ operand used on
them, and only call JBUF_SIGNAL_QUEUE after settling down,
or else you end up signaling the waiting code in chain() for every buffer
pushed out.

qtmux: Error out instead of crashing if reserved-max-duration is 0 or no samples could be created in prefill mode

gdkpixbufoverlay: Use GST_VIDEO_OVERLAY_COMPOSITION_BLEND_FORMATS for the supported formats

We don't do any blending by ourselves since a while now.

Note that this is a regression in "supported" formats: previously
ARGB64 was supported, for example, but in practice it caused blending to
not take place at all.

splitmuxsrc: Fix some deadlock conditions and a crash

When switching the splitmuxsrc state back to NULL quickly, it
can encounter deadlocks shutting down the part readers that
are still starting up, or encounter a crash if the splitmuxsrc
cleaned up the parts before the async callback could run.

Taking the state lock to post async-start / async-done messages can
deadlock if the state change function is trying to shut down the
element, so use some finer grained locks for that.

splitmux: Make the unit test faster

The playback test is considerably faster if it runs with the
appsink set to sync=false

tests: splitmux: Add test for timecode based split

splitmuxsink: Split fragment only if queued time is larger than threshold

The queued time includes the duration of the last queued frame
(i.e., new keyframe) so the condition check should not be inclusive.
Note that the new fragment will be cut excluding the last frame
and therefore if the condition is inclusive way,
the fragment might have one frame shorter duration for all keyframe
stream such as jpeg or all-inter video streams.

splitmuxsink: Don't need to trace next timecode for split decision

Since the commit 94bb76b6b9c48981d3ad42a8c4370b9658db4229, splitmuxsink
will split fragments based on queued time and the threshold of that.
So don't need to store the next timecode for split decision.

v4l2: add alternate interlace mode

When using this mode each frame is split in two fields, each one being
transferred using its own buffer.
This is implemented with the V4L2_FIELD_ALTERNATE field format in v4l2.

This mode is enabled using a caps filter such as
"v4l2src ! video/x-raw\(format:Interlaced\)"

Here are the main changes related to this feature:

- use the INTERLACED caps feature with this mode.

- in this mode both fields of a given frame have the same sequence/offset
so adjust the algorithm checking for lost field/frame accordingly.

- double pool's min number of buffers as each frame requires 2 buffers.

Fix #504
Co-authored-by: Zeeshan Ali <zeenix@collabora.co.uk>

v4l2: display field when setting or trying format

Ease debugging interlacing pipelines.

v4l2: pass v4l2object to GST_V4L2_MIN_BUFFERS()

Will be used to double the number of buffers in alternate interlace
mode.

v4l2: use GST_VIDEO_INFO_FIELD_HEIGHT()

Use GST_VIDEO_INFO_FIELD_HEIGHT() instead of GST_VIDEO_INFO_HEIGHT()
when we actually want the field height rather than the frame height.
So far both are equals but that won't longer be the case when
implementing alternate interlace mode.

splitmuxsink: Mark some split decision related properties as MUTABLE_READY

The change of various criteria for split decision while muxing is on progress
wouldn't work well as expected.

splitmuxsink: Take account queued time and max-size-timecode for split decision

Not only the requested keyframe time, the queued size should be
a criterion for the split decision of timecode based mode
(same as max-size-time based split case).

qmlgloverlay: fix usage without an qmlglsink in the pipeline

Without a qmlglsink, we need to retrieve the window system display
ourselves rather than relying solely on qmlglsink to have priority on
the choice of display.

Fix usage of C99

It's 2020, way too early for that, let's stick to C89 for now.

v4l2bufferpool: Use unique name for v4l2bufferpool object

Assign unique sequence number to an object name for better debugging

qmlgloverlay: don't leak resources freed on a different GL thread

deleting a QOpenGLFrameBufferObject needs to occur on the same thread it
was created on in order to actually free the relevant resources
immediately.  Otherwise, they will be queued for deletion and not freed
until the associated QOpenGLContext is destroyed.

qt: reorganize include defines

rtptimerqueue: remove ->num from the timer

This concept was only used by the "multi"-lost timer, and since that
one is not around any longer, the "num" concept is superfluous.

rtpjitterbuffer: remove the concept of "already-lost"

This is a concept that only applies when a buffer arrives in the chain
function, and it has already been scheduled as part of a "multi"-lost
timer.

However, "multi"-lost timers are now a thing of the past, making this
whole concept superflous, and this buffer is now simply counted as "late",
having already been pushed out (albeit as a lost-event).

rtpjitterbuffer: immediately insert a lost-event on multiple lost packets

There is a problem with the code today, where a single timer will
be scheduled for a series of lost packets, and then if the first packet
in that series arrives, it will cause a rescheduling of that timer, going
from a "multi"-timer to a single-timer, causing a lot of the packets
in that timer to be unaccounted for, and creating a situation in where
the jitterbuffer will never again push out another packet.

This patch solves the problem by instead of scheduling those lost packets
as another timer, it instead asks to have that lost-event pushed straight
out.

This very much goes with the intent of the code here: These packets are
so desperately late that no cure exists, and we might as well get the
lost-event out of the way and get on with it.

This change has some interesting knock-on effect being presented in
later commits. It completely removes the concept of "already-lost", so
that is why that test has been disabled in this commit, to be
removed later.

rtpjitterbuffer: rework large-gap tests

Make sure to set the time the buffer is supposed to arrive at, so
as not to trigger an artificial situation.

rtpjitterbuffer: refactor lost_timeout code

Split it up in code related to the timer, (do_lost_timeout) and code
to insert a lost-item/event and update private jitterbuffer-variables.

test/check: split out rtptimerqueue-tests in a separate file

gstqmlgl: Link to opengl32.lib on MinGW

qtmux: Fix build warning

gstqtmux.c(644): warning C4133: '=':
  incompatible types - from 'gboolean (__cdecl *)(GstAggregator *,GstAggregatorPad *,GstEvent *)'
  to 'GstFlowReturn (__cdecl *)(GstAggregator *,GstAggregatorPad *,GstEvent *)'

splitmuxsink: Reset cleanly for reuse

Reset the splitmuxsink completely when changing states so that
it can be reused.

Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241

mpegaudioparse: Use a constant bit rate to convert between time and bytes if possible.

This should result in no worse accuracy than the base parse element, and may
result in better accuracy. In particular, the number of bytes processed at any
given point, as accumulated by baseparse, can be only accurate to
(1 / # of frames) bytes per second, and if we try to seek immediately after
pausing the pipeline to a large offset, this small inaccuracy can propagate to
something noticeable.

The use case that prompted this patch is a 45-minute MPEG-1 layer 3 file, which
has a constant bit rate but no seek tables. Trying to seek the pipeline
immediately after pauisng it, without the ACCURATE flag, to a location 41
minutes in, yields a location that is, even with <https://gitlab.freedesktop.org/gstreamer/gstreamer/merge_requests/374>,
still audibly incorrect. This patch yields a much closer position, no longer
audibly incorrect, and likely within a frame of the most correct position.

qtmux: fix renegotiation check

By the time sink_event is called, the pad's current caps have
already been updated. To address this, implement sink_event_pre_queue,
and check if the pad can be renegotiated there.

Fixes #707

splitmuxsink: Decouple keyframe request and the decision for fragmentation

Split the decision for keyframe request and fragmentation in order to
ensure periodic keyframe request.

qt: add a qml overlay filter element [part 2]

It takes a qml scene description and renders it using a possible input
stream.

Currently supported on GLX and WGL.

Follow up to (as that MR had an old version of the commit):
- https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/475
- 4778d7166a02caf793df4f845dc35b6933d87c81: qt: add a qml overlay filter element

qt: add a qml overlay filter element

It takes a qml scene description and renders it using a possible input
stream.

Currently supported on GLX and WGL.

qt: don't always activate/deactivate our GstGLContext

Techincally it is enough to activate at the beginning and then forget.

test/qml: add an dynamically adding qmlglsink element

The example shows how to add qmlglsink to an already running pipeline
with pre-existing OpenGL elements.

qmlglsink: propagate the context up the the application

Allows the application to be notified of the OpenGL context creation.

qtitem: fix leak of caps

wavpack: Use G_DECLARE_FINAL_TYPE

vpx: Use G_DECLARE_FINAL_TYPE

twolame: Use G_DECLARE_FINAL_TYPE

taglib: Use G_DECLARE_FINAL_TYPE

speex: Use G_DECLARE_FINAL_TYPE

soup: Use G_DECLARE_FINAL_TYPE

shout2: Use G_DECLARE_FINAL_TYPE

raw1394: Use G_DECLARE_FINAL_TYPE

qt: Use G_DECLARE_FINAL_TYPE

pulse: Use G_DECLARE_FINAL_TYPE

mpg123: Use G_DECLARE_FINAL_TYPE

libpng: Use G_DECLARE_FINAL_TYPE

libcaca: Use G_DECLARE_FINAL_TYPE

lame: Use G_DECLARE_FINAL_TYPE

jack: Use G_DECLARE_FINAL_TYPE

gtk: Use G_DECLARE_FINAL_TYPE

gdk_pixbuf: Use G_DECLARE_FINAL_TYPE

flax: Use G_DECLARE_FINAL_TYPE

dv: Use G_DECLARE_FINAL_TYPE

cairo: Use G_DECLARE_FINAL_TYPE

aalib: Use G_DECLARE_FINAL_TYPE

tests: rtp-payloading: add minimal vp8/vp9 rtp payloading/depayloading test

rtpvp8pay, rtpvp9pay: fix caps leak in set_caps()

videomixer: Don't leak peer caps

imagesequencesrc: Cleanup and add some features

* Implement the GstURIHandlerInterface
* Rework the locking
* Implement backward seeking handling
* Generate documentation

Add an imagesequencesrc element to stream sequence of images

See: https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/issues/121

v4l2src: decrease gst_v4l2src_create log verbosity

Lower the verbosity of the 'sync' log message emitted
each buffer from gst_v4l2src_create down to LOG(6)
from INFO(4). This brings the logging behavior of
v4l2src closer to the GStreamer guidelines, which
recommend the INFO level be reserved for rare or
one-off messages.

qtdemux: Add support for AC4

The caps received from qtdemux for AC-4 content are audio/x-gst-fourcc-ac_4

Based on patch by: Savinderjit Kaur

Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/issues/413

imagefreeze: handle reconfigure events on the srcpad

imagefreeze: properly ignore setting caps failures

Ignore the return value of gst_pad_set_caps() so that setcaps will set a
framerate that is usable.

Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/issues/705

imagefreeze: don't fail sending sticky events downstream

They will be repropagated anyway.

videocrop: Add support for Y41B and Y42B

videocrop: Add support for Y444

- Refactored the planar transform method to support all video formats
  that are stored planar, independent of the used subsampling
- Added support for Y444

videocrop: Use G_VALUE_INIT to initialize GValues

jpegdec: Configure JPEG chroma-siting for YUV formats

rtph26x: Use gst_memory_map() instead of gst_buffer_map() in avc mode

gst_buffer_map () results in memcopying when a GstBuffer contains
more than one GstMemory and when AVC (length-prefixed) alignment is used.
This has quite an impact on performance on systems with limited amount of
resources. With this patch the whole GstBuffer will not be mapped at once,
instead each individual GstMemory will be iterated and mapped separately.

qmlgl: ensure Qt defines GLsync to fix compile on some platforms

By explictly including QtGui/qopengl.h we force the code path that
defines GLsync in the Qt-specific way. Without that, some platforms
failed to compile the qmlgl plugin, since neither Qt nor gstreamer
defined GLsync then, leading to e.g.:

```
make[4]: Entering directory '/.../gst-plugins-good-1.16.1/ext/qt'
  CXX      libgstqmlgl_la-qtitem.lo
In file included from gstqtgl.h:32,
                 from qtitem.h:27,
                 from qtitem.cc:28:
/.../usr/include/gstreamer-1.0/
gst/gl/gstglfuncs.h:93:17: error: expected identifier before ‘*’ token
   ret (GSTGLAPI *name) args;
                 ^
/.../usr/include/gstreamer-1.0/
gst/gl/glprototypes/sync.h:27:1: note: in expansion of macro
‘GST_GL_EXT_FUNCTION’
 GST_GL_EXT_FUNCTION (GLsync, FenceSync,
 ^~~~~~~~~~~~~~~~~~~
```

rtptwcc: make RTPTWCCManager a GObject

rtpjitterbuffer: fix stalling when resetting timers

When calling gst_rtp_jitter_buffer_reset you pass in a seqnum.

This is considered the starting-point for a new stream.

However, the old behavior would unref this buffer, basically lying to
the thread that is pushing out buffers saying that it can expect
this buffer, when it would never arrive. The resulting effect being no
more buffer pushed out of the jitterbuffer, and it would buffer
incoming data indefinitely.

By instead inserting the buffer in the gap_packets queue, the _reset()
function will take responsibility for using that as the first buffer
of the new stream.

Fixes #703