And let it rety twice.

Fixes gstreamer/gst-plugins-good#717

Part-of: <gstreamer/gst-plugins-good!601>

Nicolas Dufresne authored 4 years ago and GStreamer Marge Bot committed 4 years ago

The profiles and levels were applied to the common caps instead of the copy.
That had the side effect of setting profiles/level from one CODEC onto
another. Leaving to encoder not being registered or not-negotiated errors.

Part-of: <!599>

Nicolas Dufresne authored 4 years ago and GStreamer Marge Bot committed 4 years ago

The levels and profiles probe function returned a dynamically allocated GValue
that was leaked. Simplify this by using a stack allocated GValue and a boolean
return value.

Part-of: <!599>

Nicolas Dufresne authored 4 years ago and GStreamer Marge Bot committed 4 years ago

There is only one user of that function and the split only increase
complexicity.

Part-of: <!599>

Nicolas Dufresne authored 4 years ago and GStreamer Marge Bot committed 4 years ago

With older kernel, older driver or just broken drivers, the sequence number
may not be increasing. This simply ignore the sequence in this case. This
would otherwise miss-leading large amount of lost frame being reported.

Fixes #729

Part-of: <!598>

Matthew Waters authored 4 years ago and GStreamer Marge Bot committed 4 years ago

Part-of: <gstreamer/gst-plugins-good!595>

Sebastian Dröge authored 4 years ago and GStreamer Marge Bot committed 4 years ago

Same mechanism and threshold as in other demuxers.

Part-of: <!597>

Sebastian Dröge authored 4 years ago and GStreamer Marge Bot committed 4 years ago

Part-of: <!597>

Edward Hervey authored 4 years ago and Sebastian Dröge committed 4 years ago

If upstream (such as queue2 in urisourcebin) asks for our bitrate, check if we
have stored audio/video bitrates, and use them.

Part-of: <!596>

Edward Hervey authored 4 years ago and Edward Hervey committed 4 years ago

g_utf8_validate() errors out on empty string. But empty strings are valid,
so only check if they're not

Part-of: <!596>

Edward Hervey authored 4 years ago and Edward Hervey committed 4 years ago

A demuxer can accept any caps matching its sinkpad template caps

Part-of: <!596>

46bfb7d2 fixed a format warning without checking if it actually compiled.
toUtf8() returns QByteArray so we need to assign it to a temporary variable to be able to get the raw string data from it.

Part-of: <!593>

Part-of: <!592>

This is needed for cross-compiling without a build machine compiler
available. The option was added in 0.54, but we only need this in
Cerbero and it doesn't break older versions so it should be ok.

Part-of: <gstreamer/gst-plugins-good!589>

It is now controlled by the qt5 and/or taglib options. We won't
silently fail to build taglib now.

Part-of: <!587>

Also rename from build_ to have_, which is more accurate.

Part-of: <!587>

Stricter and simpler. For example, now we properly error out when
gstreamer-gl-1.0 was not found when the qt5 plugin is enabled or when
a C++ compiler is not enabled.

Part-of: <!587>

Separate out explicit NULL checks for fields we depend on so
that coverity can hopefully verify dependencies better.

Part-of: <!585>

Don't fall back on the default interpolate_scanline function, which
blindly tries to copy from the next field, which can be NULL in
mixed progressive/interlaced streams

Part-of: <!585>

Vivia Nikolaidou authored 4 years ago and GStreamer Marge Bot committed 4 years ago

Part-of: <!444>

Vivia Nikolaidou authored 4 years ago and GStreamer Marge Bot committed 4 years ago

In some algorithms (like yadif), the Y plane has to be handled different
than the UV plane. Therefore, the planar_y functions are now called for
the Y plane, and the nv12/nv21 functions are handling only the UV/VU
planes respectively.

Part-of: <!444>

Jan Schmidt authored 5 years ago and GStreamer Marge Bot committed 4 years ago

Import the YADIF deinterlacer from ffmpeg and modify
it to match the simple deinterlace scanlines structure.

Part-of: <!444>

Jan Schmidt authored 5 years ago and GStreamer Marge Bot committed 4 years ago

Add an extra field to the simple deinterlace implementation,
so that methods can potentially use 5 fields - the current
field, and 2 before and 2 after.

Part-of: <!444>

Switching the deinterlacing mode on-the-fly from disabled to
auto used to work, but was broken by commit #1f21747c some
years ago.

Force re-negotiation with downstream when the mode or
fields properties are changed, otherwise deinterlace
never switches out of the passthrough mode.

Part-of: <!584>

nian.yan authored 4 years ago and GStreamer Marge Bot committed 4 years ago

GstVideoEncoder takes care of the Meta copy, so there is no need in
jpegenc

Fixes http://gstreamer-devel.966125.n4.nabble.com/jpegenc-copy-GstMeta-twice-tt4693981.html

Part-of: <!576>

Sebastian Dröge authored 4 years ago and GStreamer Marge Bot committed 4 years ago

First of all get rid of the atomic seeking boolean, which was only ever
set and never read. Replace it with a flushing boolean that is used in
the loop function to distinguish no buffer because of flushing and no
buffer because of an error as otherwise we could end up in a
GST_FLOW_ERROR case during flushing.

Also only reset the state of imagefreeze in flush-stop when all
processing is stopped instead of doing it as part of flush-start.

And last, get a reference to the imagefreeze buffer in the loop function
in the very beginning and work from that as otherwise it could in theory
be replaced or set to NULL in the meantime as we release and re-take the
mutex a couple of times during the loop function.

Part-of: <gstreamer/gst-plugins-good!580>

Edward Hervey authored 4 years ago and GStreamer Marge Bot committed 4 years ago

an unsigned int is always positive.

CID #206207
CID #206208
CID #206209
CID #206210
CID #206211

Part-of: <!583>

Edward Hervey authored 4 years ago and Edward Hervey committed 4 years ago

stream->name was being freed (without being NULL-ed) before we were certain it
would be set again.

CID #1456071

Part-of: <gstreamer/gst-plugins-good!582>

Edward Hervey authored 4 years ago and Edward Hervey committed 4 years ago

CID #1455494

Part-of: <!581>

Edward Hervey authored 4 years ago and Edward Hervey committed 4 years ago

Previously this would end up in a refcounting loop of hell.

Part-of: <!578>

Backwards timestamps confuse librtmp, even if they're only backwards
relative to the other stream. If the timestamp of a stream is going
backwards related to the other stream, this property allows the muxer to
skip a few buffers until it reaches the timestamp of the other stream.

Part-of: <!572>

Allows us to request pads after writing header for streamable flv's.

For non-streamable it doesn't make sense to request a new pad after
writing the header, because the headers have been written already and we
can't add the new stream. But for streamable, any clients that connect
after the new pad has been added will be able to see both streams.

Part-of: <!572>

Removes this warning from Qt:

QGLXContext: Multiple configs for FBConfig ID -1
QSGContext::initialize: depth buffer support missing, expect rendering errors

Part-of: <!575>

As is required when creating a QWindow instance set out in the Qt
documentation.

Part-of: <gstreamer/gst-plugins-good!575>

Part-of: <!574>

Sebastian Dröge authored 4 years ago and Nicolas Dufresne committed 4 years ago

As we override the GLib item with our own structure, we cannot use any
function from GList or GQueue that would try to free the RTPJitterBufferItem.
In this patch, we move away from g_queue_new() which forces using
g_queue_free(). This this function could use g_slice_free() if there is any items
left in the queue. Passing the wrong size to GSLice may cause data corruption
and crash.

A better approach would be to use a proper intrusive linked list
implementation but that's left as an exercise for the next person
running into crashes caused by this.

Be ware that this regression was introduced 6 years ago in the following
commit [0], the call to flush() looked useless, as there was a g_queue_free()
afterward.

Signed-off-by: Nicolas Dufresne <nicolas.dufresne@collabora.com>

[0] 479c7642

Part-of: <!573>

... and split test cases to run tests in parallel

The calculated threshold for timecode might be varying depending on
"max-size-timecode" and framerate.
For instance, with framerate 29.97 (30000/1001) and
"max-size-timecode=00:02:00;02", every fragment will have identical
number of frames 3598. However, when "max-size-timecode=00:02:00;00",
calculated next keyframe via gst_video_time_code_add_interval()
can be different per fragment, but this is the nature of timecode.
To compensate such timecode drift, we should keep track of expected
timecode of next fragment based on observed timecode.

In case we cannot rely on max-size-timecode for split decision,
post error instead of crashing

The problem was this:

Due to the highly irregular arrival of RTX-packet the max-misorder variable
could be pushed very low. (-10).

If you then at some point get a big in the sequence-numbers (62 in the
test) you end up sending RTX-requests for some of those packets, and then
if the sender answers those requests, you are going to get a bunch of
RTX-packets arriving. (-13 and then 5 more packets in the test)

Now, if max-misorder is pushed very low at this point, these RTX-packets
will trigger the handle_big_gap_buffer() logic, and because they arriving
so neatly in order, (as they would, since they have been requested like
that), the gst_rtp_jitter_buffer_reset() will be called, and two things
will happen:
1. priv->next_seqnum will be set to the first RTX packet
2. the 5 RTX-packet will be pushed into the chain() function

However, at this point, these RTX-packets are no longer valid, the
jitterbuffer has already pushed lost-events for these, so they will now
be dropped on the floor, and never make it to the waiting loop-function.

And, since we now have a priv->next_seqnum that will never arrive
in the loop-function, the jitterbuffer is now stalled forever, and will
not push out another buffer.

The proposed fixes:
1. Don't use RTX in calculation of the packet-rate.
2. Don't use RTX in large-gap logic, as they are likely to be dropped.