GitLab

Fixes #196.

Otherwise the library user will have to guess and find out the limit the hard way.

Signed-off-by: James Almer <jamrial@gmail.com>

Also remove redundant entries from Dav1dPictureParameters, and move
documentation of these fields into Dav1dFrame/SequenceHeader instead.

The old flushing logic would simply leave frame threads (and tile
threads) running without caring how much latency that might impose
in the post-seek time-to-first-frame. This commit adds a 'flush'
state that will abort all running frame/tile threads from decoding
their current frame, as well as dispose of all frames in the output
queue.

Then, we use dav1d_flush() in dav1d_close() to abort running threads
on exit, instead of signaling their respective dependents to prevent
deadlocks. The advantage of this approach is that we don't signal on
objects we don't have ownership over, and thus this should prevent
race conditions where the owning thread could dispose of the object
just as we're signaling it, which I believe is what causes #193.

Fixes #188.

Refs #188, adds a dav1d CLI option. Defaults to 1 to allow adjustment of the
tests of scalable bitstreams.

Refs #188, adds a corrosponding dav1d CLI option and skips not required
temporal and spatial layers based on the selected operating point.

Also mark all planes broken after tile error.
Fixes an use-of-uninitialized-value in apply_to_row_y() with
clusterfuzz-testcase-minimized-dav1d_fuzzer_mt-5652400153559040. Credits
to oss-fuzz.

Also ensure we apply film-grain to delayed pictures.

Fixes a deadlock on teardown with
clusterfuzz-testcase-minimized-dav1d_fuzzer_mt-5636065151418368. Credits
to oss-fuzz.

Niklas Haas authored Nov 13, 2018 and Ronald S. Bultje committed Nov 19, 2018

This is using a slightly adapted version of my GPU-based algorithm. The
major difference to the algorithm suggested by the spec (and implemented
in libaom) is that instead of using a line buffer to hold the previous
row's film grain blocks, we compute each row/block fully independently.

This opens up the door to exploit parallelism in the future, since we
don't have any left->right or top->down dependency except for the PRNG
state. (Which we could pre-compute for a massively parallel / GPU
implementation)

That being said, it's probably somewhat slower than using a line buffer
for the serial / single CPU case, although most likely not by much
(since the areas with the most redundant work get progressively smaller,
down to a single 2x2 square for the worst case).

Fixes #172.

The race is exposed by not draining the decoder correctly after
02606969 (decoupled decoding api). Fixes a memleak with
clusterfuzz-testcase-minimized-dav1d_fuzzer_mt-5728508249112576. Credits
to oss-fuzz.

Fixes #121.

To account for overwrites of up to 31 pixels and widths of up to
128+7=135 pixels, yet still be aligned to 32.

Signed-off-by: James Almer <jamrial@gmail.com>

Fix 122.

Janne Grunau authored Oct 17, 2018 and Ronald S. Bultje committed Oct 18, 2018

Fixes #66.

Janne Grunau authored Oct 13, 2018 and Jean-Baptiste Kempf committed Oct 13, 2018

Fixes emmory leak with asan seen with 'dav1d --tilethreads 2 ...'

skal authored Oct 02, 2018 and Ronald S. Bultje committed Oct 05, 2018

"comparison between signed and unsigned integer expressions"

Henrik Gramner authored Oct 02, 2018 and Jean-Baptiste Kempf committed Oct 03, 2018

Perform the library initialization as part of dav1d_open() instead.

Signed-off-by: Derek Buitenhuis <derek.buitenhuis@gmail.com>

Signed-off-by: Derek Buitenhuis <derek.buitenhuis@gmail.com>

This is, de facto, an unsigned counter and this fixes a warning

Marvin Scholz authored Oct 02, 2018 and Jean-Baptiste Kempf committed Oct 02, 2018

Previously it was assumed version.h is in include, which is actually
not always the case, for example with --layout flat when configuring.

This makes the function thread safe, to call, for example,
from multiple transient dependecies or threads.
Signed-off-by: Derek Buitenhuis <derek.buitenhuis@gmail.com>

These were all allocated with aligned malloc().

This prevents leaving the caller with a dangling pointer.