drm单个framebuffer显示

已于 2022-12-21 16:45:52 修改
阅读量961 收藏 6
点赞数
分类专栏： libdrm 文章标签： java 算法 c++
于 2022-12-21 16:35:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39678541/article/details/128398969
版权

Drm 单个buff显示

这章介绍drm的部分的函数和结构体，实现单个frambuffer的显示

drm buff相关结构体

struct buffer object

struct buffer_object {
	unsigned int width;
	unsigned int height;
	unsigned int pitch;		//图片每一行数据所占字节数 例800*1280 rgb  ->800*3
	unsigned int handle;	//gem 缓冲区fd
	unsigned int size;
	unsigned int *vaddr;
	unsigned int fb_id;		//framebuffer创建的bufid
};

struct drm_mode_create_dumb

struct drm_mode_create_dumb {
	//user fill in
	__u32 height;
	__u32 width;
	__u32 bpp;		//像素位深
	__u32 flags;	//current unused
	//kernel return fill in
	__u32 handle;	//gem 缓冲区fd
	__u32 pitch;	//图片每一行数据所占字节数 例800*1280 rgb  ->800*3
	__u64 size;		//(height * pitch + width) * bpp / 4
};

struct drm_mode_map_dumb

struct drm_mode_map_dumb {
	__u32 handle;		//申请的gem handle
	__u32 pad;			//unused

	__u64 offset;		//用于mmap的偏移大小
};

通过ioctl来创建获取dumb buf

/* 创建一个dumb buffer
ioctl can be used to create a dumb buffer. The kernel will return a 32bit handle
that can be used to manage the buffer with the DRM API. You can create framebuffers with
*/
DRM_IOCTL_MODE_CREATE_DUMB
/*获取dumb内存映射偏移值
ioctl requests the DRM subsystem to prepare the buffer for memory-mapping and returns a
fake-offset that can be used with*/
DRM_IOCTL_MODE_MAP_DUMB

drmModeRes

typedef struct _drmModeRes {
    int count_fbs;		//当前申请的framebuffer的数量
    uint32_t *fbs;		

    int count_crtcs;	//可用的crtcs配置
    uint32_t *crtcs;

    int count_connectors;	//可用的连接器connectors
    uint32_t *connectors;

    int count_encoders;		//可用的编码器encoders 
    uint32_t *encoders;

    uint32_t min_width, max_width;
    uint32_t min_height, max_height;
} drmModeRes, *drmModeResPtr;

drm相关操作函数

drmSetClientCap

drm设置客户端属性

/** DRM_IOCTL_SET_CLIENT_CAP ioctl argument type */
struct drm_set_client_cap {
	__u64 capability;
	__u64 value;
};
/**
 * DRM_CLIENT_CAP_STEREO_3D
 *
 * if set to 1, the DRM core will expose the stereo 3D capabilities of the
 * monitor by advertising the supported 3D layouts in the flags of struct
 * drm_mode_modeinfo.
 */
#define DRM_CLIENT_CAP_STEREO_3D	1

/**
 * DRM_CLIENT_CAP_UNIVERSAL_PLANES
 *
 * If set to 1, the DRM core will expose all planes (overlay, primary, and
 * cursor) to userspace.
 */
#define DRM_CLIENT_CAP_UNIVERSAL_PLANES  2

/**
 * DRM_CLIENT_CAP_ATOMIC
 *
 * If set to 1, the DRM core will expose atomic properties to userspace
 */
#define DRM_CLIENT_CAP_ATOMIC	3

int drmSetClientCap(int fd, uint64_t capability, uint64_t value)
{
    struct drm_set_client_cap cap;

    memclear(cap);
    cap.capability = capability;
    cap.value = value;

    return drmIoctl(fd, DRM_IOCTL_SET_CLIENT_CAP, &cap);
}

drmModeGetResources

获取card的所有资源信息

drmModeResPtr drmModeGetResources(int fd)
{
	struct drm_mode_card_res res, counts;
	drmModeResPtr r = 0;

retry:
	memclear(res);
	if (drmIoctl(fd, DRM_IOCTL_MODE_GETRESOURCES, &res))
		return 0;

	counts = res;

	if (res.count_fbs) {
		res.fb_id_ptr = VOID2U64(drmMalloc(res.count_fbs*sizeof(uint32_t)));
		if (!res.fb_id_ptr)
			goto err_allocs;
	}
	if (res.count_crtcs) {
		res.crtc_id_ptr = VOID2U64(drmMalloc(res.count_crtcs*sizeof(uint32_t)));
		if (!res.crtc_id_ptr)
			goto err_allocs;
	}
	if (res.count_connectors) {
		res.connector_id_ptr = VOID2U64(drmMalloc(res.count_connectors*sizeof(uint32_t)));
		if (!res.connector_id_ptr)
			goto err_allocs;
	}
	if (res.count_encoders) {
		res.encoder_id_ptr = VOID2U64(drmMalloc(res.count_encoders*sizeof(uint32_t)));
		if (!res.encoder_id_ptr)
			goto err_allocs;
	}

	if (drmIoctl(fd, DRM_IOCTL_MODE_GETRESOURCES, &res))
		goto err_allocs;

	/* The number of available connectors and etc may have changed with a
	 * hotplug event in between the ioctls, in which case the field is
	 * silently ignored by the kernel.
	 */
	if (counts.count_fbs < res.count_fbs ||
	    counts.count_crtcs < res.count_crtcs ||
	    counts.count_connectors < res.count_connectors ||
	    counts.count_encoders < res.count_encoders)
	{
		drmFree(U642VOID(res.fb_id_ptr));
		drmFree(U642VOID(res.crtc_id_ptr));
		drmFree(U642VOID(res.connector_id_ptr));
		drmFree(U642VOID(res.encoder_id_ptr));

		goto retry;
	}

	/*
	 * return
	 */
	if (!(r = drmMalloc(sizeof(*r))))
		goto err_allocs;

	r->min_width     = res.min_width;
	r->max_width     = res.max_width;
	r->min_height    = res.min_height;
	r->max_height    = res.max_height;
	r->count_fbs     = res.count_fbs;
	r->count_crtcs   = res.count_crtcs;
	r->count_connectors = res.count_connectors;
	r->count_encoders = res.count_encoders;

	r->fbs        = drmAllocCpy(U642VOID(res.fb_id_ptr), res.count_fbs, sizeof(uint32_t));
	r->crtcs      = drmAllocCpy(U642VOID(res.crtc_id_ptr), res.count_crtcs, sizeof(uint32_t));
	r->connectors = drmAllocCpy(U642VOID(res.connector_id_ptr), res.count_connectors, sizeof(uint32_t));
	r->encoders   = drmAllocCpy(U642VOID(res.encoder_id_ptr), res.count_encoders, sizeof(uint32_t));
	if ((res.count_fbs && !r->fbs) ||
	    (res.count_crtcs && !r->crtcs) ||
	    (res.count_connectors && !r->connectors) ||
	    (res.count_encoders && !r->encoders))
	{
		drmFree(r->fbs);
		drmFree(r->crtcs);
		drmFree(r->connectors);
		drmFree(r->encoders);
		drmFree(r);
		r = 0;
	}

err_allocs:
	drmFree(U642VOID(res.fb_id_ptr));
	drmFree(U642VOID(res.crtc_id_ptr));
	drmFree(U642VOID(res.connector_id_ptr));
	drmFree(U642VOID(res.encoder_id_ptr));

	return r;
}

drmModeFreeResources

void drmModeFreeResources(drmModeResPtr ptr)
{
	if (!ptr)
		return;

	drmFree(ptr->fbs);
	drmFree(ptr->crtcs);
	drmFree(ptr->connectors);
	drmFree(ptr->encoders);
	drmFree(ptr);
}

drmModeGetConnector

获取card的connector的所有信息

static drmModeConnectorPtr
_drmModeGetConnector(int fd, uint32_t connector_id, int probe)
{
	struct drm_mode_get_connector conn, counts;
	drmModeConnectorPtr r = NULL;
	struct drm_mode_modeinfo stack_mode;

	memclear(conn);
	conn.connector_id = connector_id;
	if (!probe) {
		conn.count_modes = 1;
		conn.modes_ptr = VOID2U64(&stack_mode);
	}

	if (drmIoctl(fd, DRM_IOCTL_MODE_GETCONNECTOR, &conn))
		return 0;

retry:
	counts = conn;

	if (conn.count_props) {
		conn.props_ptr = VOID2U64(drmMalloc(conn.count_props*sizeof(uint32_t)));
		if (!conn.props_ptr)
			goto err_allocs;
		conn.prop_values_ptr = VOID2U64(drmMalloc(conn.count_props*sizeof(uint64_t)));
		if (!conn.prop_values_ptr)
			goto err_allocs;
	}

	if (conn.count_modes) {
		conn.modes_ptr = VOID2U64(drmMalloc(conn.count_modes*sizeof(struct drm_mode_modeinfo)));
		if (!conn.modes_ptr)
			goto err_allocs;
	} else {
		conn.count_modes = 1;
		conn.modes_ptr = VOID2U64(&stack_mode);
	}

	if (conn.count_encoders) {
		conn.encoders_ptr = VOID2U64(drmMalloc(conn.count_encoders*sizeof(uint32_t)));
		if (!conn.encoders_ptr)
			goto err_allocs;
	}

	if (drmIoctl(fd, DRM_IOCTL_MODE_GETCONNECTOR, &conn))
		goto err_allocs;

	/* The number of available connectors and etc may have changed with a
	 * hotplug event in between the ioctls, in which case the field is
	 * silently ignored by the kernel.
	 */
	if (counts.count_props < conn.count_props ||
	    counts.count_modes < conn.count_modes ||
	    counts.count_encoders < conn.count_encoders) {
		drmFree(U642VOID(conn.props_ptr));
		drmFree(U642VOID(conn.prop_values_ptr));
		if (U642VOID(conn.modes_ptr) != &stack_mode)
			drmFree(U642VOID(conn.modes_ptr));
		drmFree(U642VOID(conn.encoders_ptr));

		goto retry;
	}

	if(!(r = drmMalloc(sizeof(*r)))) {
		goto err_allocs;
	}

	r->connector_id = conn.connector_id;
	r->encoder_id = conn.encoder_id;
	r->connection   = conn.connection;
	r->mmWidth      = conn.mm_width;
	r->mmHeight     = conn.mm_height;
	/* convert subpixel from kernel to userspace */
	r->subpixel     = conn.subpixel + 1;
	r->count_modes  = conn.count_modes;
	r->count_props  = conn.count_props;
	r->props        = drmAllocCpy(U642VOID(conn.props_ptr), conn.count_props, sizeof(uint32_t));
	r->prop_values  = drmAllocCpy(U642VOID(conn.prop_values_ptr), conn.count_props, sizeof(uint64_t));
	r->modes        = drmAllocCpy(U642VOID(conn.modes_ptr), conn.count_modes, sizeof(struct drm_mode_modeinfo));
	r->count_encoders = conn.count_encoders;
	r->encoders     = drmAllocCpy(U642VOID(conn.encoders_ptr), conn.count_encoders, sizeof(uint32_t));
	r->connector_type  = conn.connector_type;
	r->connector_type_id = conn.connector_type_id;

	if ((r->count_props && !r->props) ||
	    (r->count_props && !r->prop_values) ||
	    (r->count_modes && !r->modes) ||
	    (r->count_encoders && !r->encoders)) {
		drmFree(r->props);
		drmFree(r->prop_values);
		drmFree(r->modes);
		drmFree(r->encoders);
		drmFree(r);
		r = 0;
	}

err_allocs:
	drmFree(U642VOID(conn.prop_values_ptr));
	drmFree(U642VOID(conn.props_ptr));
	if (U642VOID(conn.modes_ptr) != &stack_mode)
		drmFree(U642VOID(conn.modes_ptr));
	drmFree(U642VOID(conn.encoders_ptr));

	return r;
}

drmModeFreeConnector

释放connector

void drmModeFreeConnector(drmModeConnectorPtr ptr)
{
	if (!ptr)
		return;

	drmFree(ptr->encoders);
	drmFree(ptr->prop_values);
	drmFree(ptr->props);
	drmFree(ptr->modes);
	drmFree(ptr);
}

drmModeObjectGetProperties

获取connector dpms （Display Power Manage System）属性

drmModeObjectPropertiesPtr drmModeObjectGetProperties(int fd,
						      uint32_t object_id,
						      uint32_t object_type)
{
	struct drm_mode_obj_get_properties properties;
	drmModeObjectPropertiesPtr ret = NULL;
	uint32_t count;

retry:
	memclear(properties);
	properties.obj_id = object_id;
	properties.obj_type = object_type;

	if (drmIoctl(fd, DRM_IOCTL_MODE_OBJ_GETPROPERTIES, &properties))
		return 0;

	count = properties.count_props;

	if (count) {
		properties.props_ptr = VOID2U64(drmMalloc(count *
							  sizeof(uint32_t)));
		if (!properties.props_ptr)
			goto err_allocs;
		properties.prop_values_ptr = VOID2U64(drmMalloc(count *
						      sizeof(uint64_t)));
		if (!properties.prop_values_ptr)
			goto err_allocs;
	}

	if (drmIoctl(fd, DRM_IOCTL_MODE_OBJ_GETPROPERTIES, &properties))
		goto err_allocs;

	if (count < properties.count_props) {
		drmFree(U642VOID(properties.props_ptr));
		drmFree(U642VOID(properties.prop_values_ptr));
		goto retry;
	}
	count = properties.count_props;

	ret = drmMalloc(sizeof(*ret));
	if (!ret)
		goto err_allocs;

	ret->count_props = count;
	ret->props = drmAllocCpy(U642VOID(properties.props_ptr),
				 count, sizeof(uint32_t));
	ret->prop_values = drmAllocCpy(U642VOID(properties.prop_values_ptr),
				       count, sizeof(uint64_t));
	if (ret->count_props && (!ret->props || !ret->prop_values)) {
		drmFree(ret->props);
		drmFree(ret->prop_values);
		drmFree(ret);
		ret = NULL;
	}

err_allocs:
	drmFree(U642VOID(properties.props_ptr));
	drmFree(U642VOID(properties.prop_values_ptr));
	return ret;
}

drmModeGetEncoder

获取Encoder

drmModeEncoderPtr drmModeGetEncoder(int fd, uint32_t encoder_id)
{
	struct drm_mode_get_encoder enc;
	drmModeEncoderPtr r = NULL;

	memclear(enc);
	enc.encoder_id = encoder_id;

	if (drmIoctl(fd, DRM_IOCTL_MODE_GETENCODER, &enc))
		return 0;

	if (!(r = drmMalloc(sizeof(*r))))
		return 0;

	r->encoder_id = enc.encoder_id;
	r->crtc_id = enc.crtc_id;
	r->encoder_type = enc.encoder_type;
	r->possible_crtcs = enc.possible_crtcs;
	r->possible_clones = enc.possible_clones;

	return r;
}

drmModeGetCrtc

Retrive information about the ctrt crtcId

drmModeCrtcPtr drmModeGetCrtc(int fd, uint32_t crtcId)
{
	struct drm_mode_crtc crtc;
	drmModeCrtcPtr r;

	memclear(crtc);
	crtc.crtc_id = crtcId;

	if (drmIoctl(fd, DRM_IOCTL_MODE_GETCRTC, &crtc))
		return 0;

	/*
	 * return
	 */

	if (!(r = drmMalloc(sizeof(*r))))
		return 0;

	r->crtc_id         = crtc.crtc_id;
	r->x               = crtc.x;
	r->y               = crtc.y;
	r->mode_valid      = crtc.mode_valid;
	if (r->mode_valid) {
		memcpy(&r->mode, &crtc.mode, sizeof(struct drm_mode_modeinfo));
		r->width = crtc.mode.hdisplay;
		r->height = crtc.mode.vdisplay;
	}
	r->buffer_id       = crtc.fb_id;
	r->gamma_size      = crtc.gamma_size;
	return r;
}

drmModeAddFB

Creates a new framebuffer with an buffer object as its scanout buffer

创建一个具有buffer对象的framebuffer作为扫描buffer

int drmModeAddFB(int fd, uint32_t width, uint32_t height, uint8_t depth,
		 uint8_t bpp, uint32_t pitch, uint32_t bo_handle,
		 uint32_t *buf_id)
{
	struct drm_mode_fb_cmd f;
	int ret;

	memclear(f);
	f.width  = width;
	f.height = height;
	f.pitch  = pitch;
	f.bpp    = bpp;
	f.depth  = depth;
	f.handle = bo_handle;

	if ((ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_ADDFB, &f)))
		return ret;

	*buf_id = f.fb_id;
	return 0;
}

drmModeRmFB

释放创建的framebuffer

int drmModeRmFB(int fd, uint32_t bufferId)
{
	return DRM_IOCTL(fd, DRM_IOCTL_MODE_RMFB, &bufferId);
}

drmModeSetCrtc

Set the mode on a crtc crtcId with the given mode modeId.

int drmModeSetCrtc(int fd, uint32_t crtcId, uint32_t bufferId,
		   uint32_t x, uint32_t y, uint32_t *connectors, int count,
		   drmModeModeInfoPtr mode)
{
	struct drm_mode_crtc crtc;

	memclear(crtc);
	crtc.x             = x;
	crtc.y             = y;
	crtc.crtc_id       = crtcId;
	crtc.fb_id         = bufferId;
	crtc.set_connectors_ptr = VOID2U64(connectors);
	crtc.count_connectors = count;
	if (mode) {
	  memcpy(&crtc.mode, mode, sizeof(struct drm_mode_modeinfo));
	  crtc.mode_valid = 1;
	}

	return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETCRTC, &crtc);
}

例程

伪代码

1.open card

2.获取card的connector和encoder id

3.创建dumb buffer ，从内存中获取dumb 映射的偏移值，mmap申请，申请framebuffer 填充dumb buffer

4.销毁资源

代码

#include <stdio.h>
#include <errno.h>
#include "xf86drmMode.h"
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>

#define DRM_CARD    "/dev/dri/card0"
#define check_ptr(ptr) do{ \
    if(ptr == NULL) { \
        printf("ptr is NULL\n"); \
        return -1; \
    } \
} while (0)


#define drm_print(fmt, args...) \
do \
{ \
	printf("func:%s line:%d "#fmt"\n",  __FUNCTION__, __LINE__, ##args); \
}while (0)

typedef struct _buffer_object {
	unsigned int width;
	unsigned int height;
	unsigned int pitch;
	unsigned int handle;
	unsigned int size;
	unsigned char *vaddr;
	unsigned int fb_id;
}buffer_object;


typedef struct  _drm_ctx{
    int fd;    
    buffer_object buf;
    unsigned int conector_id;
    unsigned int crtc_id;
    unsigned int encoder_id;
}drm_ctx;

drm_ctx gdrm_var;

static int creat_fb(int fd, buffer_object *bo)
{
    struct drm_mode_create_dumb creq;
    struct drm_mode_map_dumb mreq;
    int ret;

    creq.width = bo->width;
    creq.height = bo->height;
    creq.bpp = 32;

    ret = ioctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &creq);
    if(ret != 0)
    {
        drm_print("ioctl creat dumb fail\n");
        return -1;
    }

    bo->pitch = creq.pitch;
    bo->handle = creq.handle;
    bo->size = creq.size;

    drmModeAddFB(fd, bo->width, bo->height, 24, 32, bo->pitch, bo->handle, &bo->fb_id);

    mreq.handle = bo->handle;
    ret = ioctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &mreq);
    if(ret != 0)
    {
        drm_print("ioctl mmap dumb fail\n");
        return -1;
    }
        /* perform actual memory mapping */
    bo->vaddr = mmap(0, creq.size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, mreq.offset);
    check_ptr(bo->vaddr);
    //使用crtc驱动connector
    memset(bo->vaddr, 0xff, bo->size);

    return 0;
}

static int destroy_fb(int fd, buffer_object *bo)
{
    int ret;
    struct drm_mode_destroy_dumb dreq;

    drmModeRmFB(fd, bo->fb_id);
    dreq.handle = bo->handle;
    ret = ioctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &dreq);
    if(ret != 0)
    {
        drm_print("ioctl destory dumb fail\n");
        return -1;
    }
    
    munmap(bo->vaddr, bo->size);
}

int main(int argc, char *argv[])
{
    //open card
    drmModeResPtr   resptr;
    drmModeConnectorPtr conptr;

    int ret;
    unsigned int fb;

    gdrm_var.fd = open(DRM_CARD, O_RDWR);
    if(gdrm_var.fd < 0)
    {
        perror("open card fail\n");
        return -1;
    }

    drm_print("fd%d\n", gdrm_var.fd);
    //获取card resource，include crtc connector encoder plane
    resptr = drmModeGetResources(gdrm_var.fd);
    check_ptr(resptr);

    gdrm_var.crtc_id = resptr->crtcs[0];
    gdrm_var.conector_id = resptr->connectors[0];
    drm_print("crtc id:%d conector_id %d", gdrm_var.crtc_id, gdrm_var.conector_id);
    //printf("%s %d crtc_id:%d con_id:%d\n", resptr->count_crtcs, resptr->count_connectors);
    //select which connector used
    conptr = drmModeGetConnector(gdrm_var.fd, gdrm_var.conector_id);
    check_ptr(conptr);
    gdrm_var.buf.width = conptr->modes[0].hdisplay;
    gdrm_var.buf.height = conptr->modes[0].vdisplay;
    drm_print("%d %d", gdrm_var.buf.width, gdrm_var.buf.height);
    //create framebuffer, fill dumb buffer
    creat_fb(gdrm_var.fd, &gdrm_var.buf);

    drmModeSetCrtc(gdrm_var.fd, gdrm_var.crtc_id, gdrm_var.buf.fb_id,
                   0, 0, &gdrm_var.conector_id, 1, &conptr->modes[0]);
    //destory dumb buffer
    sleep(5);
    destroy_fb(gdrm_var.fd, &gdrm_var.buf);
    drmModeFreeConnector(conptr);
    drmModeFreeResources(resptr);
    
    close(gdrm_var.fd);
}
不吃辣的同学
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图显系统DRM FRAMEBUFFER完全解析
多年芯片设计领域从业经验，负责芯片bringup以及kernel驱动开发。
09-12 4074
1. frame buffers 介绍 frame buffers 是一个抽象出来的内存对象，用于向 CRTC 扇出像素数据。应用程序通过 DRM_IOCTL_MODE_ADDFB(2) ioctls 来显示的申请创建 frame buffers。内核空间代码创建完成后返回 handle 值，该值可以用于控制 CRTC、PLANE 等模块。后面以 fb 代替 frame buffer。 内核空间需要实现显存管理器以支持 fb 的创建。例如应用程序可以发送 GEM handle 值触其发申请内存空间。对于图显
DRM全解析 —— framebuffer详解（2）
phmatthaus的专栏
10-09 222
DRM全解析 —— framebuffer详解（2）
最简单的DRM应用程序 （single-buffer）
qq_42538455的博客
08-03 407
(DRM)Direct Rendering Manager学习
mtk-drm初始化
zhexingsunba的博客
09-25 3001
mtk-drm初始化走读
display: drm: virtio-gpu-drm
maze的专栏
08-17 1571
static struct virtio_driver virtio_gpu_driver = { .feature_table = features, .feature_table_size = ARRAY_SIZE(features), … .id_table = id_table, .probe = virtio_gpu_probe, .remove = virtio_gpu_remove, .config_changed = virtio_gpu_...
嵌入式linux通用截图工具(增强版）
06-20
gsnap不基于任何具体的GUI，直接从framebuffer中截图，所以适用于任何嵌入式linux设备。
最新DRM系统源码下载
最新发布
03-30
DRM（Digital Rights Management，数字版权管理）是一种用于保护数字内容版权的技术，它允许内容创建者、发行者或版权所有者控制、管理和限制数字媒体的使用。在这个“最新DRM系统源码下载”的资源中，我们可以推测...
rockchip_drm框架介绍
04-21
此外，Rockchip_DRM还负责管理多个显示通道，支持多屏输出或单屏多路显示。 在代码层面，rockchip_drm通常包含以下几个关键部分： 1. **设备驱动**：这是与硬件直接交互的部分，包括初始化硬件、配置寄存器、设置...
drm.rar_DRM
09-21
在Linux系统中，DRM框架（Direct Rendering Manager）是内核的一部分，它负责管理和控制图形硬件，如GPU，以支持图形处理和显示任务。在TI OMAP平台上，DRM系统对于确保高效、安全的多媒体内容播放至关重要。 TI ...
drm.rar drm 測試demo
04-19
DRM，全称为Digital Rights Management，即数字版权管理，是一种用于保护数字内容版权的技术。它主要应用于音频、视频、电子书等数字媒体，通过加密手段防止未经授权的复制、分发和非法使用。在这个"drm.rar drm ...
[Linux 基础] -- Linux DRM（三）RK 平台 DRM 代码分析 - Rockchip
u014674293的博客
04-27 8649
一、概览 不知道大家是否还记得，之前我有引用 Wiki 中对 DRM 的介绍，这里我们再回顾一下：DRM 由两个部分组成：一是 Kernel 的子系统，这个子系统对硬件 GPU 操作进行了一层框架封装。二是提供了一个 libdrm 库，里面封装了一系列 API，用来进行图像显示。整体来看和 Android 上所采用的 Direct Frame Buffer 差不多。Android Kernel ...
libdrm全解析四十 —— 源码全解析（37）
phmatthaus的专栏
09-02 435
libdrm全解析四十 —— 源码全解析（37）
Framebuffer 驱动学习总结（一） ---- 总体架构及关键结构体
Xiaohui6666的博客
02-01 495
一、Framebuffer 设备驱动总体架构 帧缓冲设备为标准的字符型设备，在Linux中主设备号29，定义在/include/linux/major.h中的FB_MAJOR，次设备号定义帧缓冲的个数，最大允许有32个FrameBuffer，定义在/include/linux/fb.h中的FB_MAX，对应于文件系统下/dev/fb%d设备文件。 我们从上...
LCD DRM驱动框架分析一
qq_33782617的博客
08-09 3392
主要是介绍LCD DRM框架所涉及的内容。
linux下实现对framebuffer(/dev/fb0)的截屏操作
weixin_45312249的博客
11-21 2901
在linux系统中,使用framebuffer来提供用户态进程直接操作显示屏的功能. 在嵌入式系统开发中,需要对显示屏的内容进行截取,实现一个lcd截屏工具实现对显示屏内容的截取,存储为bmp格式. 一个bmp文件有四部分组成: 其中位图文件头内容如下: WORD bfType; DWORD bfSize; WORD bfReserved1; WORD bfReserved2; DWORD bfOffBits; bfType 说
RK3568平台开发系列讲解（显示篇） DRM显示系统组成分析
内核笔记
03-08 1829
📢让我们分析一下绿框中的五个部件，以及他们的联动。
DRM全解析 —— framebuffer详解（1）
phmatthaus的专栏
10-09 512
DRM全解析 —— framebuffer详解（1）
LINUX DRM 入门一条龙
weixin_45154862的博客
02-20 2386
Linux DRM入门一条龙
Drm 例程2 双dumb buffer显示
南大侠的博客
12-21 555
显示过程中，drm是通过申请framebuffer 填充其中的dumb的buf来显示的，drmModeAddFB对不同的dumb buff拿到的bufid也不一样，最终使用drmModeSetCrtc来设定参数，使用dumb的bufid来填充相应的buf值。
drm_framebuffer_put
10-23
drm_framebuffer_put是一个函数，用于减少对DRM（Direct Rendering Manager）帧缓冲对象的引用计数。在Linux内核中，DRM用于提供对图形硬件的直接访问和管理。 当一个进程不再需要使用某个DRM帧缓冲对象时，可以调用drm_framebuffer_put函数将其引用计数减少。这样做是为了确保系统中有且仅有一个持有对该帧缓冲对象的引用的进程。当帧缓冲对象的引用计数为零时，系统可以释放该帧缓冲对象以回收资源。 使用drm_framebuffer_put函数需要传入一个指向drm_framebuffer结构体的指针作为参数。该结构体用于描述帧缓冲对象的属性，例如宽度、高度、像素格式等。 调用drm_framebuffer_put函数会递减帧缓冲对象的引用计数，并在引用计数归零时释放帧缓冲对象。同时，该函数还会清除帧缓冲对象中的引用计数标志，并在需要时释放与之关联的其他资源。 通常情况下，只有调用过drm_framebuffer_get函数的进程才能调用drm_framebuffer_put函数。因为只有进程持有帧缓冲对象的引用，才能够对其进行减引用操作。 总之，drm_framebuffer_put函数是用于减少对DRM帧缓冲对象引用计数的函数。通过调用该函数，可以释放帧缓冲对象以回收资源，并确保系统中仅有一个进程持有对该帧缓冲对象的引用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值