Intel(R) Media Driver for VAAPI

To improve performance during interactions between CPU and GPU memory, the driver supports Media Copy. This feature uses GPU hardware engines or GPU kernels to accelerate copying surfaces to and from CPU-accessible locations.

Requirements and Constraints:

• Platform Support: Supported on ATSM/Meteor Lake (MTL) and newer platforms.
• Memory Alignment: The CPU start address must be 4k aligned. Refer to drm_i915_gem_userptr for details on user pointer requirements.
• Supported Formats: Includes Nv12, p010, p016, ARGB, yuy2, y210, y216, AYUV, y410, and ARGB10.
• Supported Resolutions: Supports common resolutions including 8K, 4K, 2K, 1080p, 720p, 480p, and 320P.

For implementation details, use the vaCopy API.

The media driver is available in two distinct build types:

• Full Feature Build (Default): Supports all features using hardware accelerators and closed-source shaders (media kernel binaries). This is the build used by most OSVs like RHEL, SUSE, and Fedora.
• Free Kernel Build: Uses fully open-source shaders (media kernels) and hardware features, but some features may be limited.

Ubuntu/Debian Users:

• For the Full feature build, install intel-media-va-driver-non-free.
• For the Free kernel build, install intel-media-va-driver.

API Stability

• Stable Interface: API options are considered a stable interface.
• Unstable Interface: Debug parameters, environmental variables, and internal data structures are not considered a stable interface and may be changed or removed without notice.

Hardware Compatibility

• The driver maintains strict backward compatibility; no code changes should regress support for currently supported hardware.
• Any deliberate removal of hardware support will be communicated in the release notes.

The Intel(R) Media Driver for VAAPI consists of three primary functional components:

• Video decoding: Utilizes the hardware-based decoder (VDBox) to provide fully-accelerated hardware video decoding, offloading the graphics engine.
• Video encoding: Supports two modes selectable via VA-API:
  • Low power encoding using the hardware-based encoder (VDEnc/Huc).
  • Hardware (PAK) + shader (media kernel + VME) based encoding.
• Video processing: Combines hardware-based video processor (VEBox/SFC) and shader (media kernel) based solutions to support various video processing features.

The Media Driver can be built with different kernel feature sets. Use the following build configuration options to select your desired build type:

• Full Feature Build: Includes all kernels (default).
  • ENABLE_KERNELS=ON
  • ENABLE_NONFREE_KERNELS=ON
• Free Kernel Build: Uses only open-source kernels.
  • ENABLE_KERNELS=ON
  • ENABLE_NONFREE_KERNELS=OFF

When performing a Free Kernel Build, you can further control how kernels are handled:

• To use pre-built open source kernel binaries: Set BUILD_KERNELS=OFF (default).
• To rebuild open source kernels from source code: Set BUILD_KERNELS=ON.

To enable support for DG1/SG1 or ATSM platforms (which require a special i915 kernel mode driver), you must set:

• ENABLE_PRODUCTION_KMD=ON (Note: this is OFF by default).

Once the dependencies are built, you can generate the kernel assembly code into C and header files using the build.py script.

Prerequisites

Ensure you have organized your tools in the following structure within the kernel directory:

• Kernel Directory: ./agnostic/gen11_icllp/vp/kernel
• compile/ folder: Must contain the binaries GenKrnBin, KernelBinToSource, and KrnToHex_IGA.
• compile/IGA/ folder: Must contain the iga64 binary.

Execution

Navigate to ./agnostic/gen11_icllp/vp/kernel and run the build.py script.

To profile media task performance (timing, FPS, and engine concurrency), follow these steps:

1. Build and install the latest internal-release version of the driver.
2. Configure the driver by copying the feature file to /etc/ (see Configure the UMD Perf Profiler via igfx_user_feature).
3. Run your test case. Upon completion, a binary file (e.g., linux_perf_out.bin) will be created in your working directory.
4. Parse the results using the MediaPerfParser tool to generate performance reports.

To build the driver on Ubuntu 16.04 or newer, you must first install the required system dependencies using apt.

apt install autoconf libtool libdrm-dev xorg xorg-dev openbox libx11-dev libgl1-mesa-glx

To compile and convert DS (Deep Learning Super Sampling) and HME (Hardware Media Engine) kernels, you must first build the required compiler toolchain components: cmc (CM Compiler) and igc (Intel Graphics Compiler).

1. Build CM Compiler (cmc):
   • Clone/download: https://github.com/intel/cm-compiler
   • Follow the build instructions in the cm-compiler repository.
2. Build Intel Graphics Compiler (igc):
   • Clone/download: https://github.com/intel/intel-graphics-compiler
   • Follow the build instructions in the intel-graphics-compiler repository.

Once the compilers are built, you can generate the kernel binaries using the provided build script. You must ensure the compiler paths are included in your PATH environment variable before running the script.

export PATH=$PATH:<cm_compiler_path>/include:<cm_compiler_path>/bin
run build.py to generate kernel binary