drmdevice.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef __DRMDEVICE_H
#define __DRMDEVICE_H
 
#include <array>
#include <cstdint>
#include <string>
 
#ifdef USE_GLES
#include <EGL/egl.h>
#endif
 
#include <xf86drm.h>
#include <xf86drmMode.h>
 
#include "config.h"
#include "drmplane.h"
 
#ifdef USE_GLES
class cDrmBuffer;
#endif
 
class cVideoRender;
 
inline constexpr std::array DrmModeWhitelist = {
    // 2160p (4K)
    sDrmMode{ 3840, 2160, 60.00, false },
    sDrmMode{ 3840, 2160, 59.94, false },
    sDrmMode{ 3840, 2160, 50.00, false },
    sDrmMode{ 3840, 2160, 30.00, false  },
    sDrmMode{ 3840, 2160, 29.97, false  },
    sDrmMode{ 3840, 2160, 25.00, false  },
    sDrmMode{ 3840, 2160, 24.00, false  },
    sDrmMode{ 3840, 2160, 23.98, false  },
 
    // 1080p (FullHD progressive)
    sDrmMode{ 1920, 1080, 60.00, false },
    sDrmMode{ 1920, 1080, 59.94, false },
    sDrmMode{ 1920, 1080, 50.00, false },
    sDrmMode{ 1920, 1080, 30.00, false },
    sDrmMode{ 1920, 1080, 29.97, false },
    sDrmMode{ 1920, 1080, 25.00, false },
    sDrmMode{ 1920, 1080, 24.00, false },
    sDrmMode{ 1920, 1080, 23.98, false },
 
    // 1080i (FullHD interlaced)
    sDrmMode{ 1920, 1080, 30.00, true  }, // 1928x1080@60i
    sDrmMode{ 1920, 1080, 29.97, true  }, // 1928x1080@59.94i
    sDrmMode{ 1920, 1080, 25.00, true  }, // 1928x1080@50i
 
    // 720p (HDready)
    sDrmMode{ 1280, 720, 60.00,  false },
    sDrmMode{ 1280, 720, 59.94,  false },
    sDrmMode{ 1280, 720, 50.00,  false },
};
 
class cDrmDevice {
public:
    cDrmDevice(cVideoRender *, cSoftHdConfig *);
    ~cDrmDevice(void);
 
    int Init(void);
    int ReInit(void);
#ifdef USE_GLES
    int InitGbm(void);
    void ExitGbm(void);
    int InitEGL(void);
#endif
    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; };
    uint64_t OsdWidth(void) { return m_userReqOsdWidth ? m_userReqOsdWidth : DisplayWidth(); };
    uint64_t OsdHeight(void) { return m_userReqOsdWidth ? m_userReqOsdHeight : DisplayHeight(); };
 
    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; };
    bool CanHandleMode(sDrmMode *);
 
    // 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;               
    cSoftHdConfig *m_pConfig;              
 
    int m_fdDrm = -1;                      
    uint32_t m_connectorId;                
    std::string m_connectorName;           
    drmModeModeInfo m_drmModeInfo;         
    uint32_t m_crtcId;                     
    uint32_t m_crtcIndex;                  
    uint32_t m_hdrMetadata = 0;            
    drmModeCrtc *m_drmModeCrtcSaved;       
    drmEventContext m_drmEventCtx;         
 
    const char *m_userDrmDevice = nullptr; 
    const char *m_userDrmConnector = nullptr; 
    int m_userReqDisplayWidth = 0;         
    int m_userReqDisplayHeight;            
    double m_userReqDisplayRefreshRate;    
    bool m_userReqDisplayInterlaced;       
    int m_userReqOsdWidth = 0;             
    int m_userReqOsdHeight;                
 
    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);
    drmModeConnector *FindDrmConnector(int, drmModeRes *, const char *);
    int32_t FindCrtcForConnector(const drmModeRes *, const drmModeConnector *);
    int FindMode(void);
#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;                    
 
    EGLConfig GetEGLConfig(void);
#endif
};
 
#endif