DrmKmsDevice.hpp

Go to the documentation of this file.

#pragma once
 
#include <score_plugin_gfx_export.h>
 
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
namespace score::gfx::drm
{
 
struct ModeInfo
{
  std::string name;
  std::uint32_t width{}, height{};
  std::uint32_t refreshMilliHz{}; 
  std::uint32_t clockKHz{};
  bool interlaced{};
  bool preferred{};
};
 
struct ConnectorInfo
{
  std::uint32_t id{};
  std::string name; 
  bool connected{};
  bool writeback{};
  std::uint32_t mmWidth{}, mmHeight{};
  std::vector<ModeInfo> modes;
  std::vector<std::uint32_t> possibleCrtcs;
};
 
struct PlaneFormat
{
  std::uint32_t fourcc{};
  std::vector<std::uint64_t> modifiers;
};
 
struct PlaneInfo
{
  std::uint32_t id{};
  enum Type
  {
    Overlay,
    Primary,
    Cursor
  } type{Overlay};
  std::uint32_t possibleCrtcs{}; 
  std::vector<PlaneFormat> formats;
};
 
struct CrtcInfo
{
  std::uint32_t id{};
  int index{};
  bool active{};
};
 
struct DeviceInfo
{
  std::string path;
  std::string driver;
  bool atomic{};          
  bool universalPlanes{};      
  bool writebackConnectors{};  
  bool hasMaster{};       
  std::vector<ConnectorInfo> connectors;
  std::vector<CrtcInfo> crtcs;
  std::vector<PlaneInfo> planes;
};
 
struct FramebufferDesc
{
  std::uint32_t width{}, height{};
  std::uint32_t fourcc{};
  std::uint64_t modifier{};
  int fd[4]{-1, -1, -1, -1};
  std::uint32_t stride[4]{};
  std::uint32_t offset[4]{};
  std::uint32_t planeCount{1};
};
 
struct FlipEvent
{
  std::uint64_t sequence{};
  std::uint64_t timestampNs{}; 
  bool valid{};
};
 
class SCORE_PLUGIN_GFX_EXPORT KmsDevice
{
public:
  KmsDevice();
  ~KmsDevice();
  KmsDevice(const KmsDevice&) = delete;
  KmsDevice& operator=(const KmsDevice&) = delete;
 
  bool open(const std::string& path);
  void close();
  bool isOpen() const noexcept;
 
  const DeviceInfo& info() const noexcept;
 
  static std::vector<DeviceInfo> enumerateDevices();
 
  bool acquireMaster();
  void releaseMaster();
 
  struct DumbBuffer
  {
    std::uint32_t handle{};
    std::uint32_t fbId{};
    std::uint32_t stride{};
    std::uint64_t size{};
    void* map{};
  };
  bool createDumbBuffer(
      std::uint32_t width, std::uint32_t height, std::uint32_t bpp,
      DumbBuffer& out);
  void destroyDumbBuffer(DumbBuffer& b);
 
  std::uint32_t addFramebuffer(const FramebufferDesc& desc);
  void removeFramebuffer(std::uint32_t fbId);
 
  bool setMode(std::uint32_t connectorId, const ModeInfo& mode, std::uint32_t fbId);
 
  bool pageFlip(std::uint32_t fbId, bool async = false);
 
  bool atomicModeset(
      std::uint32_t connectorId, const ModeInfo& mode, std::uint32_t fbId);
 
  bool atomicFlip(std::uint32_t fbId, bool async = false);
 
  bool setOverlay(
      std::uint32_t planeId, std::uint32_t fbId, int x, int y,
      std::uint32_t width, std::uint32_t height);
 
  bool writebackCapture(
      std::uint32_t writebackConnectorId, std::uint32_t fbId,
      bool includeCrtcState = true, bool allowModeset = true,
      bool testOnly = false);
 
  bool atomicReady() const noexcept;
 
  FlipEvent waitFlip(int timeoutMs);
 
  const std::string& lastError() const noexcept;
 
  struct Impl;
 
private:
  std::unique_ptr<Impl> d;
};
 
SCORE_PLUGIN_GFX_EXPORT std::string modifierName(std::uint64_t modifier);
 
SCORE_PLUGIN_GFX_EXPORT std::string fourccName(std::uint32_t fourcc);
 
} // namespace score::gfx::drm