From 4c7ea4b5564d224d60a080d105ae299407239dcb Mon Sep 17 00:00:00 2001

From: Rozhuk Ivan <rozhuk.im@gmail.com>

Date: Sun, 10 Nov 2024 02:24:16 +0200

Subject: [PATCH] Revert "CDRMAtomic: add support for using DRM_MODE_ATOMIC_NONBLOCK"

This reverts commit e9710033029d86efa0c18a6121d2c6376f74ef10.

---

 xbmc/windowing/gbm/WinSystemGbm.cpp            |  8 ++++----

 xbmc/windowing/gbm/WinSystemGbm.h              |  2 +-

 xbmc/windowing/gbm/WinSystemGbmEGLContext.cpp  | 11 -----------

 xbmc/windowing/gbm/WinSystemGbmEGLContext.h    |  3 ---

 xbmc/windowing/gbm/WinSystemGbmGLContext.cpp   | 26 +-------------------------

 xbmc/windowing/gbm/WinSystemGbmGLESContext.cpp | 27 +--------------------------

 xbmc/windowing/gbm/drm/DRMAtomic.cpp           | 19 +++----------------

 xbmc/windowing/gbm/drm/DRMAtomic.h             |  2 +-

 xbmc/windowing/gbm/drm/DRMLegacy.cpp           |  2 +-

 xbmc/windowing/gbm/drm/DRMLegacy.h             |  2 +-

 xbmc/windowing/gbm/drm/DRMUtils.h              | 13 +------------

 xbmc/windowing/gbm/drm/OffScreenModeSetting.h  |  2 +-

 12 files changed, 15 insertions(+), 102 deletions(-)

diff --git a/xbmc/windowing/gbm/WinSystemGbm.cpp b/xbmc/windowing/gbm/WinSystemGbm.cpp

index 6569718..da56094 100644

--- xbmc/windowing/gbm/WinSystemGbm.cpp

+++ xbmc/windowing/gbm/WinSystemGbm.cpp

@@ -269,64 +269,64 @@ bool CWinSystemGbm::DisplayHardwareScalingEnabled()

 void CWinSystemGbm::UpdateDisplayHardwareScaling(const RESOLUTION_INFO& resInfo)

 {

   if (!DisplayHardwareScalingEnabled())

     return;

   //! @todo The PR that made the res struct constant was abandoned due to drama.

   // It should be const-corrected and changed here.

   RESOLUTION_INFO& resMutable = const_cast<RESOLUTION_INFO&>(resInfo);

   SetFullScreen(true, resMutable, false);

 }

-void CWinSystemGbm::FlipPage(bool rendered, bool videoLayer, bool async)

+void CWinSystemGbm::FlipPage(bool rendered, bool videoLayer)

 {

   if (m_videoLayerBridge && !videoLayer)

   {

     // disable video plane when video layer no longer is active

     m_videoLayerBridge->Disable();

   }

   struct gbm_bo *bo = nullptr;

   if (rendered)

   {

     bo = m_GBM->GetDevice().GetSurface().LockFrontBuffer().Get();

   }

-  m_DRM->FlipPage(bo, rendered, videoLayer, async);

+  m_DRM->FlipPage(bo, rendered, videoLayer);

   if (m_videoLayerBridge && !videoLayer)

   {

     // delete video layer bridge when video layer no longer is active

     m_videoLayerBridge.reset();

   }

 }

 bool CWinSystemGbm::UseLimitedColor()

 {

   return CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_VIDEOSCREEN_LIMITEDRANGE);

 }

 bool CWinSystemGbm::Hide()

 {

   bool ret = m_DRM->SetActive(false);

-  FlipPage(false, false, false);

+  FlipPage(false, false);

   return ret;

 }

 bool CWinSystemGbm::Show(bool raise)

 {

   bool ret = m_DRM->SetActive(true);

-  FlipPage(false, false, false);

+  FlipPage(false, false);

   return ret;

 }

 void CWinSystemGbm::Register(IDispResource *resource)

 {

   std::unique_lock<CCriticalSection> lock(m_resourceSection);

   m_resources.push_back(resource);

 }

 void CWinSystemGbm::Unregister(IDispResource *resource)

 {

   std::unique_lock<CCriticalSection> lock(m_resourceSection);

diff --git a/xbmc/windowing/gbm/WinSystemGbm.h b/xbmc/windowing/gbm/WinSystemGbm.h

index 9609675..8993b6d 100644

--- xbmc/windowing/gbm/WinSystemGbm.h

+++ xbmc/windowing/gbm/WinSystemGbm.h

@@ -40,25 +40,25 @@ public:

   ~CWinSystemGbm() override;

   const std::string GetName() override { return "gbm"; }

   bool InitWindowSystem() override;

   bool DestroyWindowSystem() override;

   bool ResizeWindow(int newWidth, int newHeight, int newLeft, int newTop) override;

   bool SetFullScreen(bool fullScreen, RESOLUTION_INFO& res, bool blankOtherDisplays) override;

   bool DisplayHardwareScalingEnabled() override;

   void UpdateDisplayHardwareScaling(const RESOLUTION_INFO& resInfo) override;

-  void FlipPage(bool rendered, bool videoLayer, bool async);

+  void FlipPage(bool rendered, bool videoLayer);

   bool CanDoWindowed() override { return false; }

   void UpdateResolutions() override;

   bool UseLimitedColor() override;

   bool Hide() override;

   bool Show(bool raise = true) override;

   void Register(IDispResource* resource) override;

   void Unregister(IDispResource* resource) override;

   bool SetHDR(const VideoPicture* videoPicture) override;

diff --git a/xbmc/windowing/gbm/WinSystemGbmEGLContext.cpp b/xbmc/windowing/gbm/WinSystemGbmEGLContext.cpp

index fac914d..2fb742e 100644

--- xbmc/windowing/gbm/WinSystemGbmEGLContext.cpp

+++ xbmc/windowing/gbm/WinSystemGbmEGLContext.cpp

@@ -49,35 +49,24 @@ bool CWinSystemGbmEGLContext::InitWindowSystemEGL(EGLint renderableType, EGLint 

     if (!m_eglContext.ChooseConfig(renderableType, CDRMUtils::FourCCWithAlpha(visualId)) &&

         !m_eglContext.ChooseConfig(renderableType, CDRMUtils::FourCCWithoutAlpha(visualId)))

     {

       return false;

     }

   }

   if (!CreateContext())

   {

     return false;

   }

-  if (CEGLUtils::HasExtension(m_eglContext.GetEGLDisplay(), "EGL_ANDROID_native_fence_sync") &&

-      CEGLUtils::HasExtension(m_eglContext.GetEGLDisplay(), "EGL_KHR_fence_sync"))

-  {

-    m_eglFence = std::make_unique<KODI::UTILS::EGL::CEGLFence>(m_eglContext.GetEGLDisplay());

-  }

-  else

-  {

-    CLog::Log(LOGWARNING, "[GBM] missing support for EGL_KHR_fence_sync and "

-                          "EGL_ANDROID_native_fence_sync - performance may be impacted");

-  }

-

   return true;

 }

 bool CWinSystemGbmEGLContext::CreateNewWindow(const std::string& name,

                                               bool fullScreen,

                                               RESOLUTION_INFO& res)

 {

   //Notify other subsystems that we change resolution

   OnLostDevice();

   if (!DestroyWindow())

   {

diff --git a/xbmc/windowing/gbm/WinSystemGbmEGLContext.h b/xbmc/windowing/gbm/WinSystemGbmEGLContext.h

index fbd5235..84f863d 100644

--- xbmc/windowing/gbm/WinSystemGbmEGLContext.h

+++ xbmc/windowing/gbm/WinSystemGbmEGLContext.h

@@ -1,24 +1,23 @@

 /*

  *  Copyright (C) 2005-2018 Team Kodi

  *  This file is part of Kodi - https://kodi.tv

  *

  *  SPDX-License-Identifier: GPL-2.0-or-later

  *  See LICENSES/README.md for more information.

  */

 #pragma once

 #include "WinSystemGbm.h"

-#include "utils/EGLFence.h"

 #include "utils/EGLUtils.h"

 #include "windowing/linux/WinSystemEGL.h"

 #include <memory>

 namespace KODI

 {

 namespace WINDOWING

 {

 namespace GBM

 {

@@ -38,24 +37,22 @@ public:

 protected:

   CWinSystemGbmEGLContext(EGLenum platform, std::string const& platformExtension)

     : CWinSystemEGL{platform, platformExtension}

   {}

   /**

    * Inheriting classes should override InitWindowSystem() without parameters

    * and call this function there with appropriate parameters

    */

   bool InitWindowSystemEGL(EGLint renderableType, EGLint apiType);

   virtual bool CreateContext() = 0;

-  std::unique_ptr<KODI::UTILS::EGL::CEGLFence> m_eglFence;

-

   struct delete_CVaapiProxy

   {

     void operator()(CVaapiProxy *p) const;

   };

   std::unique_ptr<CVaapiProxy, delete_CVaapiProxy> m_vaapiProxy;

 };

 }

 }

 }

diff --git a/xbmc/windowing/gbm/WinSystemGbmGLContext.cpp b/xbmc/windowing/gbm/WinSystemGbmGLContext.cpp

index adbb539..e4ff49c 100644

--- xbmc/windowing/gbm/WinSystemGbmGLContext.cpp

+++ xbmc/windowing/gbm/WinSystemGbmGLContext.cpp

@@ -110,55 +110,31 @@ bool CWinSystemGbmGLContext::SetFullScreen(bool fullScreen, RESOLUTION_INFO& res

   return true;

 }

 void CWinSystemGbmGLContext::PresentRender(bool rendered, bool videoLayer)

 {

   if (!m_bRenderCreated)

     return;

   if (rendered || videoLayer)

   {

     if (rendered)

     {

-#if defined(EGL_ANDROID_native_fence_sync) && defined(EGL_KHR_fence_sync)

-      if (m_eglFence)

-      {

-        int fd = m_DRM->TakeOutFenceFd();

-        if (fd != -1)

-        {

-          m_eglFence->CreateKMSFence(fd);

-          m_eglFence->WaitSyncGPU();

-        }

-

-        m_eglFence->CreateGPUFence();

-      }

-#endif

-

       if (!m_eglContext.TrySwapBuffers())

       {

         CEGLUtils::Log(LOGERROR, "eglSwapBuffers failed");

         throw std::runtime_error("eglSwapBuffers failed");

       }

-

-#if defined(EGL_ANDROID_native_fence_sync) && defined(EGL_KHR_fence_sync)

-      if (m_eglFence)

-      {

-        int fd = m_eglFence->FlushFence();

-        m_DRM->SetInFenceFd(fd);

-

-        m_eglFence->WaitSyncCPU();

-      }

-#endif

     }

-    CWinSystemGbm::FlipPage(rendered, videoLayer, static_cast<bool>(m_eglFence));

+    CWinSystemGbm::FlipPage(rendered, videoLayer);

     if (m_dispReset && m_dispResetTimer.IsTimePast())

     {

       CLog::Log(LOGDEBUG, "CWinSystemGbmGLContext::{} - Sending display reset to all clients",

                 __FUNCTION__);

       m_dispReset = false;

       std::unique_lock<CCriticalSection> lock(m_resourceSection);

       for (auto resource : m_resources)

         resource->OnResetDisplay();

     }

   }

diff --git a/xbmc/windowing/gbm/WinSystemGbmGLESContext.cpp b/xbmc/windowing/gbm/WinSystemGbmGLESContext.cpp

index ad80abf..0d071c3 100644

--- xbmc/windowing/gbm/WinSystemGbmGLESContext.cpp

+++ xbmc/windowing/gbm/WinSystemGbmGLESContext.cpp

@@ -119,56 +119,31 @@ bool CWinSystemGbmGLESContext::SetFullScreen(bool fullScreen, RESOLUTION_INFO& r

   return true;

 }

 void CWinSystemGbmGLESContext::PresentRender(bool rendered, bool videoLayer)

 {

   if (!m_bRenderCreated)

     return;

   if (rendered || videoLayer)

   {

     if (rendered)

     {

-#if defined(EGL_ANDROID_native_fence_sync) && defined(EGL_KHR_fence_sync)

-      if (m_eglFence)

-      {

-        int fd = m_DRM->TakeOutFenceFd();

-        if (fd != -1)

-        {

-          m_eglFence->CreateKMSFence(fd);

-          m_eglFence->WaitSyncGPU();

-        }

-

-        m_eglFence->CreateGPUFence();

-      }

-#endif

-

       if (!m_eglContext.TrySwapBuffers())

       {

         CEGLUtils::Log(LOGERROR, "eglSwapBuffers failed");

         throw std::runtime_error("eglSwapBuffers failed");

       }

-

-#if defined(EGL_ANDROID_native_fence_sync) && defined(EGL_KHR_fence_sync)

-      if (m_eglFence)

-      {

-        int fd = m_eglFence->FlushFence();

-        m_DRM->SetInFenceFd(fd);

-

-        m_eglFence->WaitSyncCPU();

-      }

-#endif

     }

-

-    CWinSystemGbm::FlipPage(rendered, videoLayer, static_cast<bool>(m_eglFence));

+    CWinSystemGbm::FlipPage(rendered, videoLayer);

     if (m_dispReset && m_dispResetTimer.IsTimePast())

     {

       CLog::Log(LOGDEBUG, "CWinSystemGbmGLESContext::{} - Sending display reset to all clients",

                 __FUNCTION__);

       m_dispReset = false;

       std::unique_lock<CCriticalSection> lock(m_resourceSection);

       for (auto resource : m_resources)

         resource->OnResetDisplay();

     }

   }

diff --git a/xbmc/windowing/gbm/drm/DRMAtomic.cpp b/xbmc/windowing/gbm/drm/DRMAtomic.cpp

index ff7f137..029b5ca 100644

--- xbmc/windowing/gbm/drm/DRMAtomic.cpp

+++ xbmc/windowing/gbm/drm/DRMAtomic.cpp

@@ -102,107 +102,94 @@ void CDRMAtomic::DrmAtomicCommit(int fb_id, int flags, bool rendered, bool video

     AddProperty(m_gui_plane, "CRTC_Y", 0);

     //! @todo: disabled until upstream kernel changes are merged

     // if (DisplayHardwareScalingEnabled())

     // {

     //   SetScalingFilter(m_gui_plane, "SCALING_FILTER", "Nearest Neighbor");

     // }

     // else

     {

       AddProperty(m_gui_plane, "CRTC_W", m_mode->hdisplay);

       AddProperty(m_gui_plane, "CRTC_H", m_mode->vdisplay);

     }

-    if (m_inFenceFd != -1)

-    {

-      AddProperty(m_crtc, "OUT_FENCE_PTR", reinterpret_cast<uint64_t>(&m_outFenceFd));

-      AddProperty(m_gui_plane, "IN_FENCE_FD", m_inFenceFd);

-    }

   }

   else if (videoLayer && !CServiceBroker::GetGUI()->GetWindowManager().HasVisibleControls())

   {

     // disable gui plane when video layer is active and gui has no visible controls

     AddProperty(m_gui_plane, "FB_ID", 0);

     AddProperty(m_gui_plane, "CRTC_ID", 0);

   }

   if (CServiceBroker::GetLogging().CanLogComponent(LOGWINDOWING))

     m_req->LogAtomicRequest();

   auto ret = drmModeAtomicCommit(m_fd, m_req->Get(), flags | DRM_MODE_ATOMIC_TEST_ONLY, nullptr);

   if (ret < 0)

   {

     CLog::Log(LOGERROR,

               "CDRMAtomic::{} - test commit failed: ({}) - falling back to last successful atomic "

               "request",

               __FUNCTION__, strerror(errno));

     auto oldRequest = m_atomicRequestQueue.front().get();

     CDRMAtomicRequest::LogAtomicDiff(m_req, oldRequest);

     m_req = oldRequest;

     // update the old atomic request with the new fb id to avoid tearing

     if (rendered)

       AddProperty(m_gui_plane, "FB_ID", fb_id);

   }

   ret = drmModeAtomicCommit(m_fd, m_req->Get(), flags, nullptr);

   if (ret < 0)

   {

     CLog::Log(LOGERROR, "CDRMAtomic::{} - atomic commit failed: {}", __FUNCTION__,

               strerror(errno));

   }

-  if (m_inFenceFd != -1)

-  {

-    close(m_inFenceFd);

-    m_inFenceFd = -1;

-  }

-

   if (flags & DRM_MODE_ATOMIC_ALLOW_MODESET)

   {

     if (drmModeDestroyPropertyBlob(m_fd, blob_id) != 0)

       CLog::Log(LOGERROR, "CDRMAtomic::{} - failed to destroy property blob: {}", __FUNCTION__,

                 strerror(errno));

   }

   if (m_atomicRequestQueue.size() > 1)

     m_atomicRequestQueue.pop_back();

   m_atomicRequestQueue.emplace_back(std::make_unique<CDRMAtomicRequest>());

   m_req = m_atomicRequestQueue.back().get();

 }

-void CDRMAtomic::FlipPage(struct gbm_bo* bo, bool rendered, bool videoLayer, bool async)

+void CDRMAtomic::FlipPage(struct gbm_bo *bo, bool rendered, bool videoLayer)

 {

   struct drm_fb *drm_fb = nullptr;

-  uint32_t flags = 0;

   if (rendered)

   {

     if (videoLayer)

       m_gui_plane->SetFormat(CDRMUtils::FourCCWithAlpha(m_gui_plane->GetFormat()));

     else

       m_gui_plane->SetFormat(CDRMUtils::FourCCWithoutAlpha(m_gui_plane->GetFormat()));

     drm_fb = CDRMUtils::DrmFbGetFromBo(bo);

     if (!drm_fb)

     {

       CLog::Log(LOGERROR, "CDRMAtomic::{} - Failed to get a new FBO", __FUNCTION__);

       return;

     }

-

-    if (async && !m_need_modeset)

-      flags |= DRM_MODE_ATOMIC_NONBLOCK;

   }

+  uint32_t flags = 0;

+

   if (m_need_modeset)

   {

     flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;

     m_need_modeset = false;

     CLog::Log(LOGDEBUG, "CDRMAtomic::{} - Execute modeset at next commit", __FUNCTION__);

   }

   DrmAtomicCommit(!drm_fb ? 0 : drm_fb->fb_id, flags, rendered, videoLayer);

 }

 bool CDRMAtomic::InitDrm()

 {

diff --git a/xbmc/windowing/gbm/drm/DRMAtomic.h b/xbmc/windowing/gbm/drm/DRMAtomic.h

index 6b19657..ca2cd9a 100644

--- xbmc/windowing/gbm/drm/DRMAtomic.h

+++ xbmc/windowing/gbm/drm/DRMAtomic.h

@@ -18,25 +18,25 @@

 namespace KODI

 {

 namespace WINDOWING

 {

 namespace GBM

 {

 class CDRMAtomic : public CDRMUtils

 {

 public:

   CDRMAtomic() = default;

   ~CDRMAtomic() override = default;

-  void FlipPage(struct gbm_bo* bo, bool rendered, bool videoLayer, bool async) override;

+  void FlipPage(struct gbm_bo* bo, bool rendered, bool videoLayer) override;

   bool SetVideoMode(const RESOLUTION_INFO& res, struct gbm_bo* bo) override;

   bool SetActive(bool active) override;

   bool InitDrm() override;

   void DestroyDrm() override;

   bool AddProperty(CDRMObject* object, const char* name, uint64_t value);

   bool DisplayHardwareScalingEnabled();

 private:

   void DrmAtomicCommit(int fb_id, int flags, bool rendered, bool videoLayer);

   bool SetScalingFilter(CDRMObject* object, const char* name, const char* type);

diff --git a/xbmc/windowing/gbm/drm/DRMLegacy.cpp b/xbmc/windowing/gbm/drm/DRMLegacy.cpp

index 4e9c3a6..418d067 100644

--- xbmc/windowing/gbm/drm/DRMLegacy.cpp

+++ xbmc/windowing/gbm/drm/DRMLegacy.cpp

@@ -99,25 +99,25 @@ bool CDRMLegacy::QueueFlip(struct gbm_bo *bo)

   auto ret = drmModePageFlip(m_fd, m_crtc->GetCrtcId(), drm_fb->fb_id, DRM_MODE_PAGE_FLIP_EVENT,

                              &flip_happening);

   if(ret)

   {

     CLog::Log(LOGDEBUG, "CDRMLegacy::{} - failed to queue DRM page flip", __FUNCTION__);

     return false;

   }

   return true;

 }

-void CDRMLegacy::FlipPage(struct gbm_bo* bo, bool rendered, bool videoLayer, bool async)

+void CDRMLegacy::FlipPage(struct gbm_bo *bo, bool rendered, bool videoLayer)

 {

   if (rendered || videoLayer)

   {

     flip_happening = QueueFlip(bo);

     WaitingForFlip();

   }

 }

 bool CDRMLegacy::InitDrm()

 {

   if (!CDRMUtils::OpenDrm(true))

     return false;

diff --git a/xbmc/windowing/gbm/drm/DRMLegacy.h b/xbmc/windowing/gbm/drm/DRMLegacy.h

index e763f29..2b7ff45 100644

--- xbmc/windowing/gbm/drm/DRMLegacy.h

+++ xbmc/windowing/gbm/drm/DRMLegacy.h

@@ -13,25 +13,25 @@

 namespace KODI

 {

 namespace WINDOWING

 {

 namespace GBM

 {

 class CDRMLegacy : public CDRMUtils

 {

 public:

   CDRMLegacy() = default;

   ~CDRMLegacy() override = default;

-  void FlipPage(struct gbm_bo* bo, bool rendered, bool videoLayer, bool async) override;

+  void FlipPage(struct gbm_bo* bo, bool rendered, bool videoLayer) override;

   bool SetVideoMode(const RESOLUTION_INFO& res, struct gbm_bo* bo) override;

   bool SetActive(bool active) override;

   bool InitDrm() override;

 private:

   bool WaitingForFlip();

   bool QueueFlip(struct gbm_bo *bo);

   static void PageFlipHandler(int fd, unsigned int frame, unsigned int sec,

                               unsigned int usec, void *data);

 };

 }

diff --git a/xbmc/windowing/gbm/drm/DRMUtils.h b/xbmc/windowing/gbm/drm/DRMUtils.h

index f92f716..5327e35 100644

--- xbmc/windowing/gbm/drm/DRMUtils.h

+++ xbmc/windowing/gbm/drm/DRMUtils.h

@@ -6,98 +6,87 @@

  *  See LICENSES/README.md for more information.

  */

 #pragma once

 #include "DRMConnector.h"

 #include "DRMCrtc.h"

 #include "DRMEncoder.h"

 #include "DRMPlane.h"

 #include "windowing/Resolution.h"

 #include "windowing/gbm/GBMUtils.h"

-#include <utility>

 #include <vector>

 #include <gbm.h>

 #include <xf86drm.h>

 namespace KODI

 {

 namespace WINDOWING

 {

 namespace GBM

 {

 struct drm_fb

 {

   struct gbm_bo *bo = nullptr;

   uint32_t fb_id;

   uint32_t format;

 };

 class CDRMUtils

 {

 public:

   CDRMUtils() = default;

   virtual ~CDRMUtils();

-  virtual void FlipPage(struct gbm_bo* bo, bool rendered, bool videoLayer, bool async) {}

+  virtual void FlipPage(struct gbm_bo* bo, bool rendered, bool videoLayer) {}

   virtual bool SetVideoMode(const RESOLUTION_INFO& res, struct gbm_bo* bo) { return false; }

   virtual bool SetActive(bool active) { return false; }

   virtual bool InitDrm();

   virtual void DestroyDrm();

   int GetFileDescriptor() const { return m_fd; }

   int GetRenderNodeFileDescriptor() const { return m_renderFd; }

   const char* GetRenderDevicePath() const { return m_renderDevicePath; }

   CDRMPlane* GetVideoPlane() const { return m_video_plane; }

   CDRMPlane* GetGuiPlane() const { return m_gui_plane; }

   CDRMCrtc* GetCrtc() const { return m_crtc; }

   CDRMConnector* GetConnector() const { return m_connector; }

   std::vector<std::string> GetConnectedConnectorNames();

   virtual RESOLUTION_INFO GetCurrentMode();

   virtual std::vector<RESOLUTION_INFO> GetModes();

   virtual bool SetMode(const RESOLUTION_INFO& res);

   static uint32_t FourCCWithAlpha(uint32_t fourcc);

   static uint32_t FourCCWithoutAlpha(uint32_t fourcc);

-  void SetInFenceFd(int fd) { m_inFenceFd = fd; }

-  int TakeOutFenceFd()

-  {

-    int fd{-1};

-    return std::exchange(m_outFenceFd, fd);

-  }

-

 protected:

   bool OpenDrm(bool needConnector);

   drm_fb* DrmFbGetFromBo(struct gbm_bo *bo);

   int m_fd;

   CDRMConnector* m_connector{nullptr};

   CDRMEncoder* m_encoder{nullptr};

   CDRMCrtc* m_crtc{nullptr};

   CDRMCrtc* m_orig_crtc{nullptr};

   CDRMPlane* m_video_plane{nullptr};

   CDRMPlane* m_gui_plane{nullptr};

   drmModeModeInfo *m_mode = nullptr;

   int m_width = 0;

   int m_height = 0;

-  int m_inFenceFd{-1};

-  int m_outFenceFd{-1};

-

   std::vector<std::unique_ptr<CDRMPlane>> m_planes;

 private:

   bool FindConnector();

   bool FindEncoder();

   bool FindCrtc();

   bool FindPlanes();

   bool FindPreferredMode();

   bool RestoreOriginalMode();

   RESOLUTION_INFO GetResolutionInfo(drmModeModeInfoPtr mode);

   void PrintDrmDeviceInfo(drmDevicePtr device);

diff --git a/xbmc/windowing/gbm/drm/OffScreenModeSetting.h b/xbmc/windowing/gbm/drm/OffScreenModeSetting.h

index bba0db9..4270d4e 100644

--- xbmc/windowing/gbm/drm/OffScreenModeSetting.h

+++ xbmc/windowing/gbm/drm/OffScreenModeSetting.h

@@ -13,25 +13,25 @@

 namespace KODI

 {

 namespace WINDOWING

 {

 namespace GBM

 {

 class COffScreenModeSetting : public CDRMUtils

 {

 public:

   COffScreenModeSetting() = default;

   ~COffScreenModeSetting() override = default;

-  void FlipPage(struct gbm_bo* bo, bool rendered, bool videoLayer, bool async) override {}

+  void FlipPage(struct gbm_bo *bo, bool rendered, bool videoLayer) override {}

   bool SetVideoMode(const RESOLUTION_INFO& res, struct gbm_bo *bo) override { return false; }

   bool SetActive(bool active) override { return false; }

   bool InitDrm() override;

   void DestroyDrm() override {}

   RESOLUTION_INFO GetCurrentMode() override;

   std::vector<RESOLUTION_INFO> GetModes() override;

   bool SetMode(const RESOLUTION_INFO& res) override { return true; }

 };

 }

 }

--

libgit2 1.8.4