drmdevice.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef __DRMDEVICE_H
#define __DRMDEVICE_H
 
#include <cstdint>
 
#ifdef USE_GLES
#include <EGL/egl.h>
#endif
 
#include <xf86drm.h>
#include <xf86drmMode.h>
 
#include "drmplane.h"
 
#ifdef USE_GLES
class cDrmBuffer;
#endif
 
class cVideoRender;
 
class cDrmDevice {
public:
    cDrmDevice(cVideoRender *, const char *);
    ~cDrmDevice(void);
 
    int Init(void);
    int Fd(void) { return m_fdDrm; };
    void Close(void);
 
    // setters and getters
    uint32_t ConnectorId(void) { return m_connectorId; };
 
    uint64_t DisplayWidth(void) { return m_drmModeInfo.hdisplay; };
    uint64_t DisplayHeight(void) { return m_drmModeInfo.vdisplay; };
 
    uint32_t CrtcId(void) { return m_crtcId; };
    int UseZpos(void) { return m_useZpos; };
    uint64_t ZposOverlay(void) { return m_zposOverlay; };
    uint64_t ZposPrimary(void) { return m_zposPrimary; };
 
    cDrmPlane *OsdPlane(void) { return &m_osdPlane; };
    cDrmPlane *VideoPlane(void) { return &m_videoPlane; };
    cDrmPlane *PipPlane(void) { return &m_pipPlane; };
    bool HasPipPlane(void) { return m_pipPlane.GetId(); };
 
#ifdef USE_GLES
    EGLSurface EglSurface(void) { return m_eglSurface; };
    EGLDisplay EglDisplay(void) { return m_eglDisplay; };
    EGLContext EglContext(void) { return m_eglContext; };
    int GlInitiated(void) { return m_glInitiated; };
    struct gbm_surface *GbmSurface(void) { return m_pGbmSurface; };
 
    cDrmBuffer *GetBufFromBo(struct gbm_bo *);
#endif
    void SaveCrtc(void);
    void RestoreCrtc(void);
    int HandleEvent(void);
    void InitEvent(void);
 
    bool CanHandleHdr(void) { return m_hdrMetadata != 0; };
 
    // drmModeAtomic* wrapper functions
    drmModeAtomicReqPtr ModeAtomicAlloc(void) { return drmModeAtomicAlloc(); };
    int ModeAtomicCommit(drmModeAtomicReqPtr req, uint32_t flags, void *user_data) { return drmModeAtomicCommit(m_fdDrm, req, flags, user_data); };
    void ModeAtomicFree(drmModeAtomicReqPtr req) { drmModeAtomicFree(req); };
    int SetConnectorCrtcId(drmModeAtomicReqPtr);
    int SetConnectorHdrOutputMetadata(drmModeAtomicReqPtr, uint32_t);
    int SetConnectorColorspace(drmModeAtomicReqPtr, uint32_t);
    int SetVideoPlaneColorEncoding(drmModeAtomicReqPtr, uint32_t);
    int SetVideoPlaneColorRange(drmModeAtomicReqPtr, uint32_t);
    int GetVideoPlaneColorRange(uint64_t *);
    int SetCrtcModeId(drmModeAtomicReqPtr, uint32_t);
    int SetCrtcActive(drmModeAtomicReqPtr, uint32_t);
    int CreateModeBlob(uint32_t *);
    int DestroyModeBlob(uint32_t);
    int CreateHdrBlob(struct hdr_output_metadata *, size_t, uint32_t *);
    int SetConnectorHdrBlobProperty(uint32_t);
    int DestroyHdrBlob(uint32_t);
 
private:
    cVideoRender *m_pRender;               
 
    int m_fdDrm = -1;                      
    uint32_t m_connectorId;                
    drmModeModeInfo m_drmModeInfo;         
    uint32_t m_crtcId;                     
    uint32_t m_crtcIndex;                  
    uint32_t m_hdrMetadata = 0;            
    drmModeCrtc *m_drmModeCrtcSaved;       
    drmEventContext m_drmEventCtx;         
 
    int m_userReqDisplayWidth = 0;         
    int m_userReqDisplayHeight;            
    uint32_t m_userReqDisplayRefreshRate;  
 
    bool m_useZpos = false;                
    uint64_t m_zposOverlay = 0;            
    uint64_t m_zposPrimary = 0;            
    cDrmPlane m_videoPlane;                
    cDrmPlane m_osdPlane;                  
    uint64_t m_zposPip = 0;                
    cDrmPlane m_pipPlane;                  
 
    int CreatePropertyBlob(uint32_t *);
    int GetPropertyValue(uint32_t, uint32_t, const char *, uint64_t *);
    uint32_t GetPropertyID(uint32_t, uint32_t, const char *);
 
    int SetPropertyRequest(drmModeAtomicReqPtr, uint32_t, uint32_t, const char *, uint64_t);
    int32_t FindCrtcForConnector(const drmModeRes *, const drmModeConnector *);
#ifdef USE_GLES
    struct gbm_device *m_pGbmDevice;       
    struct gbm_surface *m_pGbmSurface;     
 
    EGLSurface m_eglSurface;               
    EGLDisplay m_eglDisplay;               
    EGLContext m_eglContext;               
    bool m_glInitiated;                    
 
    int InitEGL(void);
    EGLConfig GetEGLConfig(void);
    int InitGbm(int, int, uint32_t, uint64_t);
#endif
};
 
#endif