drmbuffer.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef __DRMBUFFER_H
#define __DRMBUFFER_H
 
#include <cstdint>
 
extern "C" {
#include <libavutil/frame.h>
#include <libavutil/hwcontext_drm.h>
}
 
#include <drm_fourcc.h>
 
#include <vdr/osd.h>
 
#include "pool.h"
 
struct format_plane_info {
    uint8_t bitspp;
    uint8_t xsub;
    uint8_t ysub;
};
 
struct format_info {
    uint32_t format;
    const char *fourcc;
    uint8_t num_planes;
    struct format_plane_info planes[4];
};
 
class cDrmBuffer {
public:
    cDrmBuffer(void);
#ifdef USE_GLES
    cDrmBuffer(int, uint32_t, uint32_t, uint32_t, struct gbm_bo *);
#endif
 
    void Setup(int, uint32_t, uint32_t, uint32_t, AVDRMFrameDescriptor *, bool);
    void Destroy(void);
    void FillBlack(void);
 
    // setter and getter methods
    uint32_t Width(void) { return m_width; };
    void SetWidth(uint32_t width) { m_width = width; };
    uint32_t Height(void) { return m_height; };
    void SetHeight(uint32_t height) { m_height = height; };
    uint32_t PixFmt(void) { return m_pixFmt; };
    void SetPixFmt(uint32_t pixFmt) { m_pixFmt = pixFmt; };
 
    bool IsDirty(void) { return m_dirty; };
    void MarkClean(void) { m_dirty = false; };
    void MarkDirty(void) { m_dirty = true; };
    bool IsPresentationPending(void) { return m_presentationPending; };
    void SetPresentationPending(bool pending) { m_presentationPending = pending; };
 
    int Id(void) { return m_fbId; };
    void SetId(int id) { m_fbId = id; };
    void SetFdDrm(int fdDrm) { m_drmDeviceFd = fdDrm; };
    int NumPlanes(void) { return m_numPlanes; };
    void SetNumPlanes(int numPlanes) { m_numPlanes = numPlanes; };
    int DmaBufHandle(void) { return m_dmaBufHandle[0]; };
    int DmaBufHandle(int idx) { return m_dmaBufHandle[idx]; };
    void SetDmaBufHandle(uint32_t fd) { m_dmaBufHandle[0] = fd; };
    void SetNumObjects(int numObjects) { m_numObjects = numObjects; };
    int NumObjects(void) { return m_numObjects; };
    void SetObjectIndex(int idx, uint32_t objIdx) { m_objIdx[idx] = objIdx; };
    int ObjectIndex(int idx) { return m_objIdx[idx]; };
    uint8_t *Plane(int idx) { return m_pPlane[idx]; };
    uint32_t PrimeHandle(int idx) { return m_planePrimeHandle[idx]; };
    uint32_t *PrimeHandle(void) { return m_planePrimeHandle; };
    void SetHandle(int idx, uint32_t handle) { m_planePrimeHandle[idx] = handle; };
    uint32_t Offset(int idx) { return m_offset[idx]; };
    uint32_t *Offset(void) { return m_offset; };
    void SetOffset(int idx, uint32_t offset) { m_offset[idx] = offset; };
    uint32_t Pitch(int idx) { return m_pitch[idx]; };
    uint32_t *Pitch(void) { return m_pitch; };
    void SetPitch(int idx, uint32_t pitch) { m_pitch[idx] = pitch; };
    uint32_t Size(int idx) { return m_size[idx]; };
    uint32_t *Size(void) { return m_size; };
    void SetSize(int idx, uint32_t size) { m_size[idx] = size; };
    uint64_t Modifier(void) { return m_modifier; };
    AVFrame *frame = nullptr;   
    void SetDestroyAfterUse(bool val) { m_destroyAfterUse = val; };
    void PresentationFinished(void);
    void SetSizeOnScreen(int x, int y, int w, int h) { m_rectOnScreen.Set(x, y, w, h); };
    cRect GetScreenRect(void) { return m_rectOnScreen; };
 
private:
    uint32_t m_width;           
    uint32_t m_height;          
    uint32_t m_pixFmt;          
 
    cRect m_rectOnScreen;       
 
    bool m_dirty;               
 
    uint32_t m_fbId;            
    int m_drmDeviceFd;          
 
    int m_numPlanes;            
 
    int m_dmaBufHandle[4];      
    int m_numObjects;           
    int m_objIdx[4];            
    uint32_t m_objectPrimeHandle[4]; 
 
    uint8_t *m_pPlane[4];       
    uint32_t m_planePrimeHandle[4];  
    uint32_t m_offset[4];       
    uint32_t m_pitch[4];        
    uint32_t m_size[4]{0};      
    uint64_t m_modifier = DRM_FORMAT_MOD_INVALID;
 
    bool m_presentationPending = false; 
    bool m_destroyAfterUse = false;     
    bool m_closeHandleOnDestroy;        
 
#ifdef USE_GLES
    struct gbm_bo *m_pBo;       
#endif
};
 
class cDrmBufferPool : public cPool<cDrmBuffer> {
public:
    cDrmBufferPool() : cPool<cDrmBuffer>(RENDERBUFFERS) {}
    cDrmBuffer *FindUninitilized(void);
    cDrmBuffer *FindNoPresentationPending(void);
    cDrmBuffer *FindByDmaBufHandle(int);
    void DestroyAllExcept(cDrmBuffer *);
private:
    constexpr static int RENDERBUFFERS = 36;    
};
 
 
#endif