dtls: fix dtls connection object leak

decklink: Make sure to return a value from all code paths

False warning from MSVC, or it does not understand that
g_assert_not_reached() does not return.

...\gst-plugins-bad-1.0-1.17.0.1\sys\decklink\gstdecklink.cpp(1647) : warning C4715: 'gst_decklink_configure_duplex_mode': not all control paths return a value

decklinksrc: Reset timestamp observations on format change

We will usually get timestamps starting from 0 again and due to the
format change the clock of the input might also be different.

nvcodec: Clean up pointless return values around plugin init

Any plugin which returned FALSE from plugin_init will be blacklisted
so the plugin will be unusable even if an user install required runtime
dependency next time. So that's the reason why nvcodec returns TRUE always.

This commit is to remove possible misreading code.

nvcodec: Change log level for g_module_open failure

Since we build nvcodec plugin without external CUDA dependency,
CUDA and en/decoder library loading failure can be natural behavior.

Emit error only when the module was opend but required symbols are missing.

nvdec: Add support for 10bits 4:2:0 decoding

This commit includes h265 main-10 profile support if the device can
decode it.

Note that since h264 10bits decoding is not supported by nvidia GPU for now,
the additional code path for h264 high-10 profile is a preparation for
the future Nvidia's enhancement.

nvdec: Specify supported profiles of h264/h265 codec

See more details about supported formats at
nvidia codec sdk document "NVDEC_VideoDecoder_API_ProgGuide.pdf"
Table 1. Hardware Video Decoder Capabilities.

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

nvdec: Skip draining before creating internal parser

GstVideoDecoder::drain/flush can be called at very initial state
with stream-start and flush-stop event, respectively.
Draning with NULL CUvideoparser seems to unsafe and that eventually
failed to handle it.

dash: Fallback to libxml2 subproject

msdkdec: improve spelling and grammar of comments

msdkdec: make sure mfx frame width/height meets MSDK's requirement

It is possible that the output region size (e.g. 192x144) is different
from the coded picture size (e.g. 192x256). We may adjust the alignment
parameters so that the padding is respected in GstVideoInfo and use
GstVideoInfo to calculate mfx frame width and height

This fixes the error below when decoding a stream which has different
output region size and coded picture size

0:00:00.057726900 28634 0x55df6c3220a0 ERROR                msdkdec
gstmsdkdec.c:1065:gst_msdkdec_handle_frame:<msdkh265dec0>
DecodeFrameAsync failed (failed to allocate memory)

Sample pipeline:

gst-launch-1.0 filesrc location=output.h265 ! h265parse ! msdkh265dec !
glimagesink

msdkdec: remove unneeded code

Before calling gst_msdkdec_create_buffer_pool, the alignment parameters
have been adjusted.

nvcodec: Drop system installed cuda.h dependency

... and add our stub cuda header.

Newly introduced stub cuda.h file is defining minimal types in order to
build nvcodec plugin without system installed CUDA toolkit dependency.
This will make cross-compile possible.

nvcodec: Keep requested rank for default device

Fix for default encoder and decoder element factory to make them have
higher rank than the others.

nvenc: Register elements per GPU device with capability check

* By this commit, if there are more than one device,
nvenc element factory will be created per
device like nvh264device{device-id}enc and nvh265device{device-id}enc
in addition to nvh264enc and nvh265enc, so that the element factory
can expose the exact capability of the device for the codec.

* Each element factory will have fixed cuda-device-id
which is determined during plugin initialization
depending on the capability of corresponding device.
(e.g., when only the second device can encode h265 among two GPU,
then nvh265enc will choose "1" (zero-based numbering)
as it's target cuda-device-id. As we have element factory
per GPU device, "cuda-device-id" property is changed to read-only.

* nvh265enc gains ability to encoding
4:4:4 8bits, 4:2:0 10 bits formats and up to 8K resolution
depending on device capability.
Additionally, I420 GLMemory input is supported by nvenc.

nvdec: Create CUDA context with registered device id

Only the default device has been used by NVDEC so far.
This commit make it possible to use registered device id.
To simplify device id selection, GstNvDecCudaContext usage is removed.

nvdec: Register elements per device/codec with capability check

By this commit, each codec has its own element factory so the
nvdec element factory is removed. Also, if there are more than one device,
additional nvdec element factory will be created per
device like nvh264device{device-id}dec, so that the element factory
can expose the exact capability of the device for the codec.

msdk: Do not expose DMA buffer caps feature on Windows

On Windows, DMA buffer is not supported. PadTemplate with actually
supported feature seems to more make sense.

nvcodec: Drop cudaGL.h dependency

nvcodec does not use any type/define/enum in cudaGL.h.

av1enc: Also set AV1E_SET_ROW_MT from the property value when initializing the encoder

Previously it was only set if the property was changed after the encoder
was initialized.

av1enc: Add threads and row-mt properties

Add threads related property that setting a number of threads to encode
av1 codec and row-mt configuration.

av1enc: Release lock when failing to initialize

Add to missing unlock when failing to initialize encoder.

Revert "av1enc: Release lock when failing to initialize"

This reverts commit 7de6b5d48161cb4982efe7fd04c8be408ca85424.

It was accidentally squashed together from the MR instead of keeping the
individual commits.

siren: fix a global buffer overflow spotted by asan

This patch just enforces boudaries for the access to the
standard_deviation array (64 floats). Such case can be
seen with a corrupted stream, where there's no hope to
obtain a valid decoded frame anyway.

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

av1enc: Release lock when failing to initialize

Add to missing unlock when failing to initialize encoder.

nvdec: Fix video stuttering issue with VP9

Address nvidia driver specific behavior to avoid unexpected frame mismatch
between GStreamer and NVDEC.

nvdec: Drop async queue and handle data on callback of CUvideoparser

Callbacks of CUvideoparser is called on the streaming thread.
So the use of async queue has no benefit.

Make control flow straightforward instead of long while/switch loop.

rtponviftimestamp: fix setting of the discontinuity flag

The D bit is meant to be set whenever there is a discontinuity
in transmission, and directly maps to the DISCONT flag.

The E bit is not meant to be set on every buffer preceding a
discontinuity, but only on the last buffer of a contiguous section
of recording. This has to be signaled through the unfortunately-named
"discont" field of the custom NtpOffset event.

rtponvifparse: set ONVIF timestamps as buffer PTS

h26{4,5}parse: add support for forward predicted trick mode

Also stop assigning TRUE to fields with |=

x265enc: Specify colorimetry related VUI parameters

Set the colorimetry config for the information to be embedded in encodec bitstream.

nvdec: Port to color_{primaries,transfer,matrix}_to_iso

... and update the color information only when upstream was not provided
the information.

nvenc: Specify colorimetry related VUI parameters

Set the colorimetry config for the information to be embedded in encodec bitstream.

webrtcdatachannel: inherit directly from GObject

There's no reason for it to inherit from GstObject apart from
locking, which is easily replaced, and inheriting from
GInitiallyUnowned made introspection awkward and needlessly
complicated.

h264parse: Update caps per pixel aspect ratio change

Output caps should be updated per pixel aspect ratio change.

h265parse: Expose parsed colorimetry when VUI provided it

... and also if upstream did not specify the colorimetry.

h264parse: Expose parsed colorimetry when VUI provided it

... and also if upstream did not specify the colorimetry.

kmssink: Fix implicit declaration build error

ffs() and strcmp() require string.h

gstkmssink.c:255:28: error: implicit declaration of function ‘ffs’ [-Werror=implicit-function-declaration]
       crtc_id = res->crtcs[ffs (crtcs_for_connector) - 1];
                            ^~~

gstkmssink.c:590:10: error: implicit declaration of function ‘strcmp’ [-Werror=implicit-function-declaration]
     if (!strcmp (property->name, prop_name)) {
          ^~~~~~

Fix -Werror=return-type error in configure.

aiff: Fix infinite loop in header parsing.

decklinkvideosrc: Don't report that we have signal until we know for sure

Previously we would've reported that there is signal unless we know for
sure that we don't have signal. For example signal would've been
reported before the device is even opened.

Now keep track whether the signal state is unknown or not and report no
signal if we don't know yet. As before, only send an INFO message about
signal recovery if we actually had a signal loss before.

avwait: In running-time mode, select start/end running time based on the actual video timestamps

Otherwise we would start/end at exactly the given times, which might be
up to 1 frame earlier/later than the video.

avwait: Add some more debug output

avwait: Fix clipping of audio buffers at the start of recording

build: Fix error messages for missing hotdoc extensions

cccombiner: Proxy POSITION/DURATION/URI/CAPS/ALLOCATION queries between video sinkpad and source pad

We pass-through the video as is, only putting a GstMeta on it from the
caption sinkpad.

This fixes negotation problems caused by not passing through caps
queries in both directions.

Also handle CAPS/ACCEPT_CAPS queries directly for the caption pad
instead of proxying.

nvdec: Fix possible frame drop on EOS

On eos, baseclass videoencoder call finish() vfunc instead of drain()

decklinkvideosrc: remove g_print

Causes a lot of output :)

vulkan: Fix incompatible type build warning

Make declare/define a function consistent.
Note that GstBaseTransform::set_caps should return gboolean

Compiling C object subprojects/gst-plugins-bad/ext/vulkan/f3f9d6b@@gstvulkan@sha/vkviewconvert.c.obj.
../subprojects/gst-plugins-bad/ext/vulkan/vkviewconvert.c(644):
  warning C4133: '=': incompatible types - from 'GstFlowReturn (__cdecl *)(GstBaseTransform *,GstCaps *,GstCaps *)'
  to 'gboolean (__cdecl *)(GstBaseTransform *,GstCaps *,GstCaps *)'

srt: Remove msg-size property

Remove the now unused property

srtsrc: Receive one frame per gstbuffer

Don't aggregate the received data, just receive it one packet at a
time. So it keeps the packetization boundaries

srt: Fix listener crash if no URI is specified

srt: Use macro instead of duplicating a default value

srt: Fix confusing typo in FIXME comment

SRT does not support IPv6, but the comment said IPv4 which was the
opposite of the following code.

timecodestamper: Add support for linear timecode (LTC) from an audio stream

Based on a patch by
  Georg Lippitsch <glippitsch@toolsonair.com>
  Vivia Nikolaidou <vivia@toolsonair.com>

Using libltc from https://github.com/x42/libltc

timecodestamper: Rewrite element API and code flow

We now have a single property to select the timecode source that should
be applied, and for each timecode source the timecode is updated at
every frame. Then based on a set mode, the timecode is added to the
frame if none exists already or all existing timecodes are removed and
the timecode is added.

In addition the real-time clock is considered a proper timecode source
now instead of only allowing to initialize once in the beginning with
it, and also instead of just taking the current time we now take the
current time at the clock time of the video frame.

nvcodec: do a generic cuda tests before going into version specifics

nvdec,nvenc: Port to dynamic library loading

... and put them into new nvcodec plugin.

* nvcodec plugin
Now each nvenc and nvdec element is moved to be a part of nvcodec plugin
for better interoperability.
Additionally, cuda runtime API header dependencies
(i.e., cuda_runtime_api.h and cuda_gl_interop.h) are removed.
Note that cuda runtime APIs have prefix "cuda". Since 1.16 release with
Windows support, only "cuda.h" and "cudaGL.h" dependent symbols have
been used except for some defined types. However, those types could be
replaced with other types which were defined by "cuda.h".

* dynamic library loading
CUDA library will be opened with g_module_open() instead of build-time linking.
On Windows, nvcuda.dll is installed to system path by CUDA Toolkit
installer, and on *nix, user should ensure that libcuda.so.1 can be
loadable (i.e., via LD_LIBRARY_PATH or default dlopen path)
Therefore, NVIDIA_VIDEO_CODEC_SDK_PATH env build time dependency for Windows
is removed.

d3d11videosink: Add new Direct3D11 video render plugin

Direct3D11 was shipped as part of Windows7 and it's obviously
primary graphics API on Windows.

This plugin includes HDR10 rendering if following requirements are satisfied
* IDXGISwapChain4::SetHDRMetaData is available (decleared in dxgi1_5.h)
* Display can support DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 color space
* Upstream provides 10 bitdepth format with smpte-st 2084 static metadata

webrtcbin: Don't assert if an SDP media can't be converted to caps

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

msdk: add msdkvp9enc element

msdk: workaround for MFX_FOURCC_VP9_SEGMAP surface

MFX_FOURCC_VP9_SEGMAP surface in MSDK is an internal surface however
MSDK still call the external allocator for this surface, so this plugin
has to return UNSUPPORTED and force MSDK allocates surface using the
internal allocator.

See https://github.com/Intel-Media-SDK/MediaSDK/issues/762 for details

msdkenc: allow encode element requires extra frames

The call of MFXVideoENCODE_EncodeFrameAsync may not generate output and
the function returns MFX_ERR_MORE_DATA with NULL sync point, the input
frame is cached in this case, so it is possible that all allocated
frames go into the surfaces_used list after calling
MFXVideoENCODE_EncodeFrameAsync a few times, then the encoder will fail
to get an available surface before releasing used frames

This patch adds a new field of num_extra_frames to GstMsdkEnc and allows
encode element requires extra frames, the default value is 0.

This patch is the preparation for msdkvp9enc element.

tests/vulkan: fix copyright name

vulkan/window: add property for the parent display

vulkan/device: add property for the parent instance

vulkan: add view converter element

vulkan: fix output framebuffer creation size

We don't scale when color converting so there is no impact.

tsmux: output smoothly increasing PTS when in CBR mode

Thanks to that, when its output is plugged into eg a udp sink, the
outgoing data can be output in a smoother way, reducing burstiness

tests: Add h264parser SEI checks

Add some tests around SEI parsing.

h264parser lib: Add more profile_idc to the recognised set

Update the list of profile_idc recognised during SPS parsing
based on H.264 201704

h264parse lib: Remove the SPS parse_vui_params flag

The SPS parsing functions take a parse_vui_param flag
to skip VUI parsing, but there's no indication in the output
SPS struct that the VUI was skipped.

The only caller that ever passed FALSE seems to be the
important gst_h264_parser_parse_nal() function, meaning - so the
cached SPS were always silently invalid. That needs changing
anyway, meaning noone ever passes FALSE.

I don't see any use for saving a few microseconds in
order to silently produce garbage, and since this is still
unstable API, let's remove the parse_vui_param.

h264parser lib: Warn on invalid pic_timing SEI

The spec calls for pic_timing SEI to be absent unless
there's either a CpbDpbDelaysPresentFlag or
pic_struct_present_flag in the SPS VUI data. If
both those flags are missing, warn.

h264parser lib: Always consume all SEI bits

If parsing an SEI errors out, it might not consume
all bits, leaving extra unparsed data in the reader
that the outer loop then tries to parse as a new
appended SEI.

Skip all the bits if any are left over to avoid
'finding' extra garbage SEI in the parsing.

h264parser: Return BROKEN_LINK for missing SPS

When parsing SEI that require an SPS, return
GST_H264_PARSER_BROKEN_LINK instead of a generic
parsing error to let callers distinguish
bitstream errors from (expected) missing packets
when resuming decode.

h264parser: Improve documentation

Improve some docs around the NALU structure contents

gstmpegvideoparser: Documentation fixes

Fix some spelling mistakes and improve documentation in
the MPEG video parser

tsmuxstream: Do not try return from void function

../subprojects/gst-plugins-bad/gst/mpegtsmux/tsmux/tsmuxstream.c(1082): warning C4098:
  'tsmux_stream_get_es_descrs': 'void' function returning a value

mpegtsmux: Remove white space

vulkan: move swapper object to the gstvulkan library

Allows other sinks and/or user code to display to a VkSurface

vulkan: move trash list to library

webrtcbin: use the latest self-generated SDP as the basis for renegotiations

Fixes multiple errors when a webrtcbin renegotiation can switch between the
offerer and the answerer.

avtp: Update documentation

tests: Add AVTP CVF depayloader tests

In these tests, some specially crafted buffers are sent to the
depayloader, simulating some scenarios and checking what comes out from
it.

tests: Add AVTP CVF payloader tests

In these tests, some specially crafted buffers are sent to the
payloader, simulating some scenarios and checking what comes out from
it.

tests: Add AVTP source tests

This patch adds test cases for the AVTP source element. For now, only
properties get() and set() are covered.

tests: Add AVTP sink tests

This patch adds test cases for the AVTP sink element. For now, only
properties get() and set() are covered.

tests: Add AAF depayloader tests

This patch adds test cases for the AAF depayloader element covering the
basic functionalities.

tests: Add AAF payloader tests

This patch adds the infrastructure to test AVTP plugin elements. It also
adds a test case to check avtpaafpay element basic functionality. The
test consists in setting the element sink caps and properties, and
verifying if the output buffer is set as expected.

docs: Add AVTP elements documentation

avtp: Add fragmented packets handling to CVF depayloader

This patch adds to the CVF depayloader the capability to regroup H.264
fragmented FU-A packets.

After all packets are regrouped, they are added to the "stash" of H.264
NAL units that will be sent as soon as an AVTP packet with M bit set is
found (usually, the last fragment).

Unrecognized fragments (such as first fragment seen, but with no Start
bit set) are discarded - and any NAL units on the "stash" are sent
downstream, as if a SEQNUM discontinuty happened.

avtp: Introduce AVTP CVF depayloader element

This patch introduces the AVTP Compressed Video Format (CVF) depayloader
specified in IEEE 1722-2016 section 8. Currently, this depayloader only
supports H.264 encapsulation described in section 8.5.

Is also worth noting that only single NAL units are handled: aggregated
and fragmented payloads are not handled.

As stated in AVTP CVF payloader patch, AVTP timestamp is used to define
outgoing buffer DTS, while the H264_TIMESTAMP defines outgoing buffer
PTS.

When an AVTP packet is received, the extracted H.264 NAL unit is added to
a "stash" (the out_buffer) of H.264 NAL units. This "stash" is pushed
downstream as single buffer (with NAL units aggregated according to format
used on GStreamer, based on ISO/IEC 14496-15) as soon as we get the AVTP
packet with M bit set.

This patch groups NAL units using a fixed NAL size lenght, sent downstream
on the `codec_data` capability.

The "stash" of NAL units can be prematurely sent downstream if a
discontinuity (a missing SEQNUM) happens.

This patch reuses the infra provided by gstavtpbasedepayload.c.

avtp: Add fragmentation feature to CVF payloader

Based on `mtu` property, the CVF payloader is now capable of properly
fragmenting H.264 NAL units that are bigger than MTU in several AVTP
packets.

AVTP spec defines two methods for fragmenting H.264 packets, but this
patch only generates non-interleaved FU-A fragments.

Usually, only the last NAL unit from a group of NAL units in a single
buffer will be big enough to be fragmented. Nevertheless, only the last
AVTP packet sent for a group of NAL units will have the M bit set (this
means that the AVTP packet for the last fragment will only have the M
bit set if there's no more NAL units in the group).

avtp: Introduce AVTP CVF payloader element

This patch introduces the AVTP Compressed Video Format (CVF) payloader
specified in IEEE 1722-2016 section 8. Currently, this payload only
supports H.264 encapsulation described in section 8.5.

Is also worth noting that only single NAL units are encapsulated: no
aggregation or fragmentation is performed by the payloader.

An interesting characteristic of CVF H.264 spec is that it defines an
H264_TIMESTAMP, in addition to the AVTP timestamp. The later is
translated to the GST_BUFFER_DTS while the former is translated to the
GST_BUFFER_PTS. From AVTP CVF H.264 spec, it is clear that the AVTP
timestamp is related to the decoding order, while the H264_TIMESTAMP is
an ancillary information to the H.264 decoder.

Upon receiving a buffer containing a group of NAL units, the avtpcvfpay
element will extract each NAL unit and payload them into individual AVTP
packets. The last AVTP packet generated for a group of NAL units will
have the M bit set, so the depayloader is able to properly regroup them.

The exact format of the buffer of NAL units is described on the
'codec_data' capability, which is parsed by the avtpcvfpay, in the same
way done in rtph264pay.

This patch reuses the infra provided by gstavtpbasepayload.c.

avtp: Introduce AVTP source element

This patch introduces the avtpsrc element which implements a typical
network source. The avtpsrc element receives AVTPDUs encapsulated into
Ethernet frames and push them downstream in the GStreamer pipeline.
Implementation if pretty straightforward since the burden is implemented
by GstPushSrc class.

Likewise the avtpsink element, applications that utilize this element
must have CAP_NET_RAW capability since it is required by Linux to open
sockets from AF_PACKET domain.

avtp: Introduce AVTP sink element

This patch introduces the avtpsink elements which implements a typical
network sink. Implementation is pretty straightforward since the burden
is implemented by GstBaseSink class.

The avtpsink element defines three new properties: 1) network interface
from where AVTPDU should be transmitted, 2) destination MAC address
(usually a multicast address), and 3) socket priority (SO_PRIORITY).

Socket setup and teardown are done in start/stop virtual methods while
AVTPDU transmission is carried out by render(). AVTPDUs are encapsulated
into Ethernet frames and transmitted to the network via AF_PACKET socket
domain.  Linux requires CAP_NET_RAW capability in order to open an
AF_PACKET socket so the application that utilize this element must have
it. For further info about AF_PACKET socket domain see packet(7).

Finally, AVTPDUs are expected to be transmitted at specific times -
according to the GstBuffer presentation timestamp - so the 'sync'
property from GstBaseSink is set to TRUE by default.

avtp: Introduce AAF depayloader element

This patch introduces the AAF depayloader element, the counterpart from
the AAF payloader. As expected, this element inputs AVTPDUs and outputs
audio raw data and supports AAF PCM encapsulation only.

The AAF depayloader srcpad produces a fixed format that is encoded
within the AVTPDU. Once the first AVTPDU is received by the element, the
audio features e.g. sample format, rate, number of channels, are decoded
and the srcpad caps are set accordingly. Also, at this point, the
element pushes a SEGMENT event downstream defining the segment according
to the AVTP presentation time.

All AVTP depayloaders will share some common code. For that reason, this
patch introduces the GstAvtpBaseDepayload abstract class that implements
common depayloader functionalities. AAF-specific functionalities are
implemented in the derived class GstAvtpAafDepay.

avtp: Introduce AAF payloader element

This patch introduces the AVTP Audio Format (AAF) payloader element from
the AVTP plugin. The element inputs audio raw data and outputs AVTP
packets (aka AVTPDUs), implementing a typical protocol payloader element
from GStreamer.

AAF is one of the available formats to transport audio data in an AVTP
system. AAF is specified in IEEE 1722-2016 section 7 and provides two
encapsulation mode: PCM and AES3. This patch implements PCM
encapsulation mode only.

The AAF payloader working mechanism consists of building the AAF header,
prepending it to the GstBuffer received on the sink pad, and pushing the
buffer downstream. Payloader parameters such as stream ID, maximum
transit time, time uncertainty, and timestamping mode are passed via
element properties. AAF doesn't support all possible sample format and
sampling rate values so the sink pad caps template from the payloader is
a subset of audio/x-raw. Additionally, this patch implements only
"normal" timestamping mode from AAF. "Sparse" mode should be implemented
in future.

Upcoming patches will introduce other AVTP payloader elements that will
have some common code. For that reason, this patch introduces the
GstAvtpBasePayload abstract class that implements common payloader
functionalities, and the GstAvtpAafPay class that extends the
GstAvtpBasePayload class, implementing AAF-specific functionalities.

The AAF payloader element is most likely to be used with the AVTP sink
element (to be introduced by a later patch) but it could also be used
with UDP sink element to implement AVTP over UDP as described in IEEE
1722-2016 Annex J.

This element was inspired by RTP payloader elements.

avtp: AVTP plugin bootstrap code

This patch introduces the bootstrap code from the AVTP plugin (plugin
definition and init) as well as the build system files. Upcoming patches
will introduce payloaders, source and sink elements provided by the AVTP
plugin. These elements can be utilized by a GStreamer pipeline to
implement TSN audio/video applications.

Regarding the plugin build system files, both autotools and meson files
are introduced. The AVTP plugin is landed in ext/ since it has an
external dependency on libavtp, an opensource AVTP packetization
library. For further information about libavtp check [1].

[1] https://github.com/AVnu/libavtp

h265parse: Don't segfault when SPS hasn't been seen yet.

Fix a recently introduced segfault. Don't de-reference a NULL
SPS pointer when attempting to update source caps before SPS
has been seen in the stream.