@desklink/host 0.2.0 → 0.3.1

package/engine/vendor/libva/va/va_prot.h

@@ -0,0 +1,525 @@
+/*
+ * Copyright (c) 2020 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL INTEL AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file va_prot.h
+ * \brief Protected content API.
+ *
+ * This file contains the \ref api_prot "Protected content API".
+ */
+
+#ifndef VA_PROT_H
+#define VA_PROT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \defgroup api_prot Protected content API
+ *
+ * @{
+ * \section prolouge Prolouge
+ * Video streaming is ubiquitous and the support for video streaming is widely
+ * available across client open systems such as PCs, MACs, Chromebooks etc. and
+ * closed systems such as settop box, smart TVs, DVDs etc. By default,
+ * video streaming is not considered premium due to various constraints such as
+ * resolution, quality, production cost etc. but recently streaming of premium
+ * video(1080p+) has become norm. The streaming of premium video in open systems
+ * such as PCs, MACs, Chromebooks etc. makes video particularly susceptible to
+ * piracy (due to non-video playback usages of such systems) resulting in
+ * millions of dollars of loss to content creators.
+ *
+ * Digital Rights Management(DRM) has been proposed to stop piracy of premium
+ * video streams across a wide spectrum. There are some known open/closed DRM
+ * standards such as [Widevine by Google](https://www.widevine.com/),
+ * [PlayReady by Microsoft](https://www.microsoft.com/playready/),
+ * [FairPlay by Apple](https://developer.apple.com/streaming/fps/),
+ * [Merlin by Sony](https://www.marlin-community.com/), etc... Each DRM
+ * standard has its properties but all DRM standards support a common
+ * mechanism. This common mechanism involves cryptographical method for
+ * authenticating the client system, delivering bitstream and required
+ * cryptographic assets to client system and then cryptographically processing
+ * bitstream in client system. The cryptographic methods used in these steps
+ * are asymmetric such as RSA, DH etc. and symmetric such as AES CTR, CBC etc.
+ * encryption mechanisms. The authentication of client system, delivery of
+ * bitstream and cryptographic assets to client system is performed using
+ * asymmetric cryptographic mechanism while bitstream is encrypted and processed
+ * using symmetric cryptographic. In DRM world, authentication of client system,
+ * delivery of bitstream and required cryptographic assets to client system is
+ * loosely called provisioning and license acquisition while the processing of
+ * cryptographically secure bitstream is divided as video decryption/decoding,
+ * audio decryption/playback, video display. Besides DRM standards, Video/Audio
+ * bitstream encryption standard such as
+ * [Common Encryption Standard(CENC)](https://www.iso.org/standard/76597.html)
+ * provides a mechanism to normalize bitstream encryption methods across vendors
+ * while providing flexibility.
+ *
+ * \section DRM Pipeline
+ * Most DRM standards execute the following deep pipeline to playback
+ * contents on client systems from streaming servers - provisioning uses
+ * provisioning servers, licence aquisition uses license servers, video
+ * bitstream delivery uses content servers and decryption/decoding, audio
+ * bitstream delivery uses content servers and decyption/playback,
+ * display/playback. The system level HWDRM sequence diagram is following -
+ * ![HWDRM sequence diagram](https://user-images.githubusercontent.com/75039699/102427278-df284e80-3fc5-11eb-9a3e-129b5f6b567a.png)
+ * and HWDRM pipeline view is following -
+ * ![HWDRM pipeline view](https://user-images.githubusercontent.com/75039699/102427357-04b55800-3fc6-11eb-8b8c-f34fc44ec061.png)
+ *
+ * \section LibVA Protected Content APIs
+ * The LibVA Protected APIs are designed to enable DRM capabilities or
+ * facilitate isolated communicaiton with TEE.
+ * The VAEntrypointProtectedTEEComm is to define interfaces for Application
+ * to TEE direct communication to perform various TEE centric operations
+ * such as standalone provisioning of platform at factory or provisioning
+ * TEE for other usages, providing TEE capabilities etc.
+ * The VAEntrypointProtectedContent is to define interfaces for protected
+ * video playback using HWDRM. This entry point co-ordinates assets across
+ * TEE/GPU/Display for HWDRM playback.
+ *
+ * The difference between Protected Content and Protected TEE Communication
+ * is that Protected Content Entrypoint does not provide isolated entry
+ * point for TEE and invokes TEE only from HWDRM perspective.
+ *
+ * Protected Content Entrypoint
+ * The most of DRM standards execute following deep pipeline to playback
+ * contents on client systems from streaming servers - provisioning uses
+ * provisioning servers, licence aquisition uses license servers, video
+ * bitstream delivery uses content servers and decryption/decoding, audio
+ * bitstream delivery uses content servers and decyption/playback,
+ * display/playback.
+ *
+ * The Provisioning and License aquisition implementations are Independent
+ * Hardware Vendor (IHV) specific but most IHVs use some form of Trusted
+ * Execution Environment (TEE) to prepare client platform or system for DRM
+ * content playback. The provisioning operations use provisioning servers (as
+ * instructed in DRM standard) and client system TEE. The communication between
+ * provisioning servers and client system TEE uses asymmetic cryptographic
+ * mechanism. This step provides a way to establish root-of-trust between
+ * client system and streaming servers. Once root-of-trust is established then
+ * client system requests for license aquisition for a particular streaming
+ * title. The license aquisition involves communication between licensing
+ * servers and TEE using asymmetic cryptographic mechanism. At end of this step,
+ * client system TEE has required assets to decrypt/decode. Although these
+ * communication does not direcly involve video aspect of GPU but **facilitate
+ * GPU required assets to playback premium contents**.
+ *
+ * To support DRM standard requirements in playback pipeline, OSes and HWs
+ * incorporate various methods to protect full playback pipeline. These
+ * methods of protection could be SW based or HW based. The SW based protection
+ * mechanism of DRMs is called SWDRM while HW based protection mechanism is
+ * called HWDRM. There is no previous support in LibVA to support either DRM
+ * mechanism.
+ *
+ * For DRM capabilities, APIs inolve creation of protected session to
+ * communicate with TEE and then using these protected sessions to process
+ * video/audio data. The philophashy behind these API is to leverage existing
+ * LibVA infrastructure as much as possible.
+ *
+ * Note: TEE could be any secure HW device such as ME-FW or FPGA Secure
+ * Enclave or NPU Secure Enclave. There are 2 concepts here – TEE Type such
+ * as ME-FW or FPGA or NPU; TEE Type Client such as for AMT or HDCP or
+ * something else etc.
+ *
+ * \section description Detailed Description
+ * The Protected content API provides a general mechanism for opening
+ * protected session with TEE and if required then \ref priming GPU/Display.
+ * The behavior of protected session API depends on parameterization/
+ * configuration of protected session. Just for TEE tasks, protected
+ * session is parameterized/configured as TEE Communication while for
+ * HWDRM, protected session is parameterized/confgured as Protected
+ * Content.
+ *
+ * TEE Communication Entrypoint
+ * With TEE Communication parameterization/configuration, client
+ * executes TEE workloads in TEE with TEE Communication protected
+ * session.
+ *
+ * Protected Content Entrypoint
+ * With Protected Content parameterization/configuration, client
+ * executes HWDRM playback workloads HW accelerating protected video
+ * content decryption/decoding with protected content session.
+ *
+ * Before calling vaCreateProtectedSession, VAConfigID is obtained using
+ * existing libva mechanism to determine configuration parameters of
+ * protected session. The VAConfigID is determined in this way so that
+ * Protected Session implementation aligns with existing libva implementation.
+ * After obtaining VAConfigID, Protected Session needs to be created but
+ * note this is a session and not a context. Refer VAProtectedSessionID
+ * for more details.
+ *
+ * Note:- Protected session represents session object that has all security
+ * information needed for Secure Enclave to operate certain operations.
+ *
+ * \subsection priming Priming
+ * Priming is used to refer various types of initializations. For example,
+ * if license acquisition is being performed then priming means that TEE is
+ * already provisioned aka TEE has some sort of "cryptographic" whitelist of
+ * servers that TEE will use to do license acquisition for video playback. If
+ * HWDRM video playback is being performed then priming means that HWDRM
+ * eco-system TEE/GPU/Display has proper keys to do proper video playback etc.
+ *
+ * Protected content API uses the following paradigm for protected content
+ * session:
+ * - \ref api_pc_caps
+ * - \ref api_pc_setup
+ * - \ref api_pc_exec
+ * - \ref api_pc_attach
+ *
+ * \subsection api_pc_caps Query for supported cipher mode, block size, mode
+ *
+ * Checking whether protected content is supported can be performed with
+ * vaQueryConfigEntrypoints() and the profile argument set to
+ * #VAProfileProtected. If protected content is supported, then the list of
+ * returned entry-points will include #VAEntrypointProtectedContent
+ *
+ * \code
+ * VAEntrypoint *entrypoints;
+ * int i, num_entrypoints, supportsProtectedContent = 0;
+ *
+ * num_entrypoints = vaMaxNumEntrypoints();
+ * entrypoints = malloc(num_entrypoints * sizeof(entrypoints[0]);
+ * vaQueryConfigEntrypoints(va_dpy, VAProfileProtected, entrypoints,
+ *     &num_entrypoints);
+ *
+ * for (i = 0; !supportsProtectedContent && i < num_entrypoints; i++) {
+ *     if (entrypoints[i] == VAEntrypointProtectedContent)
+ *         supportsProtectedContent = 1;
+ * }
+ * \endcode
+ *
+ * Then, the vaGetConfigAttributes() function is used to query the protected
+ * session capabilities.
+ *
+ * \code
+ * VAConfigAttrib attribs;
+ * attribs[0].type = VAConfigAttribProtectedContentCipherAlgorithm;
+ * attribs[1].type = VAConfigAttribProtectedContentCipherBlockSize;
+ * attribs[2].type = VAConfigAttribProtectedContentCipherMode;
+ * attribs[3].type = VAConfigAttribProtectedContentCipherSampleType;
+ * attribs[4].type = VAConfigAttribProtectedContentUsage;
+ * vaGetConfigAttributes(va_dpy, VAProfileProtected,
+ *     VAEntrypointProtectedContent, attribs, 5);
+ * if ((attribs[1].value & VA_PC_CIPHER_AES) == 0) {
+ *     // not find desired cipher algorithm
+ *     assert(0);
+ * }
+ * if ((attribs[2].value & VA_PC_BLOCK_SIZE_128) == 0) {
+ *     // not find desired block size
+ *     assert(0);
+ * }
+ * if ((attribs[3].value & VA_PC_CIPHER_MODE_CBC) == 0) {
+ *     // not find desired counter mode
+ *     assert(0);
+ * }
+ * if ((attribs[4].value & VA_PC_SAMPLE_TYPE_SUBSAMPLE) == 0) {
+ *     // not find desired sample type
+ *     assert(0);
+ * }
+ * if ((attribs[5].value & VA_PC_USAGE_WIDEVINE) == 0) {
+ *     // not find desired usage
+ *     assert(0);
+ * }
+ * \endcode
+ *
+ * \subsection api_pc_setup Set up a protected content session
+ *
+ * TEE Communication Entrypoint
+ * The protected content session provides a TEE session that is used to extract
+ * TEE information. This information could be used to peform TEE operations.
+ *
+ * Protected Content Entrypoint
+ * The protected content session can be attached to VA decode/encode/vp context
+ * to do decryption/protection in the pipeline.
+ * Before creating a protected content session, it needs to create a config
+ * first via vaCreateConfig(). Then using this config id to create a protected
+ * content session via vaCreateProtectedSession().
+ *
+ * The general control flow is demonstrated by the following pseudo-code:
+ * \code
+ * // Create config
+ * VAConfigID config_id;
+ *
+ * attribs[0].value = VA_PC_CIPHER_AES;
+ * attribs[1].value = VA_PC_BLOCK_SIZE_128;
+ * attribs[2].value = VA_PC_CIPHER_MODE_CBC;
+ * attribs[3].value = VA_PC_SAMPLE_TYPE_SUBSAMPLE;
+ * attribs[4].value = VA_PC_USAGE_WIDEVINE;
+ * va_status = vaCreateConfig(va_dpy, VAProfileProtected,
+ *     VAEntrypointProtectedContent, attribs, 5, &config_id);
+ * CHECK_VASTATUS(va_status, "vaCreateConfig");
+ * \endcode
+ *
+ * Once the config is set up, we can create protected content session via
+ vaCreateProtectedSession().
+ * \code
+ * // Create a protected session
+ * VAProtectedSessionID crypto_session;
+ *
+ * va_status = vaCreateProtectedSession(va_dpy, config_id, &crypto_session);
+ * CHECK_VASTATUS(va_status, "vaCreateProtectedSession");
+ * \endcode
+ *
+ * \subsection api_pc_exec TEE communication via vaProtectedSessionExecute()
+ *
+ * TEE Communication Entrypoint
+ * App needs to communicate with TEE to get TEE information or \ref priming
+ * "prime" TEE with  information that will be utilized for future TEE
+ * operations/tasks.
+ *
+ * Protected Content Entrypoint
+ * Before starting decryption/encryption operation in GPU, app may need to
+ * communicate  with TEE to get encrypted assets for \ref priming HWDRM pipeline
+ * for decryption. App need to call vaProtectedSessionExecute() to get this
+ * asset. The following pseudo-code demonstrates getting session assets via
+ * vaProtectedSessionExecute() as an example.
+ *
+ * In this example, the vaCreateBuffer is called with exec_buffer mainly becasue TEE
+ * Communication Entrypoint buffers are CPU bound and buffer size is small enough to
+ * have extra copy operation without impacting performance.
+ *
+ * \code
+ * uint32_t app_id = 0xFF;
+ * VABufferID buffer;
+ * VAProtectedSessionExecuteBuffer exec_buff = {0};
+ *
+ * exec_buff.function_id = GET_SESSION_ID;
+ * exec_buff.input.data = nullptr;
+ * exec_buff.input.data_size = 0;
+ * exec_buff.output.data = &app_id;
+ * exec_buff.output.max_data_size = sizeof(app_id);
+ * va_status = vaCreateBuffer(
+ *                 va_dpy,
+ *                 crypto_session,
+ *                 (VABufferType) VAProtectedSessionExecuteBufferType,
+ *                 sizeof(exec_buff),
+ *                 1,
+ *                 &exec_buff,
+ *                 &buffer);
+ *
+ * va_status = vaProtectedSessionExecute(va_dpy, crypto_session, buffer);
+ *
+ * vaDestroyBuffer(va_dpy, buffer);
+ * \endcode
+ *
+ * \subsection api_pc_attach Attach/Detach protected content session to the VA
+ * context which want to enable/disable decryption/protection
+ *
+ * Protected content session is attached to VA decode/encode/vp context to
+ * enable protected decoding/encoding/video processing per frame or entire
+ * stream. If protected session attached per frame then application has 2
+ * options for decoding/encoding skip processing i.e. accomodating clear
+ * frames - 1. Application could do detach after each frame is processed
+ * to process clear frame 2. Application could remains attached to decode/
+ * encode session but specify enryption byte length to 0.
+ * The video processing does not has option #2 mainly because API does
+ * not provide skip processing.
+ *
+ * \code
+ * vaAttachProtectedSession(va_dpy, decode_ctx, crypto_session);
+ * foreach (iteration) {
+ *     vaBeginPicture(va_dpy, decode_ctx, surface);
+ *     ...
+ *     vaRenderPicture(va_dpy, decode_ctx, &buf_id1, 1);
+ *     vaRenderPicture(va_dpy, decode_ctx, &buf_id2, 1);
+ *     // Buffer holding encryption parameters, i.e. VAEncryptionParameterBufferType buffer
+ *     vaRenderPicture(va_dpy, decode_ctx, &buf_id_enc_param, 1);
+ *     ...
+ *     vaEndPicture(va_dpy, decode_ctx);
+ * }
+ * vaDetachProtectedSession(va_dpy, decode_ctx);
+ * \endcode
+ *
+ * or it could be frame-by-frame attaching/detaching as following:
+ *
+ * \code
+ * foreach (iteration) {
+ *     if (encrypted)
+ *         vaAttachProtectedSession(va_dpy, decode_ctx, crypto_session);
+
+ *     vaBeginPicture(va_dpy, decode_ctx, surface);
+ *     ...
+ *     vaRenderPicture(va_dpy, decode_ctx, &buf_id1, 1);
+ *     vaRenderPicture(va_dpy, decode_ctx, &buf_id2, 1);
+ *     // Buffer holding encryption parameters, i.e. VAEncryptionParameterBufferType buffer
+ *     vaRenderPicture(va_dpy, decode_ctx, &buf_id_enc_param, 1);
+ *     ...
+ *     vaEndPicture(va_dpy, decode_ctx);
+ *
+ *     if (encrypted)
+ *         vaDetachProtectedSession(va_dpy, decode_ctx);
+
+ *     // check encrypted variable for next frame
+ * }
+ * \endcode
+ */
+
+/**
+ * ProtectedSessions and Contexts
+ *
+ * According to #VAContextID, Context represents a "virtual" video decode,
+ * encode or video processing pipeline. Surfaces are render targets for a given
+ * context. The data in the surfaces are not accessible to the client except if
+ * derived image is supported and the internal data format of the surface is
+ * implementation specific. Application can create a video decode, encode or
+ * processing context which represents a "virtualized" hardware device.
+ *
+ * Since Protected Session does not virtualize any HW device or build any
+ * pipeline but rather accessorize existing virtualized HW device or pipeline
+ * to operate in protected mode so we decided to create separate function.
+ * Beside this, a virtualized HW device or pipeline could own several protected
+ * sessions and operate in those protected modes without ever re-creating
+ * virtualization of HW device or re-building HW pipeline (an unique protected
+ * environment multiplexing capability in Intel HW).
+ *
+ * The returned protected_session represents a notion of Host and TEE clients
+ * while representing protection status in GPU and Display.
+ *
+ * Both contexts and protected sessions are identified by unique IDs and its
+ * implementation specific internals are kept opaque to the clients
+ */
+typedef VAGenericID VAProtectedSessionID;
+
+/** \brief TEE Execucte Function ID. */
+typedef enum _VA_TEE_EXEC_FUNCTION_ID {
+    VA_TEE_EXECUTE_FUNCTION_ID_PASS_THROUGH = 0x00000001,
+    VA_TEE_EXECUTE_FUNCTION_ID_GET_FIRMWARE_VERSION = 0x00000002,
+
+} VA_TEE_EXECUTE_FUNCTION_ID;
+
+/** \brief Input/Output buffer of VAProtectedSessionExecuteBuffer */
+typedef struct _VAProtectedSessionBuffer {
+    /*
+     * This is used when this buffer refer to output buffer. The maximum size of
+     * data that the driver can return in the output buffer. It is not used for
+     * input buffer.
+     */
+    uint32_t max_data_size;
+    /*
+     * If it is used for input buffer, it is the size of the input data. If it is
+     * used for output buffer, it is the returns size of the output data written
+     * by the driver.
+     */
+    uint32_t data_size;
+    /*
+     * data pointer of this buffer
+     */
+    void *data;
+    uint32_t va_reserved[VA_PADDING_LOW];
+} VAProtectedSessionBuffer;
+
+/** \brief Buffer for vaProtectedSessionExecute() */
+typedef struct _VAProtectedSessionExecuteBuffer {
+    /** \brief Specify the function to execute. It is IHV's implementation
+     * specific */
+    uint32_t function_id;
+    /** \brief Input buffer */
+    VAProtectedSessionBuffer input;
+    /** \brief Output buffer */
+    VAProtectedSessionBuffer output;
+    /** \brief Return the result of this function. The status result is IHV's
+     * implementation specific */
+    uint32_t status;
+    /** \brief - vtag represents TEE sandbox identification for multiple playback scenario
+     *
+     * If TEE interface is created using VAEntrypointProtectedTEEComm then
+     * vtag is non-zero for multiple playback and vtag is zero for single playback
+     *
+     * If TEE interface is not created using VAEntrypointProtectedTEEComm then
+     * vtag - reserved
+     */
+    uint64_t vtag;
+    /** \brief reserved bytes for future use, must be zero */
+    uint32_t va_reserved[VA_PADDING_LOW - 2];
+} VAProtectedSessionExecuteBuffer;
+
+/**
+ * \brief Create a protected session
+ *
+ * Create a protected session
+ *
+ * @param[in] dpy                   the VA display
+ * @param[in] config_id             configuration for the protected session
+ * @param[out] protected_session    created protected session id upon return
+ */
+VAStatus vaCreateProtectedSession(VADisplay dpy, VAConfigID config_id,
+                                  VAProtectedSessionID *protected_session);
+
+/**
+ * \brief Destroy a protected session
+ *
+ * Destroy a protected session
+ *
+ * @param[in] dpy                   the VA display
+ * @param[in] protected_session     protected session to be destroyed
+ */
+VAStatus vaDestroyProtectedSession(VADisplay dpy,
+                                   VAProtectedSessionID protected_session);
+
+/**
+ * \brief Attach a protected content session to VA context
+ *
+ * Attach a protected content session to the context to enable
+ * decryption/protection
+ *
+ * @param[in] dpy                   the VA display
+ * @param[in] id                    the VA decode/encode/vp context
+ * @param[in] protected_session     the protected session to attach
+ */
+VAStatus vaAttachProtectedSession(VADisplay dpy, VAGenericID id,
+                                  VAProtectedSessionID protected_session);
+
+/**
+ * \brief  Detach the protected content session from the VA context
+ *
+ * Detach protected content session of the context to disable
+ * decryption/protection
+ *
+ * @param[in] dpy                   the VA display
+ * @param[in] id                    TEE client id to be detached
+ */
+VAStatus vaDetachProtectedSession(VADisplay dpy, VAGenericID id);
+
+/**
+ * \brief Execute provides a general mechanism for TEE client tasks execution.
+ *
+ * vaProtectedSessionExecute provides a mechanism for TEE clients to execute
+ * specific tasks. The implementation may differ between IHVs.
+ * This is a synchronous API.
+ *
+ * @param[in] dpy                   the VA display
+ * @param[in] protected_session     the protected session
+ * @param[in,out] buf_id            the VA buffer
+ */
+VAStatus vaProtectedSessionExecute(VADisplay dpy,
+                                   VAProtectedSessionID protected_session,
+                                   VABufferID buf_id);
+
+/**@}*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* VA_PROT_H */

package/engine/vendor/libva/va/va_version.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef VA_VERSION_H
+#define VA_VERSION_H
+
+/**
+ * VA_MAJOR_VERSION:
+ *
+ * The major version of VA-API (1, if %VA_VERSION is 1.2.3)
+ */
+#define VA_MAJOR_VERSION    1
+
+/**
+ * VA_MINOR_VERSION:
+ *
+ * The minor version of VA-API (2, if %VA_VERSION is 1.2.3)
+ */
+#define VA_MINOR_VERSION    24
+
+/**
+ * VA_MICRO_VERSION:
+ *
+ * The micro version of VA-API (3, if %VA_VERSION is 1.2.3)
+ */
+#define VA_MICRO_VERSION    0
+
+/**
+ * VA_VERSION:
+ *
+ * The full version of VA-API, like 1.2.3
+ */
+#define VA_VERSION          1.24.0
+
+/**
+ * VA_VERSION_S:
+ *
+ * The full version of VA-API, in string form (suited for string
+ * concatenation)
+ */
+#define VA_VERSION_S       "1.24.0"
+
+/**
+ * VA_VERSION_HEX:
+ *
+ * Numerically encoded version of VA-API, like 0x010203
+ */
+#define VA_VERSION_HEX     ((VA_MAJOR_VERSION << 24) | \
+                            (VA_MINOR_VERSION << 16) | \
+                            (VA_MICRO_VERSION << 8))
+
+/**
+ * VA_CHECK_VERSION:
+ * @major: major version, like 1 in 1.2.3
+ * @minor: minor version, like 2 in 1.2.3
+ * @micro: micro version, like 3 in 1.2.3
+ *
+ * Evaluates to %TRUE if the version of VA-API is greater than
+ * @major, @minor and @micro
+ */
+#define VA_CHECK_VERSION(major,minor,micro) \
+        (VA_MAJOR_VERSION > (major) || \
+         (VA_MAJOR_VERSION == (major) && VA_MINOR_VERSION > (minor)) || \
+         (VA_MAJOR_VERSION == (major) && VA_MINOR_VERSION == (minor) && VA_MICRO_VERSION >= (micro)))
+
+#endif /* VA_VERSION_H */