Add HDR playback on Wayland

Author: andrewrabert

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "external/mpvqt"]
 	path = external/mpvqt
 	url = https://invent.kde.org/libraries/mpvqt.git
+[submodule "external/mpv"]
+	path = external/mpv
+	url = https://github.com/andrewrabert/mpv

CMakeLists.txt

@@ -14,6 +14,7 @@ option(CHECK_FOR_UPDATES "Enable checking for new versions of Jellyfin" OFF)
 option(OPENELEC "Make an OpenELEC build" OFF)
 option(LINUX_X11POWER "Enable non D-Bus screensaver management" OFF)
 option(USE_STATIC_MPVQT "Build MpvQt from bundled submodule instead of using system library" OFF)
+option(USE_WAYLAND_SUBSURFACE "Use Wayland subsurface for mpv rendering (Wayland-only, enables HDR)" OFF)
 
 if (NOT CHECK_FOR_UPDATES)
     add_definitions(-DDISABLE_UPDATE_CHECK)

CMakeModules/PlayerConfiguration.cmake

@@ -1,15 +1,44 @@
-# We want OpenGL or OpenGLES2
-find_package(OpenGL)
-if(NOT OPENGL_FOUND)
-  find_package(GLES2)
-  if(NOT GLES2_FOUND)
-    message(FATAL_ERROR "OpenGL or GLES2 is required")
-  else(NOT GLES2_FOUND)
-    set(OPENGL_LIBS ${GLES2_LIBRARY})
-  endif(NOT GLES2_FOUND)
-else(NOT OPENGL_FOUND)
-  set(OPENGL_LIBS ${OPENGL_gl_LIBRARY})
-endif(NOT OPENGL_FOUND)
-
-find_package(MPV REQUIRED)
-include_directories(${MPV_INCLUDE_DIR})
+if(USE_WAYLAND_SUBSURFACE)
+  message(STATUS "Using Wayland subsurface for mpv rendering (HDR enabled)")
+  find_package(Vulkan REQUIRED)
+  find_package(PkgConfig REQUIRED)
+  pkg_check_modules(WAYLAND_CLIENT REQUIRED wayland-client)
+  find_package(Qt6 REQUIRED COMPONENTS GuiPrivate)
+
+  include(WaylandMpvConfiguration)
+  include_directories(${MPV_INCLUDE_DIR})
+  include_directories(${WAYLAND_CLIENT_INCLUDE_DIRS})
+
+  add_compile_definitions(USE_WAYLAND_SUBSURFACE)
+
+  set(WAYLAND_MPV_SOURCES
+    ${CMAKE_SOURCE_DIR}/src/player/WaylandVulkanContext.cpp
+    ${CMAKE_SOURCE_DIR}/src/player/WaylandMpvPlayer.cpp
+    ${CMAKE_SOURCE_DIR}/src/player/wayland-protocols/color-management-v1.c
+  )
+  set(WAYLAND_MPV_LIBS
+    ${MPV_LIBRARY}
+    Vulkan::Vulkan
+    ${WAYLAND_CLIENT_LIBRARIES}
+    Qt6::GuiPrivate
+  )
+else()
+  # We want OpenGL or OpenGLES2
+  find_package(OpenGL)
+  if(NOT OPENGL_FOUND)
+    find_package(GLES2)
+    if(NOT GLES2_FOUND)
+      message(FATAL_ERROR "OpenGL or GLES2 is required")
+    else(NOT GLES2_FOUND)
+      set(OPENGL_LIBS ${GLES2_LIBRARY})
+    endif(NOT GLES2_FOUND)
+  else(NOT OPENGL_FOUND)
+    set(OPENGL_LIBS ${OPENGL_gl_LIBRARY})
+  endif(NOT OPENGL_FOUND)
+
+  find_package(MPV REQUIRED)
+  include_directories(${MPV_INCLUDE_DIR})
+
+  set(WAYLAND_MPV_SOURCES "")
+  set(WAYLAND_MPV_LIBS "")
+endif()

CMakeModules/QtConfiguration.cmake

@@ -34,6 +34,10 @@ if(LINUX_DBUS)
   set(components ${components} DBus)
 endif(LINUX_DBUS)
 
+if(USE_WAYLAND_SUBSURFACE)
+  # We use raw Wayland protocol for color management, not Qt's private classes
+endif()
+
 foreach(COMP ${components})
 	set(mod Qt6${COMP})
 

CMakeModules/WaylandMpvConfiguration.cmake

@@ -0,0 +1,31 @@
+# Build mpv from submodule for Wayland subsurface rendering
+
+set(MPV_SOURCE_DIR "${CMAKE_SOURCE_DIR}/external/mpv")
+set(MPV_BUILD_DIR "${MPV_SOURCE_DIR}/build")
+
+if(NOT EXISTS "${MPV_BUILD_DIR}/libmpv.so")
+    message(STATUS "Building mpv from submodule...")
+    execute_process(
+        COMMAND meson setup build --default-library=shared -Dlibmpv=true
+        WORKING_DIRECTORY ${MPV_SOURCE_DIR}
+        RESULT_VARIABLE MPV_SETUP_RESULT
+    )
+    if(NOT MPV_SETUP_RESULT EQUAL 0)
+        message(FATAL_ERROR "Failed to configure mpv with meson")
+    endif()
+    execute_process(
+        COMMAND meson compile -C build
+        WORKING_DIRECTORY ${MPV_SOURCE_DIR}
+        RESULT_VARIABLE MPV_BUILD_RESULT
+    )
+    if(NOT MPV_BUILD_RESULT EQUAL 0)
+        message(FATAL_ERROR "Failed to build mpv")
+    endif()
+endif()
+
+set(MPV_INCLUDE_DIR "${MPV_SOURCE_DIR}/include")
+set(MPV_LIBRARY "${MPV_BUILD_DIR}/libmpv.so")
+
+# Set RPATH for finding bundled libmpv
+set(CMAKE_BUILD_RPATH "${MPV_BUILD_DIR}")
+set(CMAKE_INSTALL_RPATH "$ORIGIN/../lib")

external/CMakeLists.txt

@@ -31,3 +31,28 @@ if(USE_STATIC_MPVQT)
   file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/MpvQt/MpvAbstractItem "#include \"mpvabstractitem.h\"\n")
   file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/MpvQt/MpvController "#include \"mpvcontroller.h\"\n")
 endif()
+
+# Build mpv from submodule using meson
+set(MPV_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mpv")
+set(MPV_BUILD_DIR "${MPV_SOURCE_DIR}/build")
+
+if(NOT EXISTS "${MPV_BUILD_DIR}/libmpv.so")
+    message(STATUS "Building mpv from submodule...")
+    execute_process(
+        COMMAND meson setup build --default-library=shared -Dlibmpv=true
+        WORKING_DIRECTORY ${MPV_SOURCE_DIR}
+        RESULT_VARIABLE MPV_SETUP_RESULT
+    )
+    if(NOT MPV_SETUP_RESULT EQUAL 0)
+        message(FATAL_ERROR "Failed to configure mpv with meson")
+    endif()
+    execute_process(
+        COMMAND meson compile -C build
+        WORKING_DIRECTORY ${MPV_SOURCE_DIR}
+        RESULT_VARIABLE MPV_BUILD_RESULT
+    )
+    if(NOT MPV_BUILD_RESULT EQUAL 0)
+        message(FATAL_ERROR "Failed to build mpv")
+    endif()
+endif()
+

external/mpv

@@ -54,7 +54,7 @@ foreach(sfile in ${ALL_SRCS})
 endforeach(sfile in ${ALL_SRCS})
 
 # Build core sources as static library for reuse by tests
-add_library(jmp_core STATIC ${ALL_SRCS})
+add_library(jmp_core STATIC ${ALL_SRCS} ${WAYLAND_MPV_SOURCES})
 
 file(GLOB_RECURSE RESOURCE_FILES CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/resources/*)
 file(GLOB_RECURSE NATIVE_FILES CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/native/*)
@@ -189,6 +189,7 @@ target_link_libraries(jmp_core
   shared
   ${MPV_LIBRARY}
   ${OPENGL_LIBS}
+  ${WAYLAND_MPV_LIBS}
   ${QT6_LIBRARIES}
   ${OS_LIBS}
   ${EXTRA_LIBS}

src/CMakeLists.txt

@@ -1,12 +1,16 @@
 #include <QGuiApplication>
 #include <QApplication>
+#include <memory>
 #include <QDateTime>
 #include <QFileInfo>
 #include <QIcon>
 #include <QtQml>
 #include <optional>
 #include <Qt>
 #include <QtWebEngineQuick>
+#ifdef USE_WAYLAND_SUBSURFACE
+#include <QVulkanInstance>
+#endif
 #include <qtwebenginecoreglobal.h>
 #include <QtWebEngineCore/QWebEngineProfile>
 #include <QErrorMessage>
@@ -127,12 +131,6 @@ void ShowLicenseInfo()
   printf("%.*s\n", static_cast<int>(contents.size()), contents.data());
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////
-QStringList g_qtFlags = {
-  "--enable-gpu-rasterization",
-  "--disable-features=MediaSessionService"
-};
-
 /////////////////////////////////////////////////////////////////////////////////////////
 int main(int argc, char *argv[])
 {
@@ -198,11 +196,39 @@ int main(int argc, char *argv[])
     parser.addOption(deleteProfileOption);
     parser.addOption(createProfileOption);
 
+#ifdef USE_WAYLAND_SUBSURFACE
+    // Check if we'll use Wayland Vulkan mode - needs to be early for Qt flags
+    static bool isWayland = qEnvironmentVariable("XDG_SESSION_TYPE") == "wayland" ||
+                            qEnvironmentVariable("QT_QPA_PLATFORM").contains("wayland");
+#endif
+
+    // Qt flags for WebEngine - skip on Wayland Vulkan to avoid conflicts
+    QStringList g_qtFlags;
+#ifdef USE_WAYLAND_SUBSURFACE
+    if (!isWayland) {
+      g_qtFlags << "--enable-gpu-rasterization" << "--disable-features=MediaSessionService";
+    }
+#else
+    g_qtFlags << "--enable-gpu-rasterization" << "--disable-features=MediaSessionService";
+#endif
+
     char **newArgv = appendCommandLineArguments(argc, argv, g_qtFlags);
     int newArgc = argc + g_qtFlags.size();
 
     preinitQt();
 
+#ifdef USE_WAYLAND_SUBSURFACE
+    if (!isWayland) {
+      detectOpenGLEarly();
+      QQuickWindow::setGraphicsApi(QSGRendererInterface::OpenGL);
+      QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
+    }
+#else
+    detectOpenGLEarly();
+    QQuickWindow::setGraphicsApi(QSGRendererInterface::OpenGL);
+    QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
+#endif
+
     QStringList arguments;
     for (int i = 0; i < argc; i++)
       arguments << QString::fromLatin1(argv[i]);
@@ -230,10 +256,6 @@ int main(int argc, char *argv[])
 #endif
     }
 
-    detectOpenGLEarly();
-    QQuickWindow::setGraphicsApi(QSGRendererInterface::OpenGL);
-    QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
-
     if (parser.isSet("help"))
     {
       // Get Qt's generated help, insert section header before profile options
@@ -423,9 +445,17 @@ int main(int argc, char *argv[])
 #endif
 
     QStringList chromiumFlags;
+#ifdef USE_WAYLAND_SUBSURFACE
+    if (isWayland) {
+      // Disable GPU compositing in Chromium - jellyfin-web triggers Vulkan crash with radeon
+      chromiumFlags << "--disable-gpu-compositing";
+    } else {
+#endif
 #ifdef Q_OS_LINUX
-    // Disable QtWebEngine's automatic MPRIS registration - we handle it ourselves
-    chromiumFlags << "--disable-features=MediaSessionService,HardwareMediaKeyHandling";
+      chromiumFlags << "--disable-features=MediaSessionService,HardwareMediaKeyHandling";
+#endif
+#ifdef USE_WAYLAND_SUBSURFACE
+    }
 #endif
     // Disable pinch-to-zoom if browser zoom is not allowed
     QVariant allowZoom = SettingsComponent::readPreinitValue(SETTINGS_SECTION_MAIN, "allowBrowserZoom");
@@ -441,27 +471,65 @@ int main(int argc, char *argv[])
     if (parser.isSet("remote-debugging-port"))
       qputenv("QTWEBENGINE_REMOTE_DEBUGGING", parser.value("remote-debugging-port").toUtf8());
 
+    // Must initialize QtWebEngine before QGuiApplication (per Qt docs)
     QtWebEngineQuick::initialize();
+
+#ifdef USE_WAYLAND_SUBSURFACE
+    // Set Vulkan graphics API for Wayland (must be after QtWebEngineQuick::initialize, before QApplication)
+    if (isWayland) {
+      QQuickWindow::setGraphicsApi(QSGRendererInterface::Vulkan);
+    }
+#endif
+
+#ifdef USE_WAYLAND_SUBSURFACE
+    // Use QGuiApplication for Vulkan (QApplication's widget stuff conflicts with Vulkan)
+    std::unique_ptr<QCoreApplication> appPtr;
+    if (isWayland) {
+      appPtr.reset(new QGuiApplication(newArgc, newArgv));
+    } else {
+      appPtr.reset(new QApplication(newArgc, newArgv));
+    }
+    auto& app = *appPtr;
+#else
     QApplication app(newArgc, newArgv);
+#endif
+
+#ifdef USE_WAYLAND_SUBSURFACE
+    // Create Vulkan instance for Qt (must be after QApplication, before QML engine)
+    static QVulkanInstance vulkanInstance;
+    if (isWayland) {
+      vulkanInstance.setApiVersion(QVersionNumber(1, 2));
+      if (!vulkanInstance.create()) {
+        qCritical() << "Failed to create Qt Vulkan instance";
+        return EXIT_FAILURE;
+      }
+    }
+#endif
 
-#if defined(Q_OS_WIN) 
+#if defined(Q_OS_WIN)
     // Setting window icon on OSX will break user ability to change it
-    app.setWindowIcon(QIcon(":/images/icon.png"));
+    qobject_cast<QGuiApplication*>(&app)->setWindowIcon(QIcon(":/images/icon.png"));
 #endif
 
 #if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD)
   	// Set window icon on Linux using system icon theme
-  	app.setWindowIcon(QIcon::fromTheme("org.jellyfin.JellyfinDesktop", QIcon(":/images/icon.png")));
+  	qobject_cast<QGuiApplication*>(&app)->setWindowIcon(QIcon::fromTheme("org.jellyfin.JellyfinDesktop", QIcon(":/images/icon.png")));
     // Set app id for Wayland compositor window icon
-    app.setDesktopFileName("org.jellyfin.JellyfinDesktop");
+    qobject_cast<QGuiApplication*>(&app)->setDesktopFileName("org.jellyfin.JellyfinDesktop");
 #endif
 
     // Configure default WebEngineProfile paths early (profile is already set)
-    {
+    // Skip early access on Wayland Vulkan - accessing defaultProfile() here triggers
+    // Chromium GPU init which crashes. Will be set later after QML engine loads.
+#ifdef USE_WAYLAND_SUBSURFACE
+    if (!isWayland) {
+#endif
       QWebEngineProfile* defaultProfile = QWebEngineProfile::defaultProfile();
       defaultProfile->setCachePath(ProfileManager::activeProfile().cacheDir("QtWebEngine"));
       defaultProfile->setPersistentStoragePath(ProfileManager::activeProfile().dataDir("QtWebEngine"));
+#ifdef USE_WAYLAND_SUBSURFACE
     }
+#endif
 
 #if defined(Q_OS_MAC) && defined(NDEBUG)
     PFMoveToApplicationsFolderIfNecessary();
@@ -476,7 +544,7 @@ int main(int argc, char *argv[])
 
 #ifdef Q_OS_UNIX
     // install signals handlers for proper app closing.
-    SignalManager signalManager(&app);
+    SignalManager signalManager(qobject_cast<QGuiApplication*>(&app));
     Q_UNUSED(signalManager);
 #endif
 
@@ -497,7 +565,14 @@ int main(int argc, char *argv[])
     SettingsComponent::Get().setCommandLineValues(parser.optionNames());
 
     // Set user agent now that SystemComponent is available
-    QWebEngineProfile::defaultProfile()->setHttpUserAgent(SystemComponent::Get().getUserAgent());
+    // Skip early access on Wayland Vulkan - will be set in objectCreated callback
+#ifdef USE_WAYLAND_SUBSURFACE
+    if (!isWayland) {
+#endif
+      QWebEngineProfile::defaultProfile()->setHttpUserAgent(SystemComponent::Get().getUserAgent());
+#ifdef USE_WAYLAND_SUBSURFACE
+    }
+#endif
 
     // load QtWebChannel so that we can register our components with it.
     QQmlApplicationEngine *engine = Globals::Engine();
@@ -517,6 +592,20 @@ int main(int argc, char *argv[])
 
       QQuickWindow* window = Globals::MainWindow();
 
+#ifdef USE_WAYLAND_SUBSURFACE
+      // Set Vulkan instance on window when using Vulkan
+      if (isWayland && vulkanInstance.isValid()) {
+        window->setVulkanInstance(&vulkanInstance);
+      }
+      // Deferred WebEngineProfile setup for Wayland Vulkan
+      if (isWayland) {
+        QWebEngineProfile* defaultProfile = QWebEngineProfile::defaultProfile();
+        defaultProfile->setCachePath(ProfileManager::activeProfile().cacheDir("QtWebEngine"));
+        defaultProfile->setPersistentStoragePath(ProfileManager::activeProfile().dataDir("QtWebEngine"));
+        defaultProfile->setHttpUserAgent(SystemComponent::Get().getUserAgent());
+      }
+#endif
+
       // Set window flags for proper popup handling (e.g., WebEngineView dropdowns)
       window->setFlags(window->flags() | Qt::WindowFullscreenButtonHint);