#pragma once #include "./Backend.hpp" #include "../allocator/Swapchain.hpp" #include "../output/Output.hpp" #include "../input/Input.hpp" #include "FrameScheduler.hpp" #include #include #include #include namespace Aquamarine { class CDRMBackend; class CDRMFB; class CDRMOutput; struct SDRMConnector; class CDRMRenderer; class CDRMDumbAllocator; typedef std::function FIdleCallback; class CDRMBufferAttachment : public IAttachment { public: CDRMBufferAttachment(Hyprutils::Memory::CSharedPointer fb_); virtual ~CDRMBufferAttachment() { ; } Hyprutils::Memory::CSharedPointer fb; }; class CDRMBufferUnimportable : public IAttachment { public: CDRMBufferUnimportable() { ; } virtual ~CDRMBufferUnimportable() { ; } }; class CDRMLease { public: static Hyprutils::Memory::CSharedPointer create(std::vector> outputs); ~CDRMLease(); void terminate(); int leaseFD = -1; uint32_t lesseeID = 0; Hyprutils::Memory::CWeakPointer backend; std::vector> outputs; bool active = true; struct { Hyprutils::Signal::CSignalT<> destroy; } events; private: CDRMLease() = default; void destroy(); friend class CDRMBackend; }; class CDRMFB { public: ~CDRMFB(); static Hyprutils::Memory::CSharedPointer create(Hyprutils::Memory::CSharedPointer buffer_, Hyprutils::Memory::CWeakPointer backend_, bool* isNew = nullptr); void closeHandles(); // drops the buffer from KMS void drop(); // re-imports the buffer into KMS. Essentially drop and import. void reimport(); uint32_t id = 0; Hyprutils::Memory::CWeakPointer buffer; Hyprutils::Memory::CWeakPointer backend; std::array boHandles = {0, 0, 0, 0}; // true if the original buffer is gone and this has been released. bool dead = false; private: CDRMFB(Hyprutils::Memory::CSharedPointer buffer_, Hyprutils::Memory::CWeakPointer backend_); uint32_t submitBuffer(); void import(); bool dropped = false, handlesClosed = false; struct { Hyprutils::Signal::CHyprSignalListener destroyBuffer; } listeners; }; struct SDRMLayer { // we expect the consumers to use double-buffering, so we keep the 2 last FBs around. If any of these goes out of // scope, the DRM FB will be destroyed, but the IBuffer will stay, as long as it's ref'd somewhere. Hyprutils::Memory::CSharedPointer front /* currently displaying */, back /* submitted */, last /* keep just in case */; Hyprutils::Memory::CWeakPointer backend; }; struct SDRMPlane { bool init(drmModePlane* plane); uint64_t type = 0; uint32_t id = 0; uint32_t initialID = 0; Hyprutils::Memory::CSharedPointer front /* currently displaying */, back /* submitted */, last /* keep just in case */; Hyprutils::Memory::CWeakPointer backend; Hyprutils::Memory::CWeakPointer self; std::vector formats; union UDRMPlaneProps { struct { uint32_t type; uint32_t rotation; // Not guaranteed to exist uint32_t in_formats; // Not guaranteed to exist // atomic-modesetting only uint32_t src_x; uint32_t src_y; uint32_t src_w; uint32_t src_h; uint32_t crtc_x; uint32_t crtc_y; uint32_t crtc_w; uint32_t crtc_h; uint32_t fb_id; uint32_t crtc_id; uint32_t fb_damage_clips; uint32_t hotspot_x; uint32_t hotspot_y; uint32_t in_fence_fd; uint32_t color_range; } values; uint32_t props[18] = {0}; }; UDRMPlaneProps props; // only valid when color_range != 0 union UDRMPlaneColorRange { struct { uint32_t Full_YCbCr; uint32_t Limited_YCbCr; } values; uint32_t props[2] = {0}; }; UDRMPlaneColorRange colorRange; }; struct SDRMCRTC { uint32_t id = 0; std::vector layers; int32_t refresh = 0; // unused struct { int gammaSize = 0; } legacy; struct { bool ownModeID = false; uint32_t modeID = 0; uint32_t gammaLut = 0; uint32_t ctm = 0; uint32_t hdr = 0; // true once a real commit has made the kernel CTM match our state. bool ctmStateKnown = false; } atomic; Hyprutils::Memory::CSharedPointer primary; Hyprutils::Memory::CSharedPointer cursor; Hyprutils::Memory::CWeakPointer backend; Hyprutils::Memory::CSharedPointer pendingCursor; union UDRMCRTCProps { struct { // None of these are guaranteed to exist uint32_t vrr_enabled; uint32_t gamma_lut; uint32_t gamma_lut_size; uint32_t ctm; uint32_t degamma_lut; uint32_t degamma_lut_size; // atomic-modesetting only uint32_t active; uint32_t mode_id; uint32_t out_fence_ptr; } values; uint32_t props[9] = {0}; }; UDRMCRTCProps props; }; class CDRMOutput : public IOutput { public: virtual ~CDRMOutput(); virtual bool commit(); virtual bool test(); virtual Hyprutils::Memory::CSharedPointer getBackend(); virtual bool setCursor(Hyprutils::Memory::CSharedPointer buffer, const Hyprutils::Math::Vector2D& hotspot); virtual void moveCursor(const Hyprutils::Math::Vector2D& coord, bool skipSchedule = false); virtual void scheduleFrame(const scheduleFrameReason reason = AQ_SCHEDULE_UNKNOWN); virtual void setCursorVisible(bool visible); virtual Hyprutils::Math::Vector2D cursorPlaneSize(); virtual size_t getGammaSize(); virtual size_t getDeGammaSize(); virtual std::vector getRenderFormats(); virtual bool pendingPageFlip(); virtual bool pendingIdleFrame(); void releaseMgpuResources(); int getConnectorID(); Hyprutils::Memory::CWeakPointer self; Hyprutils::Memory::CWeakPointer lease; bool cursorVisible = true; Hyprutils::Math::Vector2D cursorPos; // without hotspot Hyprutils::Math::Vector2D cursorHotspot; bool enabledState = true; // actual enabled state. Should be synced with state->state().enabled after a new frame private: CDRMOutput(const std::string& name_, Hyprutils::Memory::CWeakPointer backend_, Hyprutils::Memory::CSharedPointer connector_); bool commitState(bool onlyTest = false); Hyprutils::Memory::CWeakPointer backend; Hyprutils::Memory::CSharedPointer connector; Hyprutils::Memory::CSharedPointer> frameIdle; Hyprutils::Signal::CHyprSignalListener frameReadyListener; struct { Hyprutils::Memory::CSharedPointer swapchain; Hyprutils::Memory::CSharedPointer cursorSwapchain; } mgpu; bool lastCommitNoBuffer = true; friend struct SDRMConnector; friend class CDRMLease; }; struct SDRMPageFlip { Hyprutils::Memory::CWeakPointer connector; }; struct SDRMConnectorCommitData { Hyprutils::Memory::CSharedPointer mainFB, cursorFB; bool modeset = false; bool blocking = false; uint32_t flags = 0; bool test = false; bool enabled = false; uint32_t committed = 0; Hyprutils::Math::CRegion damage; drmModeModeInfo modeInfo; std::optional ctm; std::optional hdrMetadata; struct { uint32_t gammaLut = 0; uint32_t degammaLut = 0; uint32_t fbDamage = 0; uint32_t modeBlob = 0; uint32_t ctmBlob = 0; uint32_t hdrBlob = 0; bool blobbed = false; bool gammad = false; bool degammad = false; bool ctmd = false; bool hdrd = false; // true if hdr blob needs updating or clearing // staged connector property values for this commit. on a successful non-test // commit these are copied into SDRMConnector::atomic so subsequent page-flips // can skip re-emitting unchanged values (some displays, notably samsung TVs, // renegotiate the avi infoframe whenever connector_state appears in a commit, // causing per-frame blanking, see #265). uint64_t maxBpc = 0; uint64_t colorspace = 0; uint16_t contentType = 0; uint32_t crtcID = 0; } atomic; void calculateMode(Hyprutils::Memory::CSharedPointer connector); }; struct SDRMConnector { ~SDRMConnector(); struct STileInfo { uint32_t groupId = 0; bool isSingleMonitor = false; int numHTile = 0, numVTile = 0; int tileHLoc = 0, tileVLoc = 0; int tileHSize = 0, tileVSize = 0; }; bool init(drmModeConnector* connector); void connect(drmModeConnector* connector); void disconnect(); Hyprutils::Memory::CSharedPointer getCurrentCRTC(const drmModeConnector* connector); drmModeModeInfo* getCurrentMode(); IOutput::SParsedEDID parseEDID(std::vector data); bool commitState(SDRMConnectorCommitData& data); void applyCommit(const SDRMConnectorCommitData& data); void rollbackCommit(const SDRMConnectorCommitData& data); void onPresent(); void recheckCRTCProps(); void parseTileInfo(); void releaseFBReferences(); Hyprutils::Memory::CSharedPointer output; Hyprutils::Memory::CWeakPointer backend; Hyprutils::Memory::CWeakPointer self; std::string szName; drmModeConnection status = DRM_MODE_DISCONNECTED; uint32_t id = 0; std::array maxBpcBounds = {0, 0}; Hyprutils::Memory::CSharedPointer crtc; int32_t refresh = 0; uint32_t possibleCrtcs = 0; std::string make, serial, model; bool canDoVrr = false; STileInfo tileInfo; bool tilingRedundant = false; Hyprutils::Math::Vector2D maxMode; bool cursorEnabled = false; Hyprutils::Math::Vector2D cursorPos, cursorSize, cursorHotspot; Hyprutils::Memory::CSharedPointer pendingCursorFB; SDRMPageFlip pendingPageFlip; CFrameScheduler sched; // the current state is invalid and won't commit, don't try to modeset. bool commitTainted = false; Hyprutils::Memory::CSharedPointer fallbackMode; struct { bool vrrEnabled = false; // last connector_state values successfully committed to the kernel. used // to skip re-emitting unchanged values on page-flips (see #265). uint64_t maxBpc = 0; uint64_t colorspace = 0; uint16_t contentType = 0; uint32_t crtcID = 0; bool propsCached = false; } atomic; union UDRMConnectorProps { struct { uint32_t edid; uint32_t dpms; uint32_t link_status; // not guaranteed to exist uint32_t path; uint32_t vrr_capable; // not guaranteed to exist uint32_t subconnector; // not guaranteed to exist uint32_t non_desktop; uint32_t panel_orientation; // not guaranteed to exist uint32_t content_type; // not guaranteed to exist uint32_t max_bpc; // not guaranteed to exist uint32_t Colorspace; // not guaranteed to exist uint32_t hdr_output_metadata; // not guaranteed to exist uint32_t tile; // not guaranteed to exist // atomic-modesetting only uint32_t crtc_id; } values; uint32_t props[14] = {0}; }; UDRMConnectorProps props; union UDRMConnectorColorspace { struct { uint32_t Default; uint32_t BT2020_RGB; uint32_t BT2020_YCC; } values; uint32_t props[3] = {0}; }; UDRMConnectorColorspace colorspace; }; class IDRMImplementation { public: virtual ~IDRMImplementation() = default; virtual bool commit(Hyprutils::Memory::CSharedPointer connector, SDRMConnectorCommitData& data) = 0; virtual bool reset() = 0; // moving a cursor IIRC is almost instant on most hardware so we don't have to wait for a commit. virtual bool moveCursor(Hyprutils::Memory::CSharedPointer connector, bool skipSchedule = false) = 0; }; class CDRMBackend : public IBackendImplementation { public: virtual ~CDRMBackend(); virtual eBackendType type(); virtual bool start(); virtual std::vector> pollFDs(); virtual int drmFD(); virtual bool dispatchEvents(); virtual uint32_t capabilities(); virtual bool setCursor(Hyprutils::Memory::CSharedPointer buffer, const Hyprutils::Math::Vector2D& hotspot); virtual void onReady(); virtual std::vector getRenderFormats(); virtual std::vector getCursorFormats(); virtual bool createOutput(const std::string& name = ""); virtual Hyprutils::Memory::CSharedPointer preferredAllocator(); virtual std::vector getRenderableFormats(); virtual std::vector> getAllocators(); virtual Hyprutils::Memory::CWeakPointer getPrimary(); Hyprutils::Memory::CWeakPointer self; void log(eBackendLogLevel, const std::string&); bool sessionActive(); int getNonMasterFD(); std::vector idleCallbacks; std::string gpuName; virtual int drmRenderNodeFD(); virtual eBackendGPUDriver gpuDriver(); private: CDRMBackend(Hyprutils::Memory::CSharedPointer backend); static std::vector> attempt(Hyprutils::Memory::CSharedPointer backend); static Hyprutils::Memory::CSharedPointer fromGpu(std::string path, Hyprutils::Memory::CSharedPointer backend, Hyprutils::Memory::CSharedPointer primary); bool registerGPU(Hyprutils::Memory::CSharedPointer gpu_, Hyprutils::Memory::CSharedPointer primary_ = {}); bool checkFeatures(); bool initResources(); bool initMgpu(); bool updateSecondaryRendererState(); bool grabFormats(); bool shouldBlit(); void scanConnectors(); void scanLeases(); void restoreAfterVT(); void recheckOutputs(); void recheckCRTCs(); void markRedundantTiles(); void buildGlFormats(const std::vector& fmts); Hyprutils::Memory::CSharedPointer gpu; Hyprutils::Memory::CSharedPointer impl; Hyprutils::Memory::CWeakPointer primary; struct { Hyprutils::Memory::CSharedPointer allocator; Hyprutils::Memory::CSharedPointer renderer; // may be null if creation fails } rendererState; bool rendererRequired = true; eBackendGPUDriver driver = AQ_BACKEND_GPU_DRIVER_UNKNOWN; Hyprutils::Memory::CWeakPointer backend; std::vector> crtcs; std::vector> planes; std::vector> connectors; std::vector formats; std::vector glFormats; Hyprutils::Memory::CSharedPointer dumbAllocator; bool atomic = false; struct { Hyprutils::Math::Vector2D cursorSize; bool supportsAsyncCommit = false; bool supportsAddFb2Modifiers = false; bool supportsTimelines = false; } drmProps; struct { Hyprutils::Signal::CHyprSignalListener sessionActivate; Hyprutils::Signal::CHyprSignalListener gpuChange; Hyprutils::Signal::CHyprSignalListener gpuRemove; } listeners; friend class CBackend; friend class CDRMFB; friend class CDRMFBAttachment; friend struct SDRMConnector; friend struct SDRMCRTC; friend struct SDRMPlane; friend class CDRMOutput; friend struct SDRMPageFlip; friend class CDRMLegacyImpl; friend class CDRMAtomicImpl; friend class CDRMAtomicRequest; friend class CDRMLease; friend class CGBMBuffer; }; };