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.

irtspparse: handle multiple and incomplete frames

Interleaved frames can be fragmented between
incoming frames. Thus, we can have multiple
frames within the single input frame, as well as
incomplete frame. Now it preserves parsing
state and handle both situations.

Fixes #991

msdk: don't share context between msdkvpp and msdkenc

msdkenc supports CSC implicitly, so it is possible that two VPP
processes are required when a pipeline contains msdkvpp and msdkenc.
Before this fix, msdkvpp and msdkenc may share the same context, hence
the same mfx session, which results in MFX_ERR_UNDEFINED_BEHAVIOR
in MSDK because a mfx session has at most one VPP process only

This fixes the broken pipelines below:

gst-launch-1.0 videotestsrc ! video/x-raw,format=I420 ! msdkh264enc ! \
msdkh264dec ! msdkvpp ! video/x-raw,format=YUY2 ! fakesink

gst-launch-1.0 videotestsrc ! msdkvpp ! video/x-raw,format=YUY2 ! \
msdkh264enc ! fakesink

msdkmjpegdec: support 422 output

MSDK supports JPEG YUY2 (422 chroma) output color
format. The color format of input bitstream is
described by JPEGChromaFormat and JPEGColorFormat
fields in the mfxInfoMFX structure which is filled
in by the MFXVideoDECODE_DecodeHeader function.

To obtain lossless decoded output from 422 encoded
JPEGs, we must set the output color format in the
FourCC and ChromaFormat fields in the mfxFrameInfo
structure to the appropriate values at post_configure
so that they are propagated through to the srcpad
caps accordingly.

msdkdec: add post_configure virtual method

A post_configure virtual method is added to allow
codec subclasses to adjust the initialized parameters
after MFXVideoDECODE_DecodeHeader is called from the
gstmsdkdec::gst_msdkdec_handle_frame function.

This is useful if codecs want to adjust the output
parameters based on the codec-specific decoding
options that are present in the mfxInfoMFX structure
after MFXVideoDECODE_DecodeHeader initializes them.

msdkvp9dec: add support for VP9 444

The output formats are VUYA for 8bit 444 and Y410 for 10bit 444.

msdkh265dec: add support for main-444-10/main-444-10-intra profile

The output format is Y410

msdk: return a right pointer for Y410 when mapping a frame

msdk: set right BitDepth and Shift for Y410 mfx frame

BitDepth is 10 and Shitf must be set to 0 when creating Y410 mfx
frame in MSDK

msdk: set parameters in mfxFrameData for a MFX_FOURCC_Y410 frame

msdk: map MFX_FOURCC_Y410 to VA_FOURCC_Y410

msdk: map GST_VIDEO_FORMAT_Y410 to VA_FOURCC_Y410

msdk: map GST_VIDEO_FORMAT_Y410 to MFX_FOURCC_Y410

msdkh265dec: add support for main-444 profile

The output format is VUYA

msdkh265dec: add support for main-422-10/main-422-10-intra 10bit

The ouput format is Y210

msdk: set right BitDepth and Shift for Y210 mfx frame

BitDepth is 10 and Shitf must be set to 1 when creating Y210 mfx
frame in MSDK

msdk: set parameters in mfxFrameData for a MFX_FOURCC_Y210 frame

msdk: map MFX_FOURCC_Y210 to VA_FOURCC_Y210

msdk: map GST_VIDEO_FORMAT_Y210 to VA_FOURCC_Y210

msdk: map GST_VIDEO_FORMAT_Y210 to MFX_FOURCC_Y210

msdkh265dec: add support for main-422-10/main-422-10-intra 8bit

The output format is YUY2

uvch264: Fix autotools build.

Add gstuvch264deviceprovider.c to the Makefile.am missed
in MR 387

rtp: Fix incompatible type build warning

Use GstURIType instead of guint

../subprojects/gst-plugins-bad/gst/rtp/gstrtpsink.c(575):
    warning C4133: '=': incompatible types ...

../subprojects/gst-plugins-bad/gst/rtp/gstrtpsrc.c(725):
    warning C4133: '=': incompatible types ...

dtlsagent: Clear the certificate upon finalize

Cleaning this up was likely just forgotten

dtlsdec: Avoid duplicate ref when passing certificate property

The agent itself will take a ref on the property setter, so we'll be
left with two references to the certificate object, when actually there
should be only one

meson: bluez: Early terminate configure on Windows

This plugin is for linux bluetooth stack. So the early termination can save
configure time on Windows (i.e., we can avoid glib subproject fallback)

wpe: Port for WPEWebKit 2.25.x

When WPEBackend-fdo >= 1.3.0 is detected, the threaded view now relies on the
wpe_fdo_egl_exported_image API instead of the EGLImageKHR-based API which is
going to be deprecated in 2.26. The GLib sources created by the view now use the
default priority as well, the custom priority is no longer required.

pcapparse: Fix handling of TCP payload length

The length of the  TCP payload is the IP plus TCP header length
subtracted from the IP datagram length specified in the IP header.
Prior to this, the size was calculated incorrectly, considering
all data after TCP header as a payload till the end of a packet.

Fixes #995

avwait: Make sure to never unref an input buffer we already unreffed before

avwait: Add support for setting an end running time

It was possible to set a start running time and start/end timecode
before, but not an end running time.

avwait: Correctly stop recording and signal recording stop on EOS

If recording is set to FALSE after the last audio or video buffer and
before the EOS event then recording stop is never signalled.

Similarly, we should signal recording stop once both audio and video are
EOS, regardless of the recording property, as there's nothing to be
recorded anymore.

vkswapper: support rescaling to the output size

vksink: Don't take vulkan buffer's as input

tests/vkcolorconvert: remove extra instance/device creation

It's unnecessary.

decklink: Correctly ensure >=16 byte alignment for the buffers we allocate

We'll ensure at least 64 byte alignment for AVX2 but 16 byte alignment
is what is required by the decklink SDK.

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

webrtc: Fix data-channel send-string doc

decklinkvideosrc: Notify about signal loss even when dropping no-signal frames

Otherwise the application has no way of knowing that signal loss
happened other than noticing a gap between actual frames.

vulkan: remove unused downsample AYUV shader

webrtcbin: fix DTLS when receivebin is set to DROP

Regression introduced by b4bdcf15b7237eb5c5943c4f746701a477333000

This commit prevents the handshake from reaching dtlsdec when
the receive state of the receive bin is set to DROP (for example
when transceivers are sendonly).

This preserves the intent of the commit, by blocking the bin
at its sinks until the receive state is no longer BLOCK, but
makes sure the handshake still goes through, by only dropping
data at the src pads, as was the case before.

vkcolorconvert: add support for RGB<->NV12

vkbuffermemory: report requested size of the memory

Rather than using Vulkan's much larger aligned sizes. Fixes multi-planer
video with the GstVideoFrame API.

vulkancolorconvert: support RGB <-> AYUV/YUY2/UYVY

vktrash: add mini_object_unref destroy function

vkfullscreenrender: create descriptor sets later

The desciptor sets may be dependant on the caps

vulkan/shaders: change glslc compilation args based on configurations

Add depfile support so that modifying an #included glsl snippet
rebuilds all the dependant shaders.

vulkan: add a color conversion element

Currently converts between all 4-component RGBA/RGBx formats.

vulkan: add some information on vulkan formats

vkupload: Also implement copying non vulkan memory into vulkan buffers

The only way we can upload things is through our memory so any
non-vulkan memory that appears must be copied into our memory.

vulkan: add download element

Currently only downloads images into a host-visible buffer and
synchronises immediately.

vulkan/identity: Split out most rendering code to a base class

A simple base class that renders a 2d fullscreen quad parallel to the
screen surface inside the view frustum.

vkupload: fix a structure sType

vulkan: ensure initialization of a couple of debug categories

Needed when some of the context querying functions can be called before
an instance has been created.

vksink: Retrieve vulkan queue earlier

Allows using the swapper's queue over upstream's queue.  The swapper
will check for the necessary presentation support that upstream may not
consider.

mpegvideoparse: Pass through interlace-mode field from upstream if available

We generally always prefer the information from upstream for other
metadata (pixel-aspect-ration, etc.) and should also do so here.

Other parsers (h264parse) already do the same.

zbar: Include running-time, stream-time and duration in the messages

The timestamp/PTS alone is meaningless without the segment and usually
applications care about the running-time or stream-time.

This also keeps the messages in sync with the spectrum and level
elements.

tests: hls: Add a test case for EXT-X-MAP tag

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

tests: Enable hls m3u8 unit test with meson build

hlsdemux: Set fragment header uri if exists

To allow downloading fragment hearder, set its uri if there is
available "Media Initialization" parsed from EXT-X-MAP tag

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

hls: m3u8: Parsing EXT-X-MAP tag to store initialization data

EXT-X-MAP tag informs media initialization data,
such as moov box in ISOBMFF case and PAT/PMT for MPEG TS stream.

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

hlsdemux: Do not clear/advance fragment by finished header downloading

Header data must be forwarded to downstream, but if demux does not finish
to finding type (e.g., ts, mp4 and etc), this header data can be cleared
by _stream_clear_pending_data(). Moreover, although demux finish downloading
header data, still it has fragment date to be downloaded, fragment sequence
shouldn't be advanced yet at that moment.

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

tests: insertbin: Don't use duplicated variable name

../subprojects/gst-plugins-bad/tests/check/libs/insertbin.c(46): warning C4273:
  'mutex': ...

The "mutex" was declared in gstcheck.h already

applemedia: add the '-fobjc-arc' for darwin/ios

We use ARC so we need to signal that to the compiler.

uvch264: Implement device provider

uvch264: Factor out checking if v4l2device is uvc compatible

h265parse: update parser state and header flag when using fallback sps

When sps parsing fails we use a fallback sps from the caps, since we
have got an sps we need to update parser state and header as in the case the
sps was successfully parsed

h264parse: update parser state and header flag when using fallback sps

When sps parsing fails we use a fallback sps from the caps, since we
have got an sps we need to update parser state and header as in the case the
sps was successfully parsed

Closes #503

h264parse: Post a WARNING when data is broken

h265parse: Add more string representations of extension profiles

h265parser: Add more profiles to known type

"High Throughput", "Multiview", "Scalable", "3D", "Screen Content Coding",
and "Scalable format range extensions" profiles can be supported
via h265parser APIs now.

h265parse: Update framerate when we found vps_timing_info

The timing_info was described at vps or vui parameter.
So we can update the framerate field of GstCaps when we could
parse vps_timing_info parameters.

h265parser: Use vps_timing_info when not present in vui

The same timing_info will be present at vps or vui.
When the timeing_info is present in the VPS, vui_timing_info
, when present, shall be equal to vps_timing_info, and when
not present, is inferred to be equal to vps_timing_info.

vulkan: Add support WIN32 for Windows

It's almost a fork of glwindow_win32 implementation.
To build on Windows, Vulkan SDK (at https://vulkan.lunarg.com/sdk/home)
and VK_SDK_PATH environment are required. Note that VK_SDK_PATH environment
setting is a part of the SDK installation.

avdtpsrc: Honour initial transport volume setting before connection

We make the binding go from the avdtpsrc to the transport, so that any
initial setting before a connection made is used.

uvch264src: Make sure we set our segment

We were not setting self->segment and we are using it
when notifying downstream that we handled a REQUEST_KEY_UNIT
event, leading to all sort of criticals.

h265parse: Don't miss constraint indicator flags in codec data

Set more unhandled flags to general_constraint_indicator_flags field.
The field is required for building "Codecs" parameter as defined
ISO/IEC 14496-15 Annex E. The resulting "Codecs" string might be used
in various places (e.g., HLS/DASH manifest, browser, player, etc)

rtpmanagerbad: fix the plugin registration

After compilation, the compiled library needs to be added to the list
of plugin libraries.
.
Also, fix for static builds

Remove VDPAU plugin

It's been replaced by NVENC/NVDEC and even NVIDIA doesn't
support VDPAU any longer and hasn't for quite some time.

The plugin has been unmaintained and unsupported for a very
long time, and given the track record over the last 10 years
it seems highly unlikely anyone is going to make it work well,
not to mention adding plumbing for proper zero-copy or
gst-gl integration.

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

autotools: fix distcheck

autotools: remove gst/rtp/ from cruft dir list

rtp: fix autotools build some more

wpe: Fix build with -Werror enabled

Including gl.h from WPEThreadedView.h leads to GST_LEVEL_DEFAULT detected as
redefined. The proposed fix is to include config.h from the CPP implementation
file and disable gl.h inclusion in the header, by using forward declarations.

avwait: Allow start and end timecode to be set back to NULL

And check everywhere if they're NULL before accessing them.

Use G_DEFINE_AUTOPTR_CLEANUP_FUNC unconditionally

Since we started depending on GLib 2.44, we can be sure this macro is
defined (it will be a no-op on compilers that don't support it).