msdk: Fix increasing memory usage in dynamic pipelines

Our context is non-persistent, and we propagate it throughout the
pipeline. This means that if we try to reuse any gstmsdk element by
removing it from the pipeline and then re-adding it, we'll clone the
mfxSession and create a new gstmsdk context as a child of the old one
inside `gst_msdk_context_new_with_parent()`.

Normally this only allocates a few KB inside the driver, but on
Windows it seems to allocate tens of MBs which leads to linearly
increasing memory usage for each PLAYING->NULL->PLAYING state cycle
for the process. The contexts will only be freed when the pipeline
itself goes to `NULL`, which would defeat the purpose of dynamic
pipelines.

Essentially, we need to optimize the case in which the element is
removed from the pipeline and re-added and the same context is re-set
on it. To detect that case, we set the context on `old_context`, and
compare it to the new one when preparing the context. If they're the
same, we don't need to do anything.

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

msdk: Reorganize context preparation code

Split it out into a separate function with early exits to make the
flow clearer, and document what the function is doing clearly.
No functional changes.

msdk: Fix warning about unused variable on Windows

msdk: Use gst_clear_object()

`gst_object_replace()` is not supposed to be used for unreffing and
NULLing objects.

nvcodec: Print debug info when initializing nvenc

We weren't printing the return value.

nvcodec: Fix crash on 32-bit Windows

We weren't using the correct calling convention when calling CUDA and
CUVID APIs. `CUDAAPI` is `__stdcall` on Windows. This was working fine
on x64 because `__stdcall` is ignored and there's no special calling
convention. However, on x86, we need to use `__stdcall`.

nvcodec: cuda.h only needs glib.h, not gst.h

Just a nitpick. Also, force the compiler to use our stub header
instead of searching for it in the include paths.

webrtcbin: Start datachannel SCTP elements only after the DTLS connection is established

Otherwise we would start sending data to the DTLS connection before, and
the DTLS elements consider this an error.

Also RFC 8261 mentions:
  o A DTLS connection MUST be established before an SCTP association can
    be set up.

webrtcbin: Add handling of unspecified peer-connection-state situation

For us it can happen that the DTLS transports are still in the process
of connecting while the ICE transport is already completed. This
situation is not specified in the spec but conceptually that means it is
still in the process of connecting.

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

webrtcbin: Return the old state if we ended up being in an unspecified situation

Previously we would've returned NEW, which is usually more wrong.

webrtcbin: Fix transitions for the peer connection state

They're now mapping exactly to what
  https://www.w3.org/TR/webrtc/#rtcpeerconnectionstate-enum
actually specifies.

Related to https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/758

webrtcbin: Fix transitions for the connection state

They're now mapping exactly to what
  https://www.w3.org/TR/webrtc/#dom-rtciceconnectionstate
actually specifies.

Related to https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/758

webrtc/dtlstransport: Proxy DTLS connection state from the DTLS elements to the transport

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

dtls: Keep track of the connection state and signal it through all the layers

This allows the application to keep track of the underlying DTLS
connection state and act accordingly.

dtls: Handle errors/close_notify at all steps and propagate through the layers properly

Previously we simply logged errors but never reported them to elements
or even to the user. Fatal errors are now properly reported.

Additionally proper connection closing is implemented based on EOS:
- dtlsenc: EOS will cause close_notify to be sent to the peer and only
           if the peer also sent back close_notify we will forward the
           EOS event.
- dtlsdec: EOS will be forwarded normally, this only means that the
           unterlying transport was closed. On receiving a DTLS packet
           containing close_notify, return EOS and send EOS downstream.

dtls: Propagate write errors backwards through dtlsenc/dtlsconnection

dtls: Use a plain function pointer instead of a GClosure for the send callback

There's not point in using GClosure and going through all the
GValue/libffi infrastructure for each DTLS packet.

webrtcbin: Don't consider transceivers without mid as inactive during ICE gathering state updates

We don't have any mid before parsing the SDP, which happens after we
handled the SDP answer and that usually happens long after ICE candidate
gathering is finished.

Without this all transceivers are considered inactive and as such ICE
gathering is for active transceiver was considered complete from the
very beginning.

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

webrtcbin: Don't consider RTP receivers stopped

We don't support stopping RTP receivers currently so let's not consider
them all stopped all the time. This fixes some of the ICE/DTLS state
change handling and specifically fixes the ICE gathering state.

Previously the ICE gathering state was immediately going from NEW to
COMPLETE because it considered all transceivers stopped and as such all
activate transceivers were finished gathering ICE candidates.

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

webrtcbin: Improve logging related to ICE/DTLS state changes

yadif: Re-renable MMX asm on x86_64 with meson

The meson build doesn't automatically set HAVE_CPU_* defines
like autotools did, so the yadif plugin was being built without
the MMX assembler support

yadif: Only build inline Asm with gcc/clang

msdkdec: align frame list using decoded timestamp

Before this change decoder used the oldest frame in the list to pair it
with the decoded surface. This only works when there's a perfect stream
like HEADERS,SYNCPOINT,DELTA...

When playing RTSP streams we can get imperfect streams like HEADERS,
DELTA,SYNCPOINT,DELTA... In this case decoder drops the frames
between HEADERS and SYNCPOINT which leads into using wrong PTS on
the output frames.

With this change we inject the input PTS into the bitstream and use it
to align the internal frame list with the actually decoded position.

Fixes playback with:
```
gst-launch-1.0 rtspsrc location=... latency=0 drop-on-latency=1 ! ...
```

nvenc: Query supported minimum resolution

Hard-coded 16x16 resolution is likely to differ from the device's support
in most cases. If we can use NV_ENC_CAPS_WIDTH_MIN and NV_ENC_CAPS_HEIGHT_MIN,
update pad template with returned value.

nvcodec: Bump SDK header to version 9.1

Update header to query minimum resolution of encoder and to control
the number of reference frame if it's supported

mxfdemux: add support for Apple ProRes

examples: add test-roi for gst-msdk

Copied and pasted from gstreamer-vaapi and did a few changes for gst-msdk.

msdkdec: support transform_meta virtual method

Allow the base class to copy GstVideoRegionOfInterestMeta data to the
output buffer when calling gst_video_decoder_finish_frame

msdkenc: set ROI region for msdk{h264, h265}enc

A reconfig is needed when ROI is changed, otherwise the ROI parameters won't
take effect

msdkenc: add set_extra_params virtual method

set_extra_params is added to allow sub class to add extra mfx parameters
for changed input frame or meta data

msdkenc: add need_reconfig virtual method

need_reconfig is added to allow sub class requires a reconfig when
the input frame or the MetaData (e.g. GstVideoRegionOfInterestMeta)
attached to the input frame is changed.

d3d11h265dec: Fix wrong NoRaslOutputFlag setting

... and handle EOS and EOB nals.

Only the first CRA picture should be associated with NoRaslOutputFlag
as the comment in code.

pkgconfig: Remove unused substitution in uninstalled.pc.in

`@videolibdir@` isn't used anymore.

tests: Fix minor bugs in usage of config.h

ipcpipeline: Minimal fixes that allow building with MSVC

ipcpipeline: Rework compiler checks

`pipe()` isn't used since 15927b6511bc8304ae144a45c9fbfca88e5dd641,
and `socketpair()` from `#include <sys/socket.h>` is used only in the
examples. In practice, you can use probably also use anything that
allows you to create fd pairs, such as named pipes or anonymous pipes.

We use the cross-platform GstPollFD API in the plugin.

timecodestamper: Add property to set the extra latency to introduce for waiting for LTC timecodes

Default to 150ms instead of 8 frames, which seems to work in the
majority of cases.

timecodestamper: Add some more debug output

d3d11memory: Always use native DXGI format if device support it

Use consistent memory layout between dxva and other shader use case.
For example, use DXGI_FORMAT_NV12 texture format instead of
two textures with DXGI_FORMAT_R8_UNORM and DXGI_FORMAT_R8G8_UNORM.

Revert "d3d11: Add support for D3D11_USAGE_DYNAMIC"

This reverts commit ddd13fc7c061a9873b181d0de32aaf9546e7d0af

Dynamic usage can reduce the number of copy per frame but make
things complicated and the benefit seems to not significant.
Also since we don't provide _map() method for the dynamic usage,
application cannot read buffers which make "last-sample" property
unusable in case of d3d11videosink.

WebRTC: Support non-trickle ICE candidates in the SDP

Add any ICE candidates from the SDP before adding pending
trickle ICE candidates to support non-trickle peers

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

d3d11: Don't register decoders if unavailable

DXVA requires a hardware interface but may not be available,
such as in the case of VMs or when the GPU vendor does not provide a decoder interface.

d3d11decoder: Don't return not initialized object from _new() method

... and change some debug levels since initialization failure might not be fatal.

waylandsink: Fix xdg_shell fullscreen mode

xdg_shell fullscreen mode doesn't work for committing
xdg_surface without configure acknowledgement.

In addition, we can't set different surface setting from
acknowledged config in this mode.

h264parse: do not push wrong PTS with some raw files

Some raw h264 encoded files trigger the assignment of wrong PTS to buffers
when some SEI data is provided. This change prevents it to happen.

Also ensure this behavior is being tested.

timecodestamper: Skip over invalid LTC timecodes immediately

timecodestamper: Clean up old LTC timecodes on LTC discontinuity

We might have some old timecodes that are in the future now and have to
drop those to make sure that our queue is correctly ordered and we don't
have multiple timecodes for the same running time.

timecodestamper: Fix waiting for the first video frame in case of live video input

timecodestamper: Fix up handling/queueing of LTC timecodes

Directly read them out of the decoder as soon as we passed audio and
then store them in a queue that we handle internally together with their
timestamps. This cleans up memory management and gives us proper control
over the queue instead of guessing how the queue inside the LTC decoder
actually works and when it overflows.

timecodestamper: Only allow requesting LTC audio pad in NULL/READY states

And don't introduce any latency at all if not LTC audio pad was
requested.

timecodestamper: In live mode wait correctly for the latency to pass

And also introduce 6 instead of 2 frames of latency compared to the LTC
audio input as that seems to be an upper bound for how much the LTC
library is lagging behind.

timecodestamper: Use the internal LTC timecode tracker instead of the last one we retrieved

Otherwise we don't interpolate between LTC timecodes but only ever put
an LTC timecode on buffers once we actually received one.

decklink: Silence no driver / no SO messages

This g_once() is called everywhere, even in provider. This cause
spurious error when device monitor is used. Just silence or remove
the spurious logs.

hls: Check nettle version to ensure AES128 support

AES128 support was added since nettle version 3.0

../subprojects/gst-plugins-bad/ext/hls/gsthlsdemux.h:110:10: error: field ‘ctx’ has incomplete type
   struct CBC_CTX (struct aes128_ctx, AES_BLOCK_SIZE) aes_ctx;

Revert "msdkdec: make sure to use video memory on Linux"

Commit a1584b6 caused big performance drop if the downstream element
is not a msdk element because it is very slow to read data from video
memory directly.

This reverts commit a1584b6f99caaf61812ac6a9654ec0e6da8240da.

tests: d3d11colorconvert: Add test cases for visual validation

By default new test cases are disabled since it might be timed out
or test environment might not have render device.

d3d11colorconverter: Handle P016_LE format

P016 format is no different than P010. Not much things to add code.

d3d11colorconverter: Add support for YUV to YUV conversion

d3d11colorconverter: Add support for RGB to YUV conversion

... and remove code for RGBx since it's not supported format
by our d3d11 implementation for now.

d3d11format: Remove invalid format from supported format list

decklinkvideosink: Always configure 10 bit YUV for VANC frames

If 8 bit are required by the device/mode then it will be converted internally
by the SDK, but the SDK won't automatically convert from 8 to 10 bit. As
such, always use 10 bit VANC.

Some devices require configuring also a 10 bit video format when using
10 bit VANC is required but those would fail regardless and the
application would have to configure the correct video format.

With newer versions of the SDK this information can be retrieved via the
BMDDeckLinkVANCRequires10BitYUVVideoFrames flag but we don't use a new
enough SDK version yet to extract this information.

webrtc: Unmap all non-binary buffers received via the datachannel

Previously they were only unmapped in case of binary data, causing all
of them to be leaked.

zbar: remove useless conditional on passthrough

seen that passthrough is never set for this element, no need
to allow to remove the 'transform' call

zxing: initial plugin revision

Status:
- scan QR code with low resolution
- Scan barcode with high resolution

tests: add h26xparse HDR SEI test

Detect caps according to MDCV + CLLI SEI message

test: add h265parse test

h26xparse: Handle state change on IDR first slice

As the H265/H264 bitstream can support multiple slices,
mastering_display_info_state and content_light_level_state
should be changed only on first slice segment.

Fix #1152

h265parse: use same algo for MDCV and CLL SEI management

h264parser: add MDCV and CLL SEI message parsing

Allow to parse SEI message for:
- mastering display colour volume
- Light level infomation

Set to caps if necessary.

Fix #958

dash: Remove spurious condition check and remove unused debug category

Note that uppercase debug category names are used for
core modules and should be redefined in lowercase for plugins if necessary.

fakevideosink: Use our pad template to create pad

d3d11: Add support for Universal Windows Platform

Initial UWP support via new window (CoreWindow and SwapChainPanel) implementation.

d3d11decoder: Fix build on non-desktop target

Although the target platform of D3D11 decoding API are both desktop and UWP app,
DXVA header is blocked by "WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)"
which is meaning that that's only for desktop app.
To workaround this inconsistent annoyingness, we need to define WINAPI_PARTITION_DESKTOP
regardless of target WinAPI partition.

msdkvp9enc: fix 10bit encoding

The codec profile should be consistent with the frame fourcc code, this
fixes pipeline below:

gst-launch-1.0 videotestsrc ! \
video/x-raw,width=320,height=240,format=P010_10LE ! msdkvp9enc ! \
fakesink

msdkvp9enc: fix width and height

The frame width and height is rounded up to 128 and 32 since commit
8daac1c, so the width, height for initialization should be rounded up to
128 and 32 too because the MSDK VP9 encoder will do some check on width
and height.

Sample pipeline:
gst-launch-1.0 videotestsrc ! \
video/x-raw,width=320,height=240,format=NV12 ! msdkvp9enc ! fakesink

msdk: make sure the found response meets the request

Otherwise the re-used msdk response doesn't have enough frames so it is
possible the pipeline will be broken

msdkenc: renegotiate when video info changes

Renegotiation was implemented for bitrate change. We can re-use
the same sequence when video info changes except that this can be
executed right away when receiving the new input format. I.e. no
need to wait for the next call to handle_frame.

decklink: Fix crash when probing without driver

If there is no decklink hardware/driver, the devices list is empty (NULL), so
this needs to be checked before iterating over the list.

dashsink: Add new sink to produce DASH content

Add static or dynamic mpd with:
- baseURL
- period
- adaptation_set
- representaton
- SegmentList
- SegmentURL
- SegmentTemplate

Support multiple audio and video streams.
Pass conformance test with DashIF.org

gstxmlhelper: fix xmlOutputBufferFlush ignored ret

fix CID #1456553

dash: add set/get property for nodes

Add a way to set/get properties for given nodes:

- root
- baseurl
- representation

dash: Generate an XML content from object.

Add mpd node base class to provide
xml generation facilities for child
objects.

msdkdec: trigger renegotiation if video info changes

Useful when framerate changes. Previously it was only checking
for resolution change but renego should happen if any video
info changes.

vulkansink: Fix null pointer exception

context query might happen before creating swapper.

msdkdec: make sure to use video memory on Linux

The block that sets use_video_memory flag is after the
the condition `if gst_msdk_context_prepare` but it
always returns false when there is no other msdk elements.
So the decoder ends up with use_video_memory as FALSE.
Note that msdkvpp always set use_video_memory as TRUE.

When use_video_memory is FALSE then the msdkdec allocates
the output frames with posix_memalign (see gstmsdksystemmemory.c).
The result is then copied back to the GstVideoPool's buffers
(or to the downstream pool's buffers if any).
When use_video_memory is TRUE then the msdkdec uses vaCreateSurfaces
to create vaapi surfaces for the hw decoder to decode into
(see gstmsdkvideomemory.c). The result is then copied to either
the internal GstVideoPool and to the downstream pool if any.
(vaDeriveImage/vaMapBuffer is used in order to read the surfaces)

msdkdec: Correct return value of GstVideoDecoder::flush()

Use boolean instead of GstFlowReturn as declared.
Note that since base class does not check return value of GstVideoDecoder::flush(),
this would not cause any change of behavior.

msdkdec: free unlocked msdk surface before output buffer allocation

https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/merge_requests/924
is trying to use video memory for decoding on Linux, which reveals a
hidden bug in msdkdec.

For video memory, it is possible that a locked mfx surface is not used
indeed and it will be un-locked later in MSDK, so we have to check the
associated MSDK surface to find out and free un-used surfaces, otherwise
it is easy to exhaust all pre-allocated mfx surfaces and get errors below:

0:00:00.777324879 27290 0x564b65a510a0 ERROR                default
gstmsdkvideomemory.c:77:gst_msdk_video_allocator_get_surface: failed to
get surface available
0:00:00.777429079 27290 0x564b65a510a0 ERROR         msdkbufferpool
gstmsdkbufferpool.c:260:gst_msdk_buffer_pool_alloc_buffer:<msdkbufferpool0>
failed to create new MSDK memory

Note the sample code in MSDK does similar thing in
CBuffering::SyncFrameSurfaces()

hlssink2: Add signals for allowing custom playlist/fragment handling

Instead of always going through the file system API we allow the
application to modify the behaviour. For the playlist itself and
fragments, the application can provide a GOutputStream. In addition the
sink notifies the application whenever a fragment can be deleted.

webrtc: Actually make use of promise created one line before

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

mpegtsdemux: resurrect actual and efficient seeking of all kinds

... by seeking to target offset determined by new seek segment,
rather than that of the previous segment.  The latter would typically
seek back to start for a non-accurate seek, and lead to a lot
of skipping in case of an accurate seek.

d3d11: Add h265 decoder element

Some DPB management implementation is taken from gstreamer-vaapi

d3d11: Add vp9 decoder element

Based on gstreamer-vaapi and Chromium implemetation.

d3d11: Add h264 decoder element

New decoder implementation based on dxva2 on d3d11 APIs. The DPB
management implementation is taken from Chromium.

d3d11: Add support for Array typed texture memory

A ID3D11Texture2D memory can consist of multiple planes with array.
For array typed memory, GstD3D11Allocator will allocate new GstD3D11Memory
with increased reference count to the ID3D11Texture2D but different array index.

bad: use of g_value_dup_string

Use helper method to get string from GValue.

dtlsenc: Don't warn on GST_FLOW_FLUSHING or GST_FLOW_EOS

Only warn if pushing a buffer returns an actual error to not pollute
logs with confusing warnings.

timecodestamper: Refactor LTC audio waiting and properly handle live inputs

If one of the inputs is live, add a latency of 2 frames to the video
stream and wait on the clock for that much time to pass to allow for the
LTC audio to be ahead.

In case of live LTC, don't do any waiting but only ensure that we don't
overflow the LTC queue.

Also in non-live LTC audio mode, flush too old items from the LTC queue
if the video is actually ahead instead of potentially waiting forever.
This could've happened if there was a bigger gap in the video stream.

tests: Add simple d3d11colorconvert unit test

d3d11: Aggregate d3d11 memory usage query for dynamic-usage type decision

Even if one of downstream d3d11 elements can support dynamic-usage memory,
another one might not support it. Also, to support dynamic-usage,
both upstream and downstream d3d11device must be the same object.

d3d11colorconvert: Remove device type dependent behavior

If d3d11colorconvert element is configured, do color space conversion
regardless of the device type whether it's S/W emulation or real H/W.
Since d3d11colorconvert is no more a child of d3d11videosinkbin,
we don't need this behavior. Note that previous code was added to
avoid color space conversion from d3d11videosink if no hardware
device is available (S/W emulation of d3d11 is too slow).