public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
* [rpms/chromium] epel9-next: vaapi support for wayland
@ 2026-08-07 16:04 Than Ngo
0 siblings, 0 replies; only message in thread
From: Than Ngo @ 2026-08-07 16:04 UTC (permalink / raw)
To: git-commits
A new commit has been pushed.
Repo : rpms/chromium
Branch : epel9-next
Commit : 378fb70a07bd9a5c64b93159ca15980fa0620105
Author : Than Ngo <than@redhat.com>
Date : 2023-01-08T16:06:31+01:00
Stats : +661/-36 in 3 file(s)
URL : https://src.fedoraproject.org/rpms/chromium/c/378fb70a07bd9a5c64b93159ca15980fa0620105?branch=epel9-next
Log:
vaapi support for wayland
---
diff --git a/chromium-108-ozone-wayland-vaapi-support.patch b/chromium-108-ozone-wayland-vaapi-support.patch
new file mode 100644
index 0000000..d31ca8c
--- /dev/null
+++ b/chromium-108-ozone-wayland-vaapi-support.patch
@@ -0,0 +1,655 @@
+author Jianhui Dai <jianhui.j.dai@intel.com> Tue Nov 15 06:18:04 2022
+committer Jianhui Dai <jianhui.j.dai@intel.com> Tue Nov 15 06:18:04 2022
+
+[Ozone/Linux] Support VA-API on Linux Ozone/Wayland
+
+VA-API supports different display backends [1]. VA/DRM and VA/X11 are
+used by Chromium at the moment. All Ozone platforms support VA/DRM by
+default. VA/X11 is supported only on Ozone/X11.
+
+This CL renames 'supports_vaapi' to 'supports_vaapi_x11'; it indicates
+if VA/X11 supported. Linux Ozone/X11 supports both VA/X11 and VA/DRM;
+Linux Ozone/Wayland supports only VA/DRM. `VaapiPictureFactory` also
+takes this flag to determine picture creation and downloading mechanism
+on Linux.
+
+[1] https://github.com/intel/libva/blob/master/va/va_backend.h
+
+Test: VDA video playback on Linux X11 and Linux Wayland
+Bug: 1326754,1116701
+Change-Id: I6d6bf781833a7752d23dafb2b63112c2fc81b17a
+diff -up chromium-108.0.5359.124/media/gpu/args.gni.wayland-vaapi chromium-108.0.5359.124/media/gpu/args.gni
+--- chromium-108.0.5359.124/media/gpu/args.gni.wayland-vaapi 2022-12-14 01:39:52.000000000 +0100
++++ chromium-108.0.5359.124/media/gpu/args.gni 2023-01-05 10:13:08.291403261 +0100
+@@ -6,10 +6,14 @@ import("//build/config/chromeos/ui_mode.
+ import("//build/config/ozone.gni")
+
+ declare_args() {
+- # Indicates if X11 VA-API-based hardware acceleration is to be used.
+- # See also the comment near the |use_vaapi| arg.
+- use_vaapi_x11 = is_linux && ozone_platform_x11 &&
+- (target_cpu == "x86" || target_cpu == "x64") && !is_castos
++ # Build Chrome support for using VA-API over X11. Note that setting this to true is
++ # not a guarantee that Chrome will use (or even try to use) VA-API over X11. In
++ # particular, it is possible to build Chrome with support for VA-API over X11 but
++ # pick Wayland as the Ozone backend at runtime. In this case, Chrome will try to
++ # use VA-API over DRM.
++ support_vaapi_over_x11 =
++ is_linux && ozone_platform_x11 &&
++ (target_cpu == "x86" || target_cpu == "x64") && !is_castos
+ }
+
+ declare_args() {
+@@ -29,8 +33,9 @@ declare_args() {
+ # is typically the case on x86-based ChromeOS devices.
+ # VA-API should also be compiled by default on x11-using linux devices
+ # using x86/x64.
+- use_vaapi = use_vaapi_x11 || (is_chromeos_lacros &&
+- (target_cpu == "x86" || target_cpu == "x64"))
++ use_vaapi =
++ support_vaapi_over_x11 ||
++ (is_chromeos_lacros && (target_cpu == "x86" || target_cpu == "x64"))
+
+ # Indicates if ChromeOS protected media support exists. This is used
+ # to enable the CDM daemon in Chrome OS as well as support for
+diff -up chromium-108.0.5359.124/media/gpu/BUILD.gn.wayland-vaapi chromium-108.0.5359.124/media/gpu/BUILD.gn
+--- chromium-108.0.5359.124/media/gpu/BUILD.gn.wayland-vaapi 2022-12-14 01:39:52.000000000 +0100
++++ chromium-108.0.5359.124/media/gpu/BUILD.gn 2023-01-05 10:13:08.291403261 +0100
+@@ -20,7 +20,7 @@ buildflag_header("buildflags") {
+ "USE_VAAPI_IMAGE_CODECS=$use_vaapi_image_codecs",
+ "USE_V4L2_CODEC=$use_v4l2_codec",
+ "USE_LIBV4L2=$use_v4lplugin",
+- "USE_VAAPI_X11=$use_vaapi_x11",
++ "SUPPORT_VAAPI_OVER_X11=$support_vaapi_over_x11",
+ ]
+ }
+
+diff -up chromium-108.0.5359.124/media/gpu/vaapi/BUILD.gn.wayland-vaapi chromium-108.0.5359.124/media/gpu/vaapi/BUILD.gn
+--- chromium-108.0.5359.124/media/gpu/vaapi/BUILD.gn.wayland-vaapi 2022-12-14 01:39:52.000000000 +0100
++++ chromium-108.0.5359.124/media/gpu/vaapi/BUILD.gn 2023-01-05 10:13:08.291403261 +0100
+@@ -17,7 +17,7 @@ assert(use_vaapi)
+ generate_stubs("libva_stubs") {
+ extra_header = "va_stub_header.fragment"
+ sigs = [ "va.sigs" ]
+- if (use_vaapi_x11) {
++ if (support_vaapi_over_x11) {
+ sigs += [ "va_x11.sigs" ]
+ }
+ if (is_chromeos_ash) {
+@@ -138,7 +138,7 @@ source_set("vaapi") {
+ ]
+ }
+
+- if (use_vaapi_x11) {
++ if (support_vaapi_over_x11) {
+ deps += [ "//ui/gfx/x" ]
+ sources += [
+ "vaapi_picture_native_pixmap_angle.cc",
+@@ -214,7 +214,7 @@ source_set("common") {
+ deps += [ "//ui/ozone" ]
+ }
+
+- if (use_vaapi_x11) {
++ if (support_vaapi_over_x11) {
+ deps += [ "//ui/gfx/x" ]
+ }
+
+diff -up chromium-108.0.5359.124/media/gpu/vaapi/vaapi_picture_factory.cc.wayland-vaapi chromium-108.0.5359.124/media/gpu/vaapi/vaapi_picture_factory.cc
+--- chromium-108.0.5359.124/media/gpu/vaapi/vaapi_picture_factory.cc.wayland-vaapi 2022-12-14 01:39:53.000000000 +0100
++++ chromium-108.0.5359.124/media/gpu/vaapi/vaapi_picture_factory.cc 2023-01-05 10:32:58.616517572 +0100
+@@ -12,10 +12,10 @@
+ #if defined(USE_OZONE)
+ #include "media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.h"
+ #endif // defined(USE_OZONE)
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ #include "media/gpu/vaapi/vaapi_picture_native_pixmap_angle.h"
+ #include "media/gpu/vaapi/vaapi_picture_tfp.h"
+-#endif // BUILDFLAG(USE_VAAPI_X11)
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ #if defined(USE_EGL)
+ #include "media/gpu/vaapi/vaapi_picture_native_pixmap_egl.h"
+ #endif
+@@ -41,22 +41,32 @@ std::unique_ptr<VaapiPicture> CreateVaap
+
+ } // namespace
+
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++VaapiPictureFactory::VaapiPictureFactory(
++ absl::optional<bool> may_use_vaapi_over_x11)
++ : may_use_vaapi_over_x11_(may_use_vaapi_over_x11) {
++#else
+ VaapiPictureFactory::VaapiPictureFactory() {
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ vaapi_impl_pairs_.insert(
+ std::make_pair(gl::kGLImplementationEGLGLES2,
+ VaapiPictureFactory::kVaapiImplementationDrm));
+-#if BUILDFLAG(USE_VAAPI_X11)
+- vaapi_impl_pairs_.insert(
+- std::make_pair(gl::kGLImplementationEGLANGLE,
+- VaapiPictureFactory::kVaapiImplementationAngle));
+- vaapi_impl_pairs_.insert(
+- std::make_pair(gl::kGLImplementationDesktopGL,
+- VaapiPictureFactory::kVaapiImplementationX11));
+-#elif defined(USE_OZONE)
++
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ CHECK(may_use_vaapi_over_x11_.has_value());
++ if (may_use_vaapi_over_x11_.value()) {
++ vaapi_impl_pairs_.insert(
++ std::make_pair(gl::kGLImplementationEGLANGLE,
++ VaapiPictureFactory::kVaapiImplementationAngle));
++ vaapi_impl_pairs_.insert(
++ std::make_pair(gl::kGLImplementationDesktopGL,
++ VaapiPictureFactory::kVaapiImplementationX11));
++ }
++#else
+ vaapi_impl_pairs_.insert(
+ std::make_pair(gl::kGLImplementationEGLANGLE,
+ VaapiPictureFactory::kVaapiImplementationDrm));
+-#endif
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+
+ DeterminePictureCreationAndDownloadingMechanism();
+ }
+@@ -97,19 +107,19 @@ VaapiPictureFactory::GetVaapiImplementat
+ }
+
+ uint32_t VaapiPictureFactory::GetGLTextureTarget() {
+-#if BUILDFLAG(USE_VAAPI_X11)
+- return GL_TEXTURE_2D;
+-#else
++#if BUILDFLAG(IS_CHROMEOS)
+ return GL_TEXTURE_EXTERNAL_OES;
+-#endif
++#else
++ return GL_TEXTURE_2D;
++#endif // BUILDFLAG(IS_CHROMEOS)
+ }
+
+ gfx::BufferFormat VaapiPictureFactory::GetBufferFormat() {
+-#if BUILDFLAG(USE_VAAPI_X11)
+- return gfx::BufferFormat::RGBX_8888;
+-#else
++#if BUILDFLAG(IS_CHROMEOS)
+ return gfx::BufferFormat::YUV_420_BIPLANAR;
+-#endif
++#else
++ return gfx::BufferFormat::RGBX_8888;
++#endif // BUILDFLAG(IS_CHROMEOS)
+ }
+
+ void VaapiPictureFactory::DeterminePictureCreationAndDownloadingMechanism() {
+@@ -117,25 +127,30 @@ void VaapiPictureFactory::DeterminePictu
+ #if defined(USE_OZONE)
+ // We can be called without GL initialized, which is valid if we use Ozone.
+ case kVaapiImplementationNone:
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ DCHECK(may_use_vaapi_over_x11_.value_or(false));
++#endif
+ create_picture_cb_ = base::BindRepeating(
+ &CreateVaapiPictureNativeImpl<VaapiPictureNativePixmapOzone>);
+ needs_vpp_for_downloading_ = true;
+ break;
+ #endif // defined(USE_OZONE)
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ case kVaapiImplementationX11:
++ DCHECK(may_use_vaapi_over_x11_.value_or(false));
+ create_picture_cb_ =
+ base::BindRepeating(&CreateVaapiPictureNativeImpl<VaapiTFPPicture>);
+ // Neither VaapiTFPPicture or VaapiPictureNativePixmapAngle needs the VPP.
+ needs_vpp_for_downloading_ = false;
+ break;
+ case kVaapiImplementationAngle:
++ DCHECK(may_use_vaapi_over_x11_.value_or(false));
+ create_picture_cb_ = base::BindRepeating(
+ &CreateVaapiPictureNativeImpl<VaapiPictureNativePixmapAngle>);
+ // Neither VaapiTFPPicture or VaapiPictureNativePixmapAngle needs the VPP.
+ needs_vpp_for_downloading_ = false;
+ break;
+-#endif // BUILDFLAG(USE_VAAPI_X11)
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ case kVaapiImplementationDrm:
+ #if defined(USE_OZONE)
+ create_picture_cb_ = base::BindRepeating(
+diff -up chromium-108.0.5359.124/media/gpu/vaapi/vaapi_picture_factory.h.wayland-vaapi chromium-108.0.5359.124/media/gpu/vaapi/vaapi_picture_factory.h
+--- chromium-108.0.5359.124/media/gpu/vaapi/vaapi_picture_factory.h.wayland-vaapi 2022-12-14 01:39:53.000000000 +0100
++++ chromium-108.0.5359.124/media/gpu/vaapi/vaapi_picture_factory.h 2023-01-05 10:13:08.291403261 +0100
+@@ -36,7 +36,11 @@ class MEDIA_GPU_EXPORT VaapiPictureFacto
+ kVaapiImplementationAngle,
+ };
+
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ explicit VaapiPictureFactory(absl::optional<bool> may_use_vaapi_over_x11);
++#else
+ VaapiPictureFactory();
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+
+ VaapiPictureFactory(const VaapiPictureFactory&) = delete;
+ VaapiPictureFactory& operator=(const VaapiPictureFactory&) = delete;
+@@ -85,6 +89,11 @@ class MEDIA_GPU_EXPORT VaapiPictureFacto
+
+ CreatePictureCB create_picture_cb_;
+ bool needs_vpp_for_downloading_ = false;
++
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ // See comment in `VaapiWrapper::MayUseVaapiOverX11()`.
++ absl::optional<bool> may_use_vaapi_over_x11_;
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ };
+
+ } // namespace media
+diff -up chromium-108.0.5359.124/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc.wayland-vaapi chromium-108.0.5359.124/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc
+diff -up chromium-108.0.5359.124/media/gpu/vaapi/vaapi_video_decode_accelerator.cc.wayland-vaapi chromium-108.0.5359.124/media/gpu/vaapi/vaapi_video_decode_accelerator.cc
+--- chromium-108.0.5359.124/media/gpu/vaapi/vaapi_video_decode_accelerator.cc.wayland-vaapi 2023-01-05 10:13:08.290403251 +0100
++++ chromium-108.0.5359.124/media/gpu/vaapi/vaapi_video_decode_accelerator.cc 2023-01-05 10:13:08.292403271 +0100
+@@ -184,7 +184,12 @@ bool VaapiVideoDecodeAccelerator::Initia
+ Client* client) {
+ DCHECK(task_runner_->BelongsToCurrentThread());
+
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ vaapi_picture_factory_ =
++ std::make_unique<VaapiPictureFactory>(VaapiWrapper::MayUseVaapiOverX11());
++#else
+ vaapi_picture_factory_ = std::make_unique<VaapiPictureFactory>();
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+
+ if (config.is_encrypted()) {
+ NOTREACHED() << "Encrypted streams are not supported for this VDA";
+@@ -1210,7 +1215,7 @@ VaapiVideoDecodeAccelerator::GetSupporte
+
+ VaapiVideoDecodeAccelerator::BufferAllocationMode
+ VaapiVideoDecodeAccelerator::DecideBufferAllocationMode() {
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ // The IMPORT mode is used for Android on Chrome OS, so this doesn't apply
+ // here.
+ DCHECK_NE(output_mode_, VideoDecodeAccelerator::Config::OutputMode::IMPORT);
+diff -up chromium-108.0.5359.124/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc.wayland-vaapi chromium-108.0.5359.124/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc
+--- chromium-108.0.5359.124/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc.wayland-vaapi 2022-12-14 01:39:53.000000000 +0100
++++ chromium-108.0.5359.124/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc 2023-01-05 10:38:15.176631507 +0100
+@@ -38,6 +38,11 @@ struct TestParams {
+ bool decode_using_client_picture_buffers;
+ };
+
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++// TODO: Add it in TestParams to cover Ozone/Wayland.
++bool kMayUseVaapiOverX11 = true;
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++
+ constexpr int32_t kBitstreamId = 123;
+ constexpr size_t kInputSize = 256;
+
+@@ -130,7 +135,13 @@ class MockVaapiPicture : public VaapiPic
+
+ class MockVaapiPictureFactory : public VaapiPictureFactory {
+ public:
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ explicit MockVaapiPictureFactory(absl::optional<bool> may_use_vaapi_over_x11)
++ : VaapiPictureFactory(may_use_vaapi_over_x11) {}
++#else
+ MockVaapiPictureFactory() = default;
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++
+ ~MockVaapiPictureFactory() override = default;
+
+ MOCK_METHOD3(MockCreateVaapiPicture,
+@@ -164,7 +175,12 @@ class VaapiVideoDecodeAcceleratorTest :
+ bool can_bind_to_sampler) { return true; })),
+ decoder_thread_("VaapiVideoDecodeAcceleratorTestThread"),
+ mock_decoder_(new ::testing::StrictMock<MockAcceleratedVideoDecoder>),
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ mock_vaapi_picture_factory_(
++ new MockVaapiPictureFactory(kMayUseVaapiOverX11)),
++#else
+ mock_vaapi_picture_factory_(new MockVaapiPictureFactory()),
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ mock_vaapi_wrapper_(new MockVaapiWrapper(VaapiWrapper::kDecode)),
+ mock_vpp_vaapi_wrapper_(new MockVaapiWrapper(VaapiWrapper::kDecode)),
+ weak_ptr_factory_(this) {
+@@ -420,14 +436,16 @@ TEST_P(VaapiVideoDecodeAcceleratorTest,
+ mock_vaapi_picture_factory_->GetVaapiImplementation(
+ gl::kGLImplementationEGLGLES2));
+
+-#if BUILDFLAG(USE_VAAPI_X11)
+- EXPECT_EQ(VaapiPictureFactory::kVaapiImplementationAngle,
+- mock_vaapi_picture_factory_->GetVaapiImplementation(
+- gl::kGLImplementationEGLANGLE));
+- EXPECT_EQ(VaapiPictureFactory::kVaapiImplementationX11,
+- mock_vaapi_picture_factory_->GetVaapiImplementation(
+- gl::kGLImplementationDesktopGL));
+-#elif defined(USE_OZONE)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ if (kMayUseVaapiOverX11) {
++ EXPECT_EQ(VaapiPictureFactory::kVaapiImplementationAngle,
++ mock_vaapi_picture_factory_->GetVaapiImplementation(
++ gl::kGLImplementationEGLANGLE));
++ EXPECT_EQ(VaapiPictureFactory::kVaapiImplementationX11,
++ mock_vaapi_picture_factory_->GetVaapiImplementation(
++ gl::kGLImplementationDesktopGL));
++ }
++#else
+ EXPECT_EQ(VaapiPictureFactory::kVaapiImplementationDrm,
+ mock_vaapi_picture_factory_->GetVaapiImplementation(
+ gl::kGLImplementationEGLANGLE));
+diff -up chromium-108.0.5359.124/media/gpu/vaapi/vaapi_wrapper.cc.wayland-vaapi chromium-108.0.5359.124/media/gpu/vaapi/vaapi_wrapper.cc
+--- chromium-108.0.5359.124/media/gpu/vaapi/vaapi_wrapper.cc.wayland-vaapi 2022-12-14 01:39:53.000000000 +0100
++++ chromium-108.0.5359.124/media/gpu/vaapi/vaapi_wrapper.cc 2023-01-05 10:41:41.595648227 +0100
+@@ -62,7 +62,7 @@
+ #include "ui/gl/gl_bindings.h"
+ #include "ui/gl/gl_implementation.h"
+
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ typedef XID Drawable;
+
+ extern "C" {
+@@ -70,7 +70,7 @@ extern "C" {
+ }
+
+ #include "ui/gfx/x/connection.h" // nogncheck
+-#endif // BUILDFLAG(USE_VAAPI_X11)
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+
+ #if defined(USE_OZONE)
+ #include "ui/ozone/public/ozone_platform.h"
+@@ -84,14 +84,14 @@ using media_gpu_vaapi::kModuleVa_prot;
+
+ using media_gpu_vaapi::kModuleVa;
+ using media_gpu_vaapi::kModuleVa_drm;
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ using media_gpu_vaapi::kModuleVa_x11;
+-#endif // BUILDFLAG(USE_VAAPI_X11)
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ using media_gpu_vaapi::InitializeStubs;
+ using media_gpu_vaapi::IsVaInitialized;
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ using media_gpu_vaapi::IsVa_x11Initialized;
+-#endif // BUILDFLAG(USE_VAAPI_X11)
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ using media_gpu_vaapi::IsVa_drmInitialized;
+ using media_gpu_vaapi::StubPathMap;
+
+@@ -668,6 +668,12 @@ class VADisplayState {
+
+ void SetDrmFd(base::PlatformFile fd) { drm_fd_.reset(HANDLE_EINTR(dup(fd))); }
+
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ absl::optional<bool> MayUseVaapiOverX11() const {
++ return may_use_vaapi_over_x11_;
++ }
++#endif
++
+ private:
+ friend class base::NoDestructor<VADisplayState>;
+
+@@ -690,6 +696,13 @@ class VADisplayState {
+ // Drm fd used to obtain access to the driver interface by VA.
+ base::ScopedFD drm_fd_;
+
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ // Whether we'll be possibly using VA-API over Ozone/X11. This should only be
++ // set (if at all) during the pre-sandbox initialization. If absl::nullopt,
++ // all calls to Initialize() will return false immediately.
++ absl::optional<bool> may_use_vaapi_over_x11_;
++#endif
++
+ // The VADisplay handle. Valid between Initialize() and Deinitialize().
+ VADisplay va_display_;
+
+@@ -708,6 +721,15 @@ VADisplayState* VADisplayState::Get() {
+
+ // static
+ void VADisplayState::PreSandboxInitialization() {
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ if (ui::OzonePlatform::IsInitialized()) {
++ VADisplayState::Get()->may_use_vaapi_over_x11_ =
++ ui::OzonePlatform::GetInstance()
++ ->GetPlatformProperties()
++ .supports_vaapi_x11;
++ }
++#endif
++
+ constexpr char kRenderNodeFilePattern[] = "/dev/dri/renderD%d";
+ // This loop ends on either the first card that does not exist or the first
+ // render node that is not vgem.
+@@ -740,20 +762,18 @@ VADisplayState::VADisplayState()
+ bool VADisplayState::Initialize() {
+ base::AutoLock auto_lock(va_lock_);
+
+-#if defined(USE_OZONE) && BUILDFLAG(IS_LINUX)
+- // TODO(crbug.com/1116701): add vaapi support for other Ozone platforms on
+- // Linux. See comment in OzonePlatform::PlatformProperties::supports_vaapi
+- // for more details. This will also require revisiting everything that's
+- // guarded by USE_VAAPI_X11. For example, if USE_VAAPI_X11 is true, but the
+- // user chooses the Wayland backend for Ozone at runtime, then many things (if
+- // not all) that we do for X11 won't apply.
+- if (!ui::OzonePlatform::GetInstance()->GetPlatformProperties().supports_vaapi)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ if (!may_use_vaapi_over_x11_.has_value())
+ return false;
+ #endif
+
+ bool libraries_initialized = IsVaInitialized() && IsVa_drmInitialized();
+-#if BUILDFLAG(USE_VAAPI_X11)
+- libraries_initialized = libraries_initialized && IsVa_x11Initialized();
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ // Initialize VA-API X11 display backend for Linux Ozone/X11.
++ // See comment in OzonePlatform::PlatformProperties::supports_vaapi_x11 for
++ // more details.
++ if (may_use_vaapi_over_x11_.value())
++ libraries_initialized = libraries_initialized && IsVa_x11Initialized();
+ #endif
+ if (!libraries_initialized)
+ return false;
+@@ -768,7 +788,7 @@ bool VADisplayState::Initialize() {
+ return success;
+ }
+
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+
+ absl::optional<VADisplay> GetVADisplayStateX11(const base::ScopedFD& drm_fd) {
+ switch (gl::GetGLImplementation()) {
+@@ -796,13 +816,19 @@ absl::optional<VADisplay> GetVADisplaySt
+ }
+ }
+
+-#else
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+
+ absl::optional<VADisplay> GetVADisplayState(const base::ScopedFD& drm_fd) {
+ switch (gl::GetGLImplementation()) {
+ case gl::kGLImplementationEGLGLES2:
++#if BUILDFLAG(IS_CHROMEOS)
++ // GetVADisplayState() should not get called on Linux with Ozone/X11
++ // (GetVADisplayStateX11() should get called instead), and we haven't tried
++ // VA-API decoding on Linux with Ozone/Wayland and anything other than
++ // native EGL/GLES2.
+ case gl::kGLImplementationEGLANGLE:
+ case gl::kGLImplementationNone:
++#endif
+ return vaGetDisplayDRM(drm_fd.get());
+ default:
+ LOG(WARNING) << "VAAPI video acceleration not available for "
+@@ -812,18 +838,23 @@ absl::optional<VADisplay> GetVADisplaySt
+ }
+ }
+
+-#endif // BUILDFLAG(USE_VAAPI_X11)
+-
+ bool VADisplayState::InitializeVaDisplay_Locked() {
+- absl::optional<VADisplay> display =
+-#if BUILDFLAG(USE_VAAPI_X11)
+- GetVADisplayStateX11(drm_fd_);
+-#else
+- GetVADisplayState(drm_fd_);
+-#endif
++ absl::optional<VADisplay> display;
+
+- if (!display)
+- return false;
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ DCHECK(may_use_vaapi_over_x11_.has_value());
++ if (may_use_vaapi_over_x11_.value()) {
++ display = GetVADisplayStateX11(drm_fd_);
++ if (!display)
++ return false;
++ }
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++
++ if (!display) {
++ display = GetVADisplayState(drm_fd_);
++ if (!display)
++ return false;
++ }
+
+ va_display_ = *display;
+ if (!vaDisplayIsValid(va_display_)) {
+@@ -1656,6 +1687,13 @@ scoped_refptr<VaapiWrapper> VaapiWrapper
+ enforce_sequence_affinity);
+ }
+
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++// static
++absl::optional<bool> VaapiWrapper::MayUseVaapiOverX11() {
++ return VADisplayState::Get()->MayUseVaapiOverX11();
++}
++#endif
++
+ // static
+ std::vector<SVCScalabilityMode> VaapiWrapper::GetSupportedScalabilityModes(
+ VideoCodecProfile media_profile,
+@@ -2665,12 +2703,13 @@ bool VaapiWrapper::MapAndCopyAndExecute(
+ return Execute_Locked(va_surface_id, va_buffer_ids);
+ }
+
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ bool VaapiWrapper::PutSurfaceIntoPixmap(VASurfaceID va_surface_id,
+ x11::Pixmap x_pixmap,
+ gfx::Size dest_size) {
+ CHECK(!enforce_sequence_affinity_ ||
+ sequence_checker_.CalledOnValidSequence());
++ CHECK(MayUseVaapiOverX11().value_or(false));
+ base::AutoLockMaybe auto_lock(va_lock_.get());
+
+ VAStatus va_res = vaSyncSurface(va_display_, va_surface_id);
+@@ -2684,7 +2723,7 @@ bool VaapiWrapper::PutSurfaceIntoPixmap(
+ VA_SUCCESS_OR_RETURN(va_res, VaapiFunctions::kVAPutSurface, false);
+ return true;
+ }
+-#endif // BUILDFLAG(USE_VAAPI_X11)
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+
+ std::unique_ptr<ScopedVAImage> VaapiWrapper::CreateVaImage(
+ VASurfaceID va_surface_id,
+@@ -3086,7 +3125,7 @@ void VaapiWrapper::PreSandboxInitializat
+
+ paths[kModuleVa].push_back(std::string("libva.so.") + va_suffix);
+ paths[kModuleVa_drm].push_back(std::string("libva-drm.so.") + va_suffix);
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ paths[kModuleVa_x11].push_back(std::string("libva-x11.so.") + va_suffix);
+ #endif
+ #if BUILDFLAG(IS_CHROMEOS_ASH)
+diff -up chromium-108.0.5359.124/media/gpu/vaapi/vaapi_wrapper.h.wayland-vaapi chromium-108.0.5359.124/media/gpu/vaapi/vaapi_wrapper.h
+--- chromium-108.0.5359.124/media/gpu/vaapi/vaapi_wrapper.h.wayland-vaapi 2022-12-14 01:39:53.000000000 +0100
++++ chromium-108.0.5359.124/media/gpu/vaapi/vaapi_wrapper.h 2023-01-05 10:13:08.292403271 +0100
+@@ -36,9 +36,9 @@
+ #include "third_party/abseil-cpp/absl/types/optional.h"
+ #include "ui/gfx/geometry/size.h"
+
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ #include "ui/gfx/x/xproto.h" // nogncheck
+-#endif // BUILDFLAG(USE_VAAPI_X11)
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+
+ namespace gfx {
+ enum class BufferFormat;
+@@ -186,6 +186,16 @@ class MEDIA_GPU_EXPORT VaapiWrapper
+ VaapiWrapper(const VaapiWrapper&) = delete;
+ VaapiWrapper& operator=(const VaapiWrapper&) = delete;
+
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++ // Returns true if VaapiWrapper instances may use VA-API over X11 and false
++ // otherwise (VA-API over DRM will be used). If this returns absl::nullopt,
++ // it's because it was not possible to determine how VA-API may be used. This
++ // should only be called after PreSandboxInitialization() (which is assumed to
++ // be called only once during the GPU process startup) and is safe to call
++ // from any thread. Additionally, this should always return the same value.
++ static absl::optional<bool> MayUseVaapiOverX11();
++#endif
++
+ // Returns the supported SVC scalability modes for specified profile.
+ static std::vector<SVCScalabilityMode> GetSupportedScalabilityModes(
+ VideoCodecProfile media_profile,
+@@ -439,13 +449,13 @@ class MEDIA_GPU_EXPORT VaapiWrapper
+ VASurfaceID va_surface_id,
+ const std::vector<std::pair<VABufferID, VABufferDescriptor>>& va_buffers);
+
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ // Put data from |va_surface_id| into |x_pixmap| of size
+ // |dest_size|, converting/scaling to it.
+ [[nodiscard]] bool PutSurfaceIntoPixmap(VASurfaceID va_surface_id,
+ x11::Pixmap x_pixmap,
+ gfx::Size dest_size);
+-#endif // BUILDFLAG(USE_VAAPI_X11)
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+
+ // Creates a ScopedVAImage from a VASurface |va_surface_id| and map it into
+ // memory with the given |format| and |size|. If |format| is not equal to the
+diff -up chromium-108.0.5359.124/media/gpu/vaapi/va_stub_header.fragment.wayland-vaapi chromium-108.0.5359.124/media/gpu/vaapi/va_stub_header.fragment
+--- chromium-108.0.5359.124/media/gpu/vaapi/va_stub_header.fragment.wayland-vaapi 2022-12-14 01:39:52.000000000 +0100
++++ chromium-108.0.5359.124/media/gpu/vaapi/va_stub_header.fragment 2023-01-05 10:13:08.291403261 +0100
+@@ -7,8 +7,8 @@ extern "C" {
+
+ #include <va/va_drm.h>
+ #include <va/va.h>
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ #include <va/va_x11.h>
+-#endif // BUILDFLAG(USE_VAAPI_X11)
++#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+
+ }
+diff -up chromium-108.0.5359.124/ui/ozone/platform/x11/ozone_platform_x11.cc.wayland-vaapi chromium-108.0.5359.124/ui/ozone/platform/x11/ozone_platform_x11.cc
+--- chromium-108.0.5359.124/ui/ozone/platform/x11/ozone_platform_x11.cc.wayland-vaapi 2022-12-14 01:40:14.000000000 +0100
++++ chromium-108.0.5359.124/ui/ozone/platform/x11/ozone_platform_x11.cc 2023-01-05 10:13:08.292403271 +0100
+@@ -196,7 +196,7 @@ class OzonePlatformX11 : public OzonePla
+ properties->app_modal_dialogs_use_event_blocker = true;
+ properties->fetch_buffer_formats_for_gmb_on_gpu = true;
+ #if BUILDFLAG(IS_LINUX)
+- properties->supports_vaapi = true;
++ properties->supports_vaapi_x11 = true;
+ #endif
+
+ initialised = true;
+diff -up chromium-108.0.5359.124/ui/ozone/public/ozone_platform.h.wayland-vaapi chromium-108.0.5359.124/ui/ozone/public/ozone_platform.h
+--- chromium-108.0.5359.124/ui/ozone/public/ozone_platform.h.wayland-vaapi 2022-12-14 01:40:14.000000000 +0100
++++ chromium-108.0.5359.124/ui/ozone/public/ozone_platform.h 2023-01-05 10:13:08.293403281 +0100
+@@ -145,12 +145,13 @@ class COMPONENT_EXPORT(OZONE) OzonePlatf
+ bool fetch_buffer_formats_for_gmb_on_gpu = false;
+
+ #if BUILDFLAG(IS_LINUX)
+- // TODO(crbug.com/1116701): add vaapi support for other Ozone platforms on
+- // Linux. At the moment, VA-API Linux implementation supports only X11
+- // backend. This implementation must be refactored to support Ozone
+- // properly. As a temporary solution, VA-API on Linux checks if vaapi is
+- // supported (which implicitly means that it is Ozone/X11).
+- bool supports_vaapi = false;
++ // VA-API supports different display backends.
++ // See https://github.com/intel/libva/blob/master/va/va_backend.h
++ //
++ // VA/DRM and VA/X11 are used by Chromium at the moment. All Ozone platforms
++ // support VA/DRM by default. `supports_vaapi_x11` indicates if VA/X11
++ // supported; it is true only on Ozone/X11 platform.
++ bool supports_vaapi_x11 = false;
+ #endif
+
+ // Indicates that the platform allows client applications to manipulate
diff --git a/chromium-108-vaapi-i686-fpermissive.patch b/chromium-108-vaapi-i686-fpermissive.patch
deleted file mode 100644
index 3bd9b50..0000000
--- a/chromium-108-vaapi-i686-fpermissive.patch
+++ /dev/null
@@ -1,22 +0,0 @@
---- chromium-108.0.5359.124/media/gpu/vaapi/BUILD.gn.orig 2022-12-14 01:39:52.992482000 +0100
-+++ chromium-108.0.5359.124/media/gpu/vaapi/BUILD.gn 2022-12-24 11:14:19.118033967 +0100
-@@ -14,6 +14,10 @@
- assert(is_linux || is_chromeos)
- assert(use_vaapi)
-
-+config("vaapi_permissive") {
-+ cflags = [ "-fpermissive" ]
-+}
-+
- generate_stubs("libva_stubs") {
- extra_header = "va_stub_header.fragment"
- sigs = [ "va.sigs" ]
-@@ -138,6 +142,8 @@
- ]
- }
-
-+ configs += [ ":vaapi_permissive" ]
-+
- if (use_vaapi_x11) {
- deps += [ "//ui/gfx/x" ]
- sources += [
diff --git a/chromium.spec b/chromium.spec
index 8773da5..3047573 100644
--- a/chromium.spec
+++ b/chromium.spec
@@ -65,13 +65,6 @@
%global use_vaapi 0
%endif
-# ... and EL9 doesn't ship libva-devel on aarch64?
-%if 0%{?rhel} == 9
- %ifarch aarch64
- %global use_vaapi 0
- %endif
-%endif
-
# Seems like we might need this sometimes
# Practically, no. But it's here in case we do.
%global use_gold 0
@@ -219,7 +212,7 @@ BuildRequires: libicu-devel >= 5.4
Name: chromium%{chromium_channel}
Version: 108.0.5359.124
-Release: 3%{?dist}
+Release: 4%{?dist}
Summary: A WebKit (Blink) powered web browser that Google doesn't want you to use
Url: http://www.chromium.org/Home
License: BSD and LGPLv2+ and ASL 2.0 and IJG and MIT and GPLv2+ and ISC and OpenSSL and (MPLv1.1 or GPLv2 or LGPLv2)
@@ -382,8 +375,8 @@ Patch120: chromium-108-clang14-c++20-link-error.patch
# VAAPI
# Upstream turned VAAPI on in Linux in 86
Patch202: chromium-104.0.5112.101-enable-hardware-accelerated-mjpeg.patch
-Patch203: chromium-108-vaapi-i686-fpermissive.patch
Patch205: chromium-86.0.4240.75-fix-vaapi-on-intel.patch
+Patch206: chromium-108-ozone-wayland-vaapi-support.patch
# Apply these patches to work around EPEL8 issues
Patch300: chromium-99.0.4844.51-rhel8-force-disable-use_gnome_keyring.patch
@@ -1034,10 +1027,8 @@ udev.
# Feature specific patches
%if %{use_vaapi}
%patch202 -p1 -b .accel-mjpeg
-%ifarch i686
-%patch203 -p1 -b .i686permissive
-%endif
%patch205 -p1 -b .vaapi-intel-fix
+%patch206 -p1 -b .wayland-vaapi
%endif
%if 0%{?rhel} >= 8
@@ -1287,9 +1278,7 @@ CHROMIUM_BROWSER_GN_DEFINES+=' use_aura=true'
CHROMIUM_BROWSER_GN_DEFINES+=' enable_widevine=true'
%if %{use_vaapi}
-%if 0%{?fedora} >= 28
CHROMIUM_BROWSER_GN_DEFINES+=' use_vaapi=true'
-%endif
%else
CHROMIUM_BROWSER_GN_DEFINES+=' use_vaapi=false'
%endif
@@ -1755,6 +1744,9 @@ getent group chrome-remote-desktop >/dev/null || groupadd -r chrome-remote-deskt
%{chromium_path}/chromedriver
%changelog
+* Sun Jan 08 2023 Than Ngo <than@redhat.com> - 108.0.5359.124-4
+- vaapi support for wayland
+
* Wed Jan 04 2023 Than Ngo <than@redhat.com> - 108.0.5359.124-3
- build with system ffmpeg-free and system libaom
- fix widewine extension issue
^ permalink raw reply related [flat|nested] only message in thread
only message in thread, other threads:[~2026-08-07 16:04 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-08-07 16:04 [rpms/chromium] epel9-next: vaapi support for wayland Than Ngo
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox