xbmc/windowing/gbm/WinSystemGbm.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "WinSystemGbm.h"
  10
  11 #include "GBMDPMSSupport.h"
  12 #include "OptionalsReg.h"
  13 #include "ServiceBroker.h"
  14 #include "VideoSyncGbm.h"
  15 #include "cores/VideoPlayer/Buffers/VideoBufferDRMPRIME.h"
  16 #include "cores/VideoPlayer/VideoReferenceClock.h"
  17 #include "drm/DRMAtomic.h"
  18 #include "drm/DRMLegacy.h"
  19 #include "drm/OffScreenModeSetting.h"
  20 #include "messaging/ApplicationMessenger.h"
  21 #include "settings/DisplaySettings.h"
  22 #include "settings/Settings.h"
  23 #include "settings/SettingsComponent.h"
  24 #include "settings/lib/Setting.h"
  25 #include "utils/DisplayInfo.h"
  26 #include "utils/Map.h"
  27 #include "utils/StringUtils.h"
  28 #include "utils/log.h"
  29 #include "windowing/GraphicContext.h"
  30
  31 #include <mutex>
  32 #include <string.h>
  33
  34 #ifndef HAVE_HDR_OUTPUT_METADATA
  35 // HDR structs is copied from linux include/linux/hdmi.h
  36 struct hdr_metadata_infoframe
  37 {
  38   uint8_t eotf;
  39   uint8_t metadata_type;
  40   struct
  41   {
  42     uint16_t x, y;
  43   } display_primaries[3];
  44   struct
  45   {
  46     uint16_t x, y;
  47   } white_point;
  48   uint16_t max_display_mastering_luminance;
  49   uint16_t min_display_mastering_luminance;
  50   uint16_t max_cll;
  51   uint16_t max_fall;
  52 };
  53 struct hdr_output_metadata
  54 {
  55   uint32_t metadata_type;
  56   union
  57   {
  58     struct hdr_metadata_infoframe hdmi_metadata_type1;
  59   };
  60 };
  61 #endif
  62
  63 using namespace KODI::WINDOWING::GBM;
  64
  65 using namespace std::chrono_literals;
  66
  67 namespace
  68 {
  69
  70 // These map to the definitions in the linux kernel
  71 // drivers/gpu/drm/drm_connector.c
  72
  73 constexpr auto ColorimetryMap = make_map<KODI::UTILS::Colorimetry, std::string_view>({
  74     {KODI::UTILS::Colorimetry::DEFAULT, "Default"},
  75     {KODI::UTILS::Colorimetry::XVYCC_601, "XVYCC_601"},
  76     {KODI::UTILS::Colorimetry::XVYCC_709, "XVYCC_709"},
  77     {KODI::UTILS::Colorimetry::SYCC_601, "SYCC_601"},
  78     {KODI::UTILS::Colorimetry::OPYCC_601, "opYCC_601"},
  79     {KODI::UTILS::Colorimetry::OPRGB, "opRGB"},
  80     {KODI::UTILS::Colorimetry::BT2020_CYCC, "BT2020_CYCC"},
  81     {KODI::UTILS::Colorimetry::BT2020_YCC, "BT2020_YCC"},
  82     {KODI::UTILS::Colorimetry::BT2020_RGB, "BT2020_RGB"},
  83     {KODI::UTILS::Colorimetry::ST2113_RGB, "Default"},
  84     {KODI::UTILS::Colorimetry::ICTCP, "Default"},
  85 });
  86 } // namespace
  87
  88 CWinSystemGbm::CWinSystemGbm() :
  89   m_DRM(nullptr),
  90   m_GBM(new CGBMUtils),
  91   m_libinput(new CLibInputHandler)
  92 {
  93   m_dpms = std::make_shared<CGBMDPMSSupport>();
  94   m_libinput->Start();
  95 }
  96
  97 CWinSystemGbm::~CWinSystemGbm() = default;
  98
  99 bool CWinSystemGbm::InitWindowSystem()
 100 {
 101   const char* x11 = getenv("DISPLAY");
 102   const char* wayland = getenv("WAYLAND_DISPLAY");
 103   if (x11 || wayland)
 104   {
 105     CLog::Log(LOGDEBUG, "CWinSystemGbm::{} - not allowed to run GBM under a window manager",
 106               __FUNCTION__);
 107     return false;
 108   }
 109
 110   m_DRM = std::make_shared<CDRMAtomic>();
 111
 112   if (!m_DRM->InitDrm())
 113   {
 114     CLog::Log(LOGERROR, "CWinSystemGbm::{} - failed to initialize Atomic DRM", __FUNCTION__);
 115     m_DRM.reset();
 116
 117     m_DRM = std::make_shared<CDRMLegacy>();
 118
 119     if (!m_DRM->InitDrm())
 120     {
 121       CLog::Log(LOGERROR, "CWinSystemGbm::{} - failed to initialize Legacy DRM", __FUNCTION__);
 122       m_DRM.reset();
 123
 124       m_DRM = std::make_shared<COffScreenModeSetting>();
 125       if (!m_DRM->InitDrm())
 126       {
 127         CLog::Log(LOGERROR, "CWinSystemGbm::{} - failed to initialize off screen DRM",
 128                   __FUNCTION__);
 129         m_DRM.reset();
 130         return false;
 131       }
 132     }
 133   }
 134
 135   CDRMConnector* connector = m_DRM->GetConnector();
 136   if (connector)
 137   {
 138     std::vector<uint8_t> edid = connector->GetEDID();
 139     if (!edid.empty())
 140     {
 141       m_info = UTILS::CDisplayInfo::Create(edid);
 142     }
 143   }
 144
 145   if (!m_GBM->CreateDevice(m_DRM->GetFileDescriptor()))
 146   {
 147     m_GBM.reset();
 148     return false;
 149   }
 150
 151   auto settingsComponent = CServiceBroker::GetSettingsComponent();
 152   if (!settingsComponent)
 153     return false;
 154
 155   auto settings = settingsComponent->GetSettings();
 156   if (!settings)
 157     return false;
 158
 159   auto setting = settings->GetSetting(CSettings::SETTING_VIDEOSCREEN_LIMITEDRANGE);
 160   if (setting)
 161     setting->SetVisible(true);
 162
 163   setting = settings->GetSetting("videoscreen.limitguisize");
 164   if (setting)
 165     setting->SetVisible(true);
 166
 167   CLog::Log(LOGDEBUG, "CWinSystemGbm::{} - initialized DRM", __FUNCTION__);
 168   return CWinSystemBase::InitWindowSystem();
 169 }
 170
 171 bool CWinSystemGbm::DestroyWindowSystem()
 172 {
 173   CLog::Log(LOGDEBUG, "CWinSystemGbm::{} - deinitialized DRM", __FUNCTION__);
 174
 175   m_libinput.reset();
 176
 177   return true;
 178 }
 179
 180 void CWinSystemGbm::UpdateResolutions()
 181 {
 182   RESOLUTION_INFO current = m_DRM->GetCurrentMode();
 183
 184   auto resolutions = m_DRM->GetModes();
 185   if (resolutions.empty())
 186   {
 187     CDisplaySettings::GetInstance().ClearCustomResolutions();
 188
 189     CServiceBroker::GetWinSystem()->GetGfxContext().ResetOverscan(current);
 190     CDisplaySettings::GetInstance().AddResolutionInfo(current);
 191     CDisplaySettings::GetInstance().GetResolutionInfo(RES_DESKTOP) = current;
 192
 193     CLog::Log(LOGINFO, "Found resolution {}x{} with {}x{}{} @ {:f} Hz", current.iWidth,
 194               current.iHeight, current.iScreenWidth, current.iScreenHeight,
 195               current.dwFlags & D3DPRESENTFLAG_INTERLACED ? "i" : "", current.fRefreshRate);
 196   }
 197   else
 198   {
 199     CDisplaySettings::GetInstance().ClearCustomResolutions();
 200
 201     for (auto &res : resolutions)
 202     {
 203       CServiceBroker::GetWinSystem()->GetGfxContext().ResetOverscan(res);
 204       CDisplaySettings::GetInstance().AddResolutionInfo(res);
 205
 206       if (current.iScreenWidth == res.iScreenWidth &&
 207           current.iScreenHeight == res.iScreenHeight &&
 208           current.iWidth == res.iWidth &&
 209           current.iHeight == res.iHeight &&
 210           current.fRefreshRate == res.fRefreshRate &&
 211           current.dwFlags == res.dwFlags)
 212       {
 213         CDisplaySettings::GetInstance().GetResolutionInfo(RES_DESKTOP) = res;
 214       }
 215
 216       CLog::Log(LOGINFO, "Found resolution {}x{} with {}x{}{} @ {:f} Hz", res.iWidth, res.iHeight,
 217                 res.iScreenWidth, res.iScreenHeight,
 218                 res.dwFlags & D3DPRESENTFLAG_INTERLACED ? "i" : "", res.fRefreshRate);
 219     }
 220   }
 221
 222   CDisplaySettings::GetInstance().ApplyCalibrations();
 223 }
 224
 225 bool CWinSystemGbm::ResizeWindow(int newWidth, int newHeight, int newLeft, int newTop)
 226 {
 227   return true;
 228 }
 229
 230 bool CWinSystemGbm::SetFullScreen(bool fullScreen, RESOLUTION_INFO& res, bool blankOtherDisplays)
 231 {
 232   // Notify other subsystems that we will change resolution
 233   OnLostDevice();
 234
 235   if(!m_DRM->SetMode(res))
 236   {
 237     CLog::Log(LOGERROR, "CWinSystemGbm::{} - failed to set DRM mode", __FUNCTION__);
 238     return false;
 239   }
 240
 241   struct gbm_bo *bo = nullptr;
 242
 243   if (!std::dynamic_pointer_cast<CDRMAtomic>(m_DRM))
 244   {
 245     bo = m_GBM->GetDevice().GetSurface().LockFrontBuffer().Get();
 246   }
 247
 248   auto result = m_DRM->SetVideoMode(res, bo);
 249
 250   auto delay =
 251       std::chrono::milliseconds(CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
 252                                     "videoscreen.delayrefreshchange") *
 253                                 100);
 254   if (delay > 0ms)
 255     m_dispResetTimer.Set(delay);
 256
 257   return result;
 258 }
 259
 260 bool CWinSystemGbm::DisplayHardwareScalingEnabled()
 261 {
 262   auto drmAtomic = std::dynamic_pointer_cast<CDRMAtomic>(m_DRM);
 263   if (drmAtomic && drmAtomic->DisplayHardwareScalingEnabled())
 264     return true;
 265
 266   return false;
 267 }
 268
 269 void CWinSystemGbm::UpdateDisplayHardwareScaling(const RESOLUTION_INFO& resInfo)
 270 {
 271   if (!DisplayHardwareScalingEnabled())
 272     return;
 273
 274   //! @todo The PR that made the res struct constant was abandoned due to drama.
 275   // It should be const-corrected and changed here.
 276   RESOLUTION_INFO& resMutable = const_cast<RESOLUTION_INFO&>(resInfo);
 277
 278   SetFullScreen(true, resMutable, false);
 279 }
 280
 281 void CWinSystemGbm::FlipPage(bool rendered, bool videoLayer, bool async)
 282 {
 283   if (m_videoLayerBridge && !videoLayer)
 284   {
 285     // disable video plane when video layer no longer is active
 286     m_videoLayerBridge->Disable();
 287   }
 288
 289   struct gbm_bo *bo = nullptr;
 290
 291   if (rendered)
 292   {
 293     bo = m_GBM->GetDevice().GetSurface().LockFrontBuffer().Get();
 294   }
 295
 296   m_DRM->FlipPage(bo, rendered, videoLayer, async);
 297
 298   if (m_videoLayerBridge && !videoLayer)
 299   {
 300     // delete video layer bridge when video layer no longer is active
 301     m_videoLayerBridge.reset();
 302   }
 303 }
 304
 305 bool CWinSystemGbm::UseLimitedColor()
 306 {
 307   return CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_VIDEOSCREEN_LIMITEDRANGE);
 308 }
 309
 310 bool CWinSystemGbm::Hide()
 311 {
 312   bool ret = m_DRM->SetActive(false);
 313   FlipPage(false, false, false);
 314   return ret;
 315 }
 316
 317 bool CWinSystemGbm::Show(bool raise)
 318 {
 319   bool ret = m_DRM->SetActive(true);
 320   FlipPage(false, false, false);
 321   return ret;
 322 }
 323
 324 void CWinSystemGbm::Register(IDispResource *resource)
 325 {
 326   std::unique_lock<CCriticalSection> lock(m_resourceSection);
 327   m_resources.push_back(resource);
 328 }
 329
 330 void CWinSystemGbm::Unregister(IDispResource *resource)
 331 {
 332   std::unique_lock<CCriticalSection> lock(m_resourceSection);
 333   std::vector<IDispResource*>::iterator i = find(m_resources.begin(), m_resources.end(), resource);
 334   if (i != m_resources.end())
 335   {
 336     m_resources.erase(i);
 337   }
 338 }
 339
 340 void CWinSystemGbm::OnLostDevice()
 341 {
 342   CLog::Log(LOGDEBUG, "{} - notify display change event", __FUNCTION__);
 343   m_dispReset = true;
 344
 345   std::unique_lock<CCriticalSection> lock(m_resourceSection);
 346   for (auto resource : m_resources)
 347     resource->OnLostDisplay();
 348 }
 349
 350 std::unique_ptr<CVideoSync> CWinSystemGbm::GetVideoSync(CVideoReferenceClock* clock)
 351 {
 352   return std::make_unique<CVideoSyncGbm>(clock);
 353 }
 354
 355 std::vector<std::string> CWinSystemGbm::GetConnectedOutputs()
 356 {
 357   return m_DRM->GetConnectedConnectorNames();
 358 }
 359
 360 bool CWinSystemGbm::SetHDR(const VideoPicture* videoPicture)
 361 {
 362   auto settingsComponent = CServiceBroker::GetSettingsComponent();
 363   if (!settingsComponent)
 364     return false;
 365
 366   auto settings = settingsComponent->GetSettings();
 367   if (!settings)
 368     return false;
 369
 370   if (!settings->GetBool(SETTING_WINSYSTEM_IS_HDR_DISPLAY))
 371     return false;
 372
 373   auto drm = std::dynamic_pointer_cast<CDRMAtomic>(m_DRM);
 374   if (!drm)
 375     return false;
 376
 377   auto connector = drm->GetConnector();
 378   if (!connector)
 379     return false;
 380
 381   if (!videoPicture)
 382   {
 383     if (connector->SupportsProperty("Colorspace"))
 384     {
 385       std::optional<uint64_t> colorspace = connector->GetPropertyValue("Colorspace", "Default");
 386       if (colorspace)
 387       {
 388         CLog::LogF(LOGDEBUG, "setting connector colorspace to Default");
 389         drm->AddProperty(connector, "Colorspace", colorspace.value());
 390         drm->SetActive(true);
 391       }
 392     }
 393
 394     if (connector->SupportsProperty("HDR_OUTPUT_METADATA"))
 395     {
 396       drm->AddProperty(connector, "HDR_OUTPUT_METADATA", 0);
 397       drm->SetActive(true);
 398
 399       if (m_hdr_blob_id)
 400         drmModeDestroyPropertyBlob(drm->GetFileDescriptor(), m_hdr_blob_id);
 401       m_hdr_blob_id = 0;
 402     }
 403
 404     return false;
 405   }
 406
 407   KODI::UTILS::Colorimetry colorimetry = DRMPRIME::GetColorimetry(*videoPicture);
 408
 409   if (connector->SupportsProperty("Colorspace") && m_info &&
 410       m_info->SupportsColorimetry(colorimetry))
 411   {
 412     std::optional<uint64_t> colorspace =
 413         connector->GetPropertyValue("Colorspace", ColorimetryMap.at(colorimetry));
 414     if (colorspace)
 415     {
 416       CLog::LogF(LOGDEBUG, "setting connector colorspace to {}", ColorimetryMap.at(colorimetry));
 417       drm->AddProperty(connector, "Colorspace", colorspace.value());
 418       drm->SetActive(true);
 419     }
 420   }
 421
 422   KODI::UTILS::Eotf eotf = DRMPRIME::GetEOTF(*videoPicture);
 423
 424   if (connector->SupportsProperty("HDR_OUTPUT_METADATA") && m_info &&
 425       m_info->SupportsHDRStaticMetadataType1() && m_info->SupportsEOTF(eotf))
 426   {
 427     hdr_output_metadata hdr_metadata = {};
 428
 429     hdr_metadata.metadata_type = DRMPRIME::HDMI_STATIC_METADATA_TYPE1;
 430     hdr_metadata.hdmi_metadata_type1.eotf = static_cast<uint8_t>(eotf);
 431     hdr_metadata.hdmi_metadata_type1.metadata_type = DRMPRIME::HDMI_STATIC_METADATA_TYPE1;
 432
 433     if (m_hdr_blob_id)
 434       drmModeDestroyPropertyBlob(drm->GetFileDescriptor(), m_hdr_blob_id);
 435     m_hdr_blob_id = 0;
 436
 437     if (hdr_metadata.hdmi_metadata_type1.eotf)
 438     {
 439       const AVMasteringDisplayMetadata* mdmd = DRMPRIME::GetMasteringDisplayMetadata(*videoPicture);
 440       if (mdmd && mdmd->has_primaries)
 441       {
 442         // Convert to unsigned 16-bit values in units of 0.00002,
 443         // where 0x0000 represents zero and 0xC350 represents 1.0000
 444         for (int i = 0; i < 3; i++)
 445         {
 446           hdr_metadata.hdmi_metadata_type1.display_primaries[i].x =
 447               std::round(av_q2d(mdmd->display_primaries[i][0]) * 50000.0);
 448           hdr_metadata.hdmi_metadata_type1.display_primaries[i].y =
 449               std::round(av_q2d(mdmd->display_primaries[i][1]) * 50000.0);
 450
 451           CLog::Log(LOGDEBUG, LOGVIDEO, "CWinSystemGbm::{} - display_primaries[{}].x: {}",
 452                     __FUNCTION__, i, hdr_metadata.hdmi_metadata_type1.display_primaries[i].x);
 453           CLog::Log(LOGDEBUG, LOGVIDEO, "CWinSystemGbm::{} - display_primaries[{}].y: {}",
 454                     __FUNCTION__, i, hdr_metadata.hdmi_metadata_type1.display_primaries[i].y);
 455         }
 456         hdr_metadata.hdmi_metadata_type1.white_point.x =
 457             std::round(av_q2d(mdmd->white_point[0]) * 50000.0);
 458         hdr_metadata.hdmi_metadata_type1.white_point.y =
 459             std::round(av_q2d(mdmd->white_point[1]) * 50000.0);
 460
 461         CLog::Log(LOGDEBUG, LOGVIDEO, "CWinSystemGbm::{} - white_point.x: {}", __FUNCTION__,
 462                   hdr_metadata.hdmi_metadata_type1.white_point.x);
 463         CLog::Log(LOGDEBUG, LOGVIDEO, "CWinSystemGbm::{} - white_point.y: {}", __FUNCTION__,
 464                   hdr_metadata.hdmi_metadata_type1.white_point.y);
 465       }
 466       if (mdmd && mdmd->has_luminance)
 467       {
 468         // Convert to unsigned 16-bit value in units of 1 cd/m2,
 469         // where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2
 470         hdr_metadata.hdmi_metadata_type1.max_display_mastering_luminance =
 471             std::round(av_q2d(mdmd->max_luminance));
 472
 473         // Convert to unsigned 16-bit value in units of 0.0001 cd/m2,
 474         // where 0x0001 represents 0.0001 cd/m2 and 0xFFFF represents 6.5535 cd/m2
 475         hdr_metadata.hdmi_metadata_type1.min_display_mastering_luminance =
 476             std::round(av_q2d(mdmd->min_luminance) * 10000.0);
 477
 478         CLog::Log(LOGDEBUG, LOGVIDEO, "CWinSystemGbm::{} - max_display_mastering_luminance: {}",
 479                   __FUNCTION__, hdr_metadata.hdmi_metadata_type1.max_display_mastering_luminance);
 480         CLog::Log(LOGDEBUG, LOGVIDEO, "CWinSystemGbm::{} - min_display_mastering_luminance: {}",
 481                   __FUNCTION__, hdr_metadata.hdmi_metadata_type1.min_display_mastering_luminance);
 482       }
 483
 484       const AVContentLightMetadata* clmd = DRMPRIME::GetContentLightMetadata(*videoPicture);
 485       if (clmd)
 486       {
 487         hdr_metadata.hdmi_metadata_type1.max_cll = clmd->MaxCLL;
 488         hdr_metadata.hdmi_metadata_type1.max_fall = clmd->MaxFALL;
 489
 490         CLog::Log(LOGDEBUG, LOGVIDEO, "CWinSystemGbm::{} - max_cll: {}", __FUNCTION__,
 491                   hdr_metadata.hdmi_metadata_type1.max_cll);
 492         CLog::Log(LOGDEBUG, LOGVIDEO, "CWinSystemGbm::{} - max_fall: {}", __FUNCTION__,
 493                   hdr_metadata.hdmi_metadata_type1.max_fall);
 494       }
 495
 496       drmModeCreatePropertyBlob(drm->GetFileDescriptor(), &hdr_metadata, sizeof(hdr_metadata),
 497                                 &m_hdr_blob_id);
 498     }
 499
 500     drm->AddProperty(connector, "HDR_OUTPUT_METADATA", m_hdr_blob_id);
 501     drm->SetActive(true);
 502   }
 503
 504   return m_hdr_blob_id != 0;
 505 }
 506
 507 bool CWinSystemGbm::IsHDRDisplay()
 508 {
 509   auto drm = std::dynamic_pointer_cast<CDRMAtomic>(m_DRM);
 510   if (!drm)
 511     return false;
 512
 513   auto connector = drm->GetConnector();
 514   if (!connector)
 515     return false;
 516
 517   return connector->SupportsProperty("HDR_OUTPUT_METADATA") && m_info &&
 518          m_info->SupportsHDRStaticMetadataType1();
 519 }
 520
 521 CHDRCapabilities CWinSystemGbm::GetDisplayHDRCapabilities() const
 522 {
 523   if (!m_info)
 524     return {};
 525
 526   CHDRCapabilities caps;
 527
 528   if (m_info->SupportsEOTF(UTILS::Eotf::PQ))
 529     caps.SetHDR10();
 530
 531   if (m_info->SupportsEOTF(UTILS::Eotf::HLG))
 532     caps.SetHLG();
 533
 534   return caps;
 535 }