vc1: port to common GstVaapiDpb interface.

Use GstVaapiDpb interface instead of maintaining our own prev and next
picture pointers. While doing so, try to derive a sensible POC value.

Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>

vc1: fix decode_sequence_end() to return success, not EOS.

decoder: simplify gst_vaapi_decoder_get_surface().

Avoid extraenous branches, i.e. immediately return with success once we
have a decoded frame available.

decoder: optimize and clean decode_step() up.

Avoid usage of goto. Simplify decode_step() process to first accumulate all
pending buffers into the GstAdapter, and then parse and decode units from
that input adapter. Stop the process once a frame is fully decoded or an
error occurred.

display: move "vaapi" debug init to libgstvaapi_init_once().

display: dump gstreamer-vaapi version for debugging purposes.

tests: simple-decoder: fix build with built-in videoutils.

Fix build with built-in videoutils, i.e. when system GStreamer installation
does not know about GstVideoDecoder API.

tests: simple-decoder: flush decoded frames at EOS.

Flush the remaining decoded frames when an end-of-stream is reached.

tests: simple-decoder: drop use of GstVaapiVideoMeta.

Don't use GstVaapiVideoMeta since that object is not guaranteed to live
in libgstvaapi forever. Rather, that'd move to plugin elements at some
point.

tests: simple-decoder: add benchmark mode.

Add --benchmark option to enable benchmark mode where rendering is not
synchronized with presentation timestamps of the decoded surfaces.

tests: simple-decoder: honour framerate from the bitstream.

Try to honour the framerate from the bitstream, or cap the playback to
60 fps by default.

tests: simple-decoder: set window size to the surface dimensions.

Set the window size to the decoded surface dimensions, if the user has
not requested the application to run in full-screen mode. Besides, no
effort is made to preserve aspect ratio or to center the video within
the mapped window.

tests: add simple decoder application.

Add simple decoder application to show off decoding capabilities from
raw bitstreams, for debugging or performance evaluation purposes.

tests: add codec helper utils.

Add helper functions to determine the codec type from a specific file
or utility functions to convert from codec type to GstCaps or from
codec name to codec type.

tests: allow fullscreen mode.

Add new --fullscreen|-f option to create new windows in fullscreen mode.

h264: implement GstVaapiDecoder::flush() as a DPB flush.

h264: handle end-of-stream NALU.

Handle <end-of-stream> NAL unit to actually flush any pending picture
from the DPB.

vaapidecode: handle EOS events.

Flush all decoded frames to downstream when EOS is received. This is
performed by implementing GstVideoDecoder::finish() hook.

vaapidecode: split gvd_handle_frame() into decode/push frames.

Split GstVideoDecoder::handle_frame() implementation into two functions:
(i) one for decoding the provided GstVideoCodecFrame and (ii) another one
for purging all decoded frames and submit them downstream.

decoder: add GstVaapiDecoder::flush() hook.

decoder: fix check for end-of-stream in raw API mode.

Make sure to immediately return GST_VAAPI_DECODER_STATUS_END_OF_STREAM
if the end-of-stream was already reached at the previous iteration.

decoder: make decode_step() return once the frame is decoded.

Make sure we always have a free surface left to use for decoding the
current frame. This means that decode_step() has to return once a frame
gets decoded. If the current adapter contains more buffers with valid
frames, they will get parsed and decoded on subsequent iterations.

codecparsers: update to gst-vaapi-branch commit b47983a.

8840c2d h264: zero-initialize SPS VUI parameters

Bump version for development.

0.5.0.

docs: expose new interfaces.

NEWS: updates.

dpb: cosmetics (clean-ups).

dpb: port to GstVaapiMiniObject.

dpb: drop GstVaapiDpb2 interface, keep only one class.

Keep only one DPB interface and rename gst_vaapi_dpb2_get_references()
to gst_vaapi_dpb_get_neighbours() so that to retrieve pictures in DPB
around the specified picture POC.

dpb: rename GstVaapiDpbMpeg2 to GstVaapiDpb2.

Move GstVaapiDpbMpeg2 API to a more generic version that could also be
useful to other decoders that require 2 reference pictures, e.g. VC-1.

Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>

Bump version for pre-release.

NEWS: updates.

overlay: fix build without advanced GstVideoOverlayFormatFlags.

Check for global-alpha support in GstVideoOverlayComposition API.

Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>

tests: add support for global-alpha subpictures.

Add --global-alpha option to test-subpicture.

tests: use GstVideoOverlayComposition API for subpicture test.

tests: use common decoder helpers for subpicture test.

Use common decoder helpers for subpicture test, thus allowing to decode
sample images in an alternate format.

tests: add decoder helpers.

overlay: fix ordering of composition layers.

Make sure to maintain the association order of composition layers when
GstVideoOverlayRectangle objects are kept around (cached).

overlay: fix support for global-alpha.

Fix support for global-alpha subpictures. The previous changes brought
the ability to check for GstVideoOverlayRectangle changes by comparing
the underlying pixel buffer pointers. If sequence number and pixel data
did not change, then this is an indication that only the global-alpha
value changed. Now, try to update the underlying VA subpicture global-alpha
value.

Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>

overlay: detect render-rect changes.

Don't re-upload VA subpicture if only the render rectangle changed.
Rather deassociate the subpicture and re-associate it with the new
render rectangle.

overlay: fix check for pixels buffer change.

A GstVideoOverlayRectangle is created whenever the underlying pixels data
change. However, when global-alpha is supported, it is possible to re-use
the same GstVideoOverlayRectangle but with a change to the global-alpha
value. This process causes a change of sequence number, so we can no longer
check for that.

Still, if sequence numbers did not change, then there was no change in
global-alpha either. So, we need a way to compare the underlying GstBuffer
pointers. There is no API to retrieve the original pixels buffer from
a GstVideoOverlayRectangle. So, we use the following heuristics:

1. Use gst_video_overlay_rectangle_get_pixels_unscaled_argb() with the same
   format flags from which the GstVideoOverlayRectangle was created. This
   will work if there was no prior consumer of the GstVideoOverlayRectangle
   with alternate (non-"native") format flags.

2. In overlay_rectangle_has_changed_pixels(), we have to use the same
   gst_video_overlay_rectangle_get_pixels_unscaled_argb() function but
   with flags that match the subpicture. This is needed to cope with
   platforms that don't support global-alpha in HW, so the gst-video
   layer takes care of that and fixes this up with a possibly new
   GstBuffer, and hence pixels data (or) in-place by caching the current
   global-alpha value applied. So we have to determine the rectangle
   was previously used, based on what previous flags were used to
   retrieve the ARGB pixels buffer.

overlay: optimize cache at the GstVideoOverlayRectangle level.

We previously assumed that an overlay composition changed if the number
of overlay rectangles in there actually changed, or that the rectangle
was updated, and thus its seqnum was also updated.

Now, we can cope with cases where the GstVideoOverlayComposition grew
by one or a few more overlay rectangles, and the initial overlay rectangles
are kept as is.

overlay: simplify caching of GstVideoOverlayComposition objects.

Create the GPtrArray once in the _init() function and destroy it only
in the _finalize() function. Then use overlay_clear() to remove all
subpicture associations for intermediate updates, don't recreate the
GPtrArray.

Make GstVaapiOverlayRectangle a reference counted object. Also make
sure that overlay_rectangle_new() actually creates and associates the
VA subpicture.

overlay: add support for global-alpha.

Handle global-alpha from GstVideoOverlayComposition API. Likewise,
the same code path could also work for premultiplied-alpha but this
was not tested.

Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>

subpicture: add support for global-alpha.

Add the necessary helpers in GstVaapiDisplay to determine whether subpictures
with global alpha are supported or not. Also add accessors in GstVaapiSubpicture
to address this feature.

Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>

subpicture: add premultiplied-alpha and global-alpha feature flags.

Add premultiplied-alpha and global-alpha feature flags, along with converters
between VA-API and gstreamer-vaapi definitions. Another round of helpers is
also necessary for GstVideoOverlayComposition API.

display: allow image/subpicture formats with additional flags.

Introduce new GstVaapiFormatInfo to store the actual GstVaapiImageFormat
and any additional flags needed. Currently, all flags are set to zero.

libs: fix build of submodule wrappers.

Make sure to build codecparsers/ and videoutils/ sources against the
newly generated headers when out-of-source builds are used.

configure: fix checks for packages installed in non-standard roots.

decoder: fix mini object implementation on 64-bit systems.

Use GPOINTER_TO_SIZE() instead of GPOINTER_TO_UINT() while manipulating
pointers. The latter is meant to be 32-bit only, not uintptr_t like size.
Only a gsize can hold all bits of a pointer.

Thanks to Ouping Zhang for spotting this error.

mpeg2: optimize scan for the end of the frame.

Heuristic: if the second start-code is available, check whether that
one marks the start of a new frame because e.g. this is a sequence
or picture header. This doesn't save much, since we already cache the
results.

mpeg2: optimize scan for start codes.

Accelerate scan for start codes by skipping up to 3 bytes per iteration.
A start code prefix is defined by the following bytes: 00 00 01. Thus,
for any group of 3 bytes (xx yy zz), we have the following possible cases:

  1. If zz != 1, this cannot be a start code, then skip 3 bytes;
  2. If yy != 0, this cannot be a start code, then skip 2 bytes;
  3. If xx != 0 or zz != 1, this cannot be a start code, then skip 1 byte;
  4. xx == 00, yy == 00, zz == 1, we have match!

This algorithm requires to peek bytes from the adapter. This increases the
amount of bytes copied to a temporary buffer, but this process is much faster
than scanning for all the bytes and using shift/masks. So, overall, this is
a win.

mpeg2: drop useless gst_adapter_peek().

Drop useless gst_adapter_peek() since the returned buffer was not used
and this could incur superfluous memcpy().

mpeg2: cosmetics: move parse_slice() down.

mpeg2: avoid too many allocations of parser info objects.

Move parsing back to decoding step, but keep functions separate for now.
This is needed for future optimizations that may introduce some meta data
for parsed info attached to codec frames.

decoder: decoder units are no longer dynamically allocated objects.

decoder: optimize pre-allocation of decoder units.

Optimize pre-allocation of decoder units, thus avoiding un-necessary
memory reallocations. The heuristic used is that we could have around
one slice unit per macroblock line.

decoder: use an array of units instead of a single-linked list.

Use a GArray to hold decoder units in a frame, instead of a single-linked
list. This makes 'append' calls faster, but not that much. At least, this
makes things clearer.

decoder: refactor decoder unit API.

Allocate decoder unit earlier in the main parse() function and don't
delegate this task to derived classes. The ultimate purpose is to get
rid of dynamic allocation of decoder units.

mpeg2: introduce parser info instead of MPEG-2 specific decoder unit.

Use a new GstVaapiParserInfoMpeg2 data structure instead of deriving
from GstVaapiDecoderUnit for MPEG-2 specific parser information.

h264: introduce parser info instead of H.264 specific decoder unit.

Use a new GstVaapiParserInfoH264 data structure instead of deriving
from GstVaapiDecoderUnit for H.264 specific parser information.

h264: set default values for some header fields.

The SPS, PPS and slice headers are not fully zero-initialized in the
codecparsers/ library. Rather, the standard upstream behaviour is to
initialize only certain syntax elements with some inferred values if
they are not present in the bitstream.

At the gstreamer-vaapi decoder level, we need to further initialize
certain syntax elements with some sensible default values so that to
not complicate VA drivers that just pass those verbatim to the HW,
and also avoid an memset() of the whole decoder unit.

Signed-off-by: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>

codecparsers: update to gst-vaapi-rebased commit b47983a.

b47983a h264: add inferred value for slice_beta_offset_div2

plugins: cope with new GstVaapiVideoMeta API.

Update plugin elements with the new GstVaapiVideoMeta API.

This also fixes support for subpictures/overlay because GstVideoDecoder
generates a sub-buffer from the GstVaapiVideoBuffer. So, that sub-buffer
is marked as read-only. However, when comes in the textoverlay element
for example, it checks whether the input buffer is writable. Since that
buffer read-only, then a new GstBuffer is created. Since gst_buffer_copy()
does not preserve the parent field, the generated buffer in textoverlay
is not exploitable because we lost all VA specific information.

Now, with GstVaapiVideoMeta information attached to a standard GstBuffer,
all information are preserved through gst_buffer_copy() since the latter
does copy metadata (qdata in this case).

videobuffer: wrap video meta into a surface buffer.

Make GstVaapiVideoBuffer a simple wrapper for video meta. This buffer is
no longer necessary but for compatibility with GStreamer 0.10 APIs or users
expecting a GstSurfaceBuffer like Clutter.

videobuffer: add video meta information.

Add new GstVaapiVideoMeta object that holds all information needed to
convey gst-vaapi specific data as a GstBuffer.

vaapidecode: fix calculation of the time-out value.

Fix calculation of the time-out value for cases where no VA surface is
available for decoding. In this case, we need to wait until downstream
sink consumed at least one surface. The time-out was miscalculated as
it was always set to <current-time> + one second, which is not suitable
for streams with larger gaps.

decoder: always use the calculated presentation timestamp.

Use PTS value computed by the decoder, which could also be derived from
the GstVideoCodecFrame PTS. This makes it possible to fix up the PTS if
the original one was miscomputed or only represented a DTS instead.

h264: don't create sub-buffer for slice data.

decoder: create new context when encoded resolution changes.

Create a new VA context if the encoded surface size changes because we
need to keep the underlying surface pool until the last one was released.
Otherwise, either of the following cases could have happened: (i) release
a VA surface to an inexistent pool, or (ii) release VA surface to an
existing surface pool, but with different size.

mpeg2: don't create sub-buffer for slice data.

Avoid creating a GstBuffer for slice data. Rather, directly use the codec
frame input buffer data. This is possible because the codec frame is valid
until end_frame() where we submit the VA buffers for decoding. Anyway, the
slice data buffer is copied into the VA buffer when it is created.

mpeg2: minor clean-ups.

Drop explicit initialization of most fields that are implicitly set to
zero. Remove some useless checks for NULL pointers.

mpeg2: optimize scan for the second start code.

Optimize scan for the second start code, on the next parse() call so that
to avoid scanning again earlier bytes where we didn't find any start code.

mpeg2: use sequence_display_extension() to compute PAR.

Also compute pixel-aspect-ratio from sequence_display_extension(),
should it exist in the bitstream.

mpeg2: handle sequence_display_extension().

mpeg2: implement {start,end}_frame() hooks.

Implement GstVaapiDecoder.start_frame() and end_frame() semantics so
that to create new VA context earlier and submit VA pictures to the
HW for decoding as soon as possible. i.e. don't wait for the next
frame to start decoding the previous one.

mpeg2: parse slice() header earlier.

Parse slice() header and first macroblock position earlier in _parse()
function instead of waiting for the _decode() stage. This doesn't change
anything but readability.

mpeg2: add codec specific decoder unit.

Introduce new GstVaapiDecoderUnitMpeg2 object, which holds the standard
GstMpegVideoPacket and additional parsed header info. Besides, we now
parse as early as in the _parse() function so that to avoid un-necessary
creation of sub-buffers in _decode() for video packets that are not slices.

decoder: introduce lists of units to decode before/after frame.

Theory of operations: all units marked as "slice" are moved to the "units"
list. Since this list only contains slice data units, the prev_slice pointer
was removed. Besides, we now maintain two extra lists of units to be decoded
before or after slice data units.

In particular, all units in the "pre_units" list will be decoded before
GstVaapiDecoder::start_frame() is called and units in the "post_units"
list will be decoded after GstVaapiDecoder::end_frame() is called.

decoder: drop useless checks for codec objects.

Codec objects are used internally only and they are bound to be created
with a valid GstVaapiDecoder object.

vaapidecode: use GST_ERROR to print error messages.

vaapidecode: avoid double release of frame on error.

Don't call gst_video_decoder_drop_frame() if gst_video_decoder_finish_frame()
was already called before and it returned an error. In that case, we were
releasing the frame again, thus leading to a "double-free" condition.

Add videoutils submodule for GstVideoDecoder APIs.

configure: check for GstVideoDecoder API.

GstVideoDecoder API is part of an unreleased GStreamer 0.10 stack. In particular,
this is only available in git 0.10 branch or GStreamer >= 1.0 stack. Interested
parties may either use upstream git 0.10 branch or backport the necessary support
for GstVideoDecoder API, thus including helper tools like GstVideoCodecFrame et al.

docs: remove obsolete gst_vaapi_surface_proxy_get_type().

GstVaapiSurfaceProxy is no longer based on the GType system.

docs: fix entries for GstVaapiSurfaceProxy.

NEWS: updates.

Bump library major version.

Increase library major so that to cope with API/ABI incompatible changes
since 0.4.x series and avoid user issues.

surfaceproxy: minor clean-ups.

surfaceproxy: drop accessors to obsolete attributes.

Make GstVaapiSurfaceProxy only a thin wrapper around a VA context and a
VA surface. i.e. drop any other attribute like timestamp, duration,
interlaced or top-field-first.

decoder: maintain decoded frames as GstVideoCodecFrame objects.

Maintain decoded surfaces as GstVideoCodecFrame objects instead of
GstVaapiSurfaceProxy objects. The latter will tend to be reduced to
the strict minimum: a context and a surface.

vaapidecode: output all decoded frames as soon as possible.

Make sure to push all decoded frames downstream as soon as possible.
This makes sure we don't need to wait for a new frame to be ready to
be decoded before receiving new decoded frames.

This also separates the decode process and the output process. The latter
could be moved to a specific GstTask later on.

decoder: add gst_vaapi_decoder_get_frame() API.

Add new gst_vaapi_decoder_get_frame() function meant to be used with
gst_vaapi_decoder_decode(). The purpose is to return the next decoded
frame as a GstVideoCodecFrame and the associated GstVaapiSurfaceProxy
as the user-data object.

vaapipostproc: use GstBuffer flags for TFF.

Determine whether the buffer represents the top-field only by checking for
the GST_VIDEO_BUFFER_TFF flag instead of relying on the GstVaapiSurfaceProxy
flag. Also trust "interlaced" caps to determine whether the input frame
is interleaved or not.

vaapipostproc: handle video sub-buffers.

Intermediate elements may produce a sub-buffer from a valid GstVaapiVideoBuffer
for non raw YUV cases. Make sure vaapipostproc now understands those buffers.

h264: optimize initialization process of decoder units.

Decoder units were zero-initialized, including the SPS/PPS/slice headers.
The latter don't require zero-initialization since the codecparsers/ lib
will do so for key variables already. This is not a great value per se but
at least it makes it possible to check whether the default initialization
decisions made in the codecparsers/ lib were right or not.

This can be reverted if this exposes too many issues.

h264: minor clean-ups.

Drop explicit initialization of most fields that are implicitly set to
zero. Drop helper macros for casting to GstVaapiPictureH264 or
GstVaapiFrameStore. Also remove some useless checks for NULL pointers.

h264: drop GstVaapiSliceH264 object.

Use standard GstVaapiSlice object from now on since we already have
parsed and recorded the slice headers (GstH264SliceHdr decode units).

h264: detect new pictures from decode-units.

Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead
of assuming frame boundaries when first_mb_in_slice is zero.