rpms
/
chromium
21
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3eaf3310da'
${ noResults }
chromium/SOURCES/chromium-112-ozone-wayland-...

626 lines
26 KiB
Raw Normal View History Unescape

import chromium-122.0.6261.128-1.el8
9 months ago
diff -up chromium-112.0.5615.49/media/gpu/args.gni.wayland-vaapi chromium-112.0.5615.49/media/gpu/args.gni
--- chromium-112.0.5615.49/media/gpu/args.gni.wayland-vaapi 2023-03-30 02:33:53.000000000 +0200
+++ chromium-112.0.5615.49/media/gpu/args.gni 2023-04-14 21:29:41.776328044 +0200
@@ -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-112.0.5615.49/media/gpu/BUILD.gn.wayland-vaapi chromium-112.0.5615.49/media/gpu/BUILD.gn
--- chromium-112.0.5615.49/media/gpu/BUILD.gn.wayland-vaapi 2023-03-30 02:33:53.000000000 +0200
+++ chromium-112.0.5615.49/media/gpu/BUILD.gn 2023-04-14 21:29:41.776328044 +0200
@@ -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-112.0.5615.49/media/gpu/vaapi/BUILD.gn.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/BUILD.gn
--- chromium-112.0.5615.49/media/gpu/vaapi/BUILD.gn.wayland-vaapi 2023-03-30 02:33:53.000000000 +0200
+++ chromium-112.0.5615.49/media/gpu/vaapi/BUILD.gn 2023-04-14 21:29:41.776328044 +0200
@@ -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) {
@@ -139,7 +139,7 @@ source_set("vaapi") {
]
}
- if (use_vaapi_x11) {
+ if (support_vaapi_over_x11) {
deps += [ "//ui/gfx/x" ]
sources += [
"vaapi_picture_native_pixmap_angle.cc",
@@ -213,7 +213,7 @@ source_set("common") {
deps += [ "//ui/ozone" ]
}
- if (use_vaapi_x11) {
+ if (support_vaapi_over_x11) {
deps += [ "//ui/gfx/x" ]
}
diff -up chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.cc.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.cc
--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.cc.wayland-vaapi 2023-03-30 02:33:53.000000000 +0200
+++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.cc 2023-04-15 07:14:05.573796794 +0200
@@ -13,9 +13,9 @@
#if BUILDFLAG(IS_OZONE)
#include "media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.h"
#endif // BUILDFLAG(IS_OZONE)
-#if BUILDFLAG(USE_VAAPI_X11)
+#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
#include "media/gpu/vaapi/vaapi_picture_native_pixmap_angle.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,19 +41,28 @@ 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));
-#elif BUILDFLAG(IS_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));
+ }
+#else
vaapi_impl_pairs_.insert(
std::make_pair(gl::kGLImplementationEGLANGLE,
VaapiPictureFactory::kVaapiImplementationDrm));
-#endif
+#endif // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
DeterminePictureCreationAndDownloadingMechanism();
}
@@ -93,19 +102,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() {
@@ -113,19 +122,23 @@ void VaapiPictureFactory::DeterminePictu
#if BUILDFLAG(IS_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 // BUILDFLAG(IS_OZONE)
-#if BUILDFLAG(USE_VAAPI_X11)
+#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
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 BUILDFLAG(IS_OZONE)
create_picture_cb_ = base::BindRepeating(
diff -up chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.h.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.h
--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.h.wayland-vaapi 2023-03-30 02:33:53.000000000 +0200
+++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.h 2023-04-14 21:29:41.777328062 +0200
@@ -35,7 +35,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;
@@ -84,6 +88,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-112.0.5615.49/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc
--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc.wayland-vaapi 2023-03-30 02:33:53.000000000 +0200
+++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc 2023-04-14 21:29:41.777328062 +0200
@@ -113,7 +113,7 @@ VaapiStatus VaapiPictureNativePixmapOzon
ui::OzonePlatform* platform = ui::OzonePlatform::GetInstance();
ui::SurfaceFactoryOzone* factory = platform->GetSurfaceFactoryOzone();
gfx::BufferUsage buffer_usage = gfx::BufferUsage::SCANOUT_VDA_WRITE;
-#if BUILDFLAG(USE_VAAPI_X11)
+#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
// The 'VaapiVideoDecodeAccelerator' requires the VPP to download the decoded
// frame from the internal surface to the allocated native pixmap.
// 'SCANOUT_VDA_WRITE' is used for 'YUV_420_BIPLANAR' on ChromeOS; For Linux,
diff -up chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator.cc.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator.cc
--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator.cc.wayland-vaapi 2023-04-14 21:29:41.775328024 +0200
+++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator.cc 2023-04-14 21:29:41.777328062 +0200
@@ -185,7 +185,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";
@@ -1211,7 +1216,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-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc
--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc.wayland-vaapi 2023-03-30 02:33:53.000000000 +0200
+++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc 2023-04-15 07:38:19.058957112 +0200
@@ -41,6 +41,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;
@@ -134,7 +139,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,
@@ -167,7 +178,12 @@ class VaapiVideoDecodeAcceleratorTest :
const scoped_refptr<gl::GLImage>& image) { 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) {
@@ -422,11 +438,13 @@ 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));
-#elif BUILDFLAG(IS_OZONE)
+#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ if (kMayUseVaapiOverX11) {
+ EXPECT_EQ(VaapiPictureFactory::kVaapiImplementationAngle,
+ mock_vaapi_picture_factory_->GetVaapiImplementation(
+ gl::kGLImplementationEGLANGLE));
+ }
+#else
EXPECT_EQ(VaapiPictureFactory::kVaapiImplementationDrm,
mock_vaapi_picture_factory_->GetVaapiImplementation(
gl::kGLImplementationEGLANGLE));
diff -up chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.cc.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.cc
--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.cc.wayland-vaapi 2023-03-30 02:33:53.000000000 +0200
+++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.cc 2023-04-14 21:29:41.777328062 +0200
@@ -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 BUILDFLAG(IS_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;
@@ -680,6 +680,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>;
@@ -702,6 +708,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_;
@@ -723,6 +736,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.
@@ -755,20 +777,18 @@ VADisplayState::VADisplayState()
bool VADisplayState::Initialize() {
base::AutoLock auto_lock(va_lock_);
-#if BUILDFLAG(IS_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;
@@ -783,7 +803,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()) {
@@ -809,13 +829,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 "
@@ -825,18 +851,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_)) {
@@ -1671,6 +1702,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,
@@ -2684,12 +2722,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);
@@ -2703,7 +2742,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,
@@ -3105,7 +3144,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-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.h.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.h
--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.h.wayland-vaapi 2023-03-30 02:33:53.000000000 +0200
+++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.h 2023-04-14 21:29:41.777328062 +0200
@@ -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-112.0.5615.49/media/gpu/vaapi/va_stub_header.fragment.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/va_stub_header.fragment
--- chromium-112.0.5615.49/media/gpu/vaapi/va_stub_header.fragment.wayland-vaapi 2023-03-30 02:33:53.000000000 +0200
+++ chromium-112.0.5615.49/media/gpu/vaapi/va_stub_header.fragment 2023-04-14 21:29:41.777328062 +0200
@@ -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-112.0.5615.49/ui/ozone/platform/x11/ozone_platform_x11.cc.wayland-vaapi chromium-112.0.5615.49/ui/ozone/platform/x11/ozone_platform_x11.cc
--- chromium-112.0.5615.49/ui/ozone/platform/x11/ozone_platform_x11.cc.wayland-vaapi 2023-03-30 02:34:19.000000000 +0200
+++ chromium-112.0.5615.49/ui/ozone/platform/x11/ozone_platform_x11.cc 2023-04-14 21:29:41.778328082 +0200
@@ -197,7 +197,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-112.0.5615.49/ui/ozone/public/ozone_platform.h.wayland-vaapi chromium-112.0.5615.49/ui/ozone/public/ozone_platform.h
--- chromium-112.0.5615.49/ui/ozone/public/ozone_platform.h.wayland-vaapi 2023-03-30 02:34:19.000000000 +0200
+++ chromium-112.0.5615.49/ui/ozone/public/ozone_platform.h 2023-04-14 21:29:41.778328082 +0200
@@ -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