Linux的帧缓冲（Frame Buffer）之三：LCD上显示摄像头

最新推荐文章于 2025-05-06 19:30:36 发布
转载 最新推荐文章于 2025-05-06 19:30:36 发布 · 858 阅读 · 2

本文介绍了一个简单的应用程序，用于实现在LCD上显示当前camera的图像数据，并可根据键盘输入保存摄像头数据到BMP图片中。该程序使用了V4L2和FB设备进行数据交互。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一个简单的应用程序，来实现在LCD上显示当前camera的图像数据，也可以根据键盘输入保存摄像头数据到BMP图片中。

（1） 如下：

         文件头和全局变量：

[cpp] view plain copy print ?
  1. #include <stdio.h> 
  2. #include <string.h> 
  3. #include <stdlib.h> 
  4. #include <fcntl.h> 
  5. #include <unistd.h> 
  6. #include <ctype.h> 
  7. #include <errno.h> 
  8. #include <sys/mman.h> 
  9. #include <sys/time.h> 
  10. #include <sys/ioctl.h> 
  11. #include <asm/types.h>  
  12. #include <linux/videodev2.h> 
  13. #include <linux/fb.h> 
  14.  
  15. static unsigned int capframe = 0;       //保存的图片计数 
  16. static char filename[30];       //保存的图片文件名 
  17. FILE *bmpFile;                  //保存图片时创建的文件指针 
  18.  
  19. unsigned char bmp_head_t[] = {          //66字节的BMP位图头 
  20.          0x42,0x4d,0x42,0x58,0x02,0x00,0x00,0x00,0x00,0x00, 
  21.         0x42,0x00,0x00,0x00,0x28,0x00,0x00,0x00,0xf0,0x00, 
  22.         0x00,0x00,0x40,0x01,0x00,0x00,0x01,0x00,0x10,0x00, 
  23.         0x03,0x00,0x00,0x00,0x00,0x58,0x02,0x00,0x00,0x00, 
  24.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 
  25.         0x00,0x00,0x00,0x00,0x00,0xf8,0x00,0x00,0xe0,0x07, 
  26.         0x00,0x00,0x1f,0x00,0x00,0x00 
  27. }; 
  28. static char *vf_buff;       //从摄像头读取数据保存的内存指针 
  29. static int fb_bpp;              //帧缓冲设备的每像素位数 
  30. unsigned char bmp_head[54];         //54字节的BMP位图头 
  31.  
  32. static int cam_fp = -1;         //打开的摄像头句柄 
  33. static int fb_fp = -1;          //打开的帧缓冲句柄 
  34. static char *fb_addr = NULL;        //帧缓冲mmap的映射返回地址 
  35. static char *cam_name = "/dev/video1";  //摄像头设备路径和名字 
  36. int width=0;                //帧缓冲的resolution width 
  37. int height=0;               //帧缓冲的resolution height  
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <ctype.h>
#include <errno.h>
#include <sys/mman.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <asm/types.h> 
#include <linux/videodev2.h>
#include <linux/fb.h>

static unsigned int capframe = 0;		//保存的图片计数
static char filename[30];		//保存的图片文件名
FILE *bmpFile;					//保存图片时创建的文件指针

unsigned char bmp_head_t[] = {			//66字节的BMP位图头
         0x42,0x4d,0x42,0x58,0x02,0x00,0x00,0x00,0x00,0x00,
        0x42,0x00,0x00,0x00,0x28,0x00,0x00,0x00,0xf0,0x00,
        0x00,0x00,0x40,0x01,0x00,0x00,0x01,0x00,0x10,0x00,
        0x03,0x00,0x00,0x00,0x00,0x58,0x02,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0xf8,0x00,0x00,0xe0,0x07,
        0x00,0x00,0x1f,0x00,0x00,0x00
};
static char *vf_buff;		//从摄像头读取数据保存的内存指针
static int fb_bpp;				//帧缓冲设备的每像素位数
unsigned char bmp_head[54];			//54字节的BMP位图头

static int cam_fp = -1;			//打开的摄像头句柄
static int fb_fp = -1;			//打开的帧缓冲句柄
static char *fb_addr = NULL;		//帧缓冲mmap的映射返回地址
static char *cam_name = "/dev/video1";	//摄像头设备路径和名字
int width=0;				//帧缓冲的resolution width
int height=0;				//帧缓冲的resolution height

          主函数如下：

[cpp] view plain copy print ?
  1. int main(int argc, char *argv[]) 
  2. { 
  3.     struct timeval tv1;     //监控键盘输入的select时间参数 
  4.     unsigned long size;     //一帧画面的字节数 
  5.     int index=0;            //V4L2 input索引号 
  6.     struct v4l2_capability cap;     //V4L2设备功能结构体变量 
  7.     struct v4l2_input i;        //V4L2设备输入信息 
  8.     struct v4l2_framebuffer fb;     //V4L2的一帧设备缓存 
  9.     int on=1;               //控制V4L2设备overlay的参数 
  10.     int tmp; 
  11.     fd_set fds1;            //监控键盘输入的select fd_set变量 
  12.     int fd;             //监控键盘输入的select句柄 
  13.     char cmd[256];          //存储从键盘读入的字符串 
  14.      
  15.     cam_fp = cam_init();        //获得摄像头句柄 
  16.     fb_fp = fb_init();          //获得帧缓冲句柄 
  17.      
  18.     size=width*height*fb_bpp/8; 
  19.  
  20.     if((tmp=ioctl(cam_fp, VIDIOC_QUERYCAP, &cap))<0) {       //查询驱动功能 
  21.         printf("VIDIOC_QUERYCAP error, ret=0x%x\n",tmp); 
  22.         goto err; 
  23.     } 
  24.     printf("Driver:%s, Card:%s, cap=0x%x\n",cap.driver,cap.card,cap.capabilities); 
  25.      
  26.     memset(&i, 0, sizeof(i)); 
  27.     i.index=index; 
  28.     if(ioctl(cam_fp, VIDIOC_ENUMINPUT, &i)<0)        //枚举输入源 
  29.         goto err; 
  30.     printf("input name:%s\n",i.name);    
  31.      
  32.     index=0; 
  33.     if(ioctl(cam_fp, VIDIOC_S_INPUT, &index)<0)      //设置输入源 
  34.         goto err; 
  35.  
  36.     if(ioctl(cam_fp, VIDIOC_S_OUTPUT, &index)<0)     //设置输出源 
  37.             goto err; 
  38.  
  39.     if(ioctl(cam_fp, VIDIOC_G_FBUF, &fb)<0)      //获取V4L2设备FB属性参数 
  40.         goto err; 
  41.     printf("g_fbuf:capabilities=0x%x,flags=0x%x,width=%d,height=%d\npixelformat=0x%x,bytesperline=%d,colorspace=%d,base=0x%x\n", 
  42.         fb.capability,fb.flags,fb.fmt.width,fb.fmt.height,fb.fmt.pixelformat, 
  43.         fb.fmt.bytesperline,fb.fmt.colorspace,fb.base); 
  44.     fb.capability = cap.capabilities;           //V4L2设备功能赋值给V4L2的FB功能属性 
  45.     fb.fmt.width =width;                //LCD的FB宽度赋值给V4L2的FB宽度 
  46.     fb.fmt.height = height;             //LCD的FB高度赋值给V4L2的FB高度 
  47.     fb.fmt.pixelformat = (fb_bpp==32)?V4L2_PIX_FMT_BGR32:V4L2_PIX_FMT_RGB565;       //赋值V4L2的FB像素位数 
  48.  
  49.     if(ioctl(cam_fp, VIDIOC_S_FBUF, &fb)<0)      //设置新的FB属性给摄像头 
  50.         goto err; 
  51.     on = 1; 
  52.     if(ioctl(cam_fp, VIDIOC_OVERLAY, &on)<0)     //使能摄像头的overlay 
  53.         goto err; 
  54.      
  55.     vf_buff = (char*)malloc(size); 
  56.     if(vf_buff==NULL) 
  57.         goto err; 
  58.  
  59.     if(fb_bpp==16){         //16位BMP 
  60.         *((unsigned int*)(bmp_head_t+18)) = width; 
  61.         *((unsigned int*)(bmp_head_t+22)) = height; 
  62.         *((unsigned short*)(bmp_head_t+28)) = 16; 
  63.     }else{ 
  64.     bmp_head[0] = 'B'; 
  65.     bmp_head[1] = 'M'; 
  66.     *((unsigned int*)(bmp_head+2)) = (width*fb_bpp/8)*height+54;        //整个位图大小 
  67.     *((unsigned int*)(bmp_head+10)) = 54;               //从54字节开始存图像 
  68.     *((unsigned int*)(bmp_head+14)) = 40;               //图像描述信息块的大小 
  69.     *((unsigned int*)(bmp_head+18)) = width; 
  70.     *((unsigned int*)(bmp_head+22)) = height; 
  71.     *((unsigned short*)(bmp_head+26)) = 1;              //图像的plane总数 
  72.     *((unsigned short*)(bmp_head+28)) = fb_bpp; 
  73.     *((unsigned short*)(bmp_head+34)) = (width*fb_bpp/8)*height;        //图像数据区大小 
  74.     } 
  75.      
  76.     while(1) 
  77.     { 
  78.         if (!read_data(cam_fp, vf_buff, width, height, fb_bpp))     //读摄像头数据到vf_buff 
  79.         { 
  80.         printf("read error\n"); 
  81.         } 
  82.         memcpy(fb_addr,vf_buff,width*height*fb_bpp/8);      //将读到的图像数据从内存拷贝到帧缓冲地址 
  83.         fd=0;                           //键盘句柄 
  84.         tv1.tv_sec=0; 
  85.         tv1.tv_usec=0;                      //无限等待 
  86.         FD_ZERO(&fds1); 
  87.         FD_SET(fd,&fds1);                   //绑定句柄跟监控对象 
  88.         select(fd+1,&fds1,NULL,NULL,&tv1);          //监控键盘输入 
  89.         if(FD_ISSET(fd,&fds1))                  //如果键盘有输入 
  90.         { 
  91.         memset(cmd,0,sizeof(cmd)); 
  92.         read(fd,cmd,256);                   //读取键盘输入的字符 
  93.         if(strncmp(cmd,"quit",4)==0){           //如果键盘输入quit 
  94.             printf("-->quit\n"); 
  95.             on=0; 
  96.             if(ioctl(cam_fp, VIDIOC_OVERLAY, &on)<0)     //关掉V4L2设备的overlay 
  97.             goto err; 
  98.             close(fb_fp); 
  99.             close(cam_fp);                  //释放FB跟摄像头的句柄 
  100.             return 0; 
  101.         }else if(strncmp(cmd,"capt",4)==0){         //如果键盘输入capt 
  102.             printf("-->capture\n"); 
  103.             printf("write to img --> "); 
  104.             writeImageToFile(size);             //把FB数据保存到位图中 
  105.             printf("OK\n"); 
  106.         } 
  107.         } 
  108.     } 
  109.  
  110. err: 
  111.     if (cam_fp) 
  112.         close(cam_fp); 
  113.     if (fb_fp) 
  114.         close(fb_fp); 
  115.     return 1; 
  116. }  
int main(int argc, char *argv[])
{
	struct timeval tv1;		//监控键盘输入的select时间参数
	unsigned long size;		//一帧画面的字节数
	int index=0;			//V4L2 input索引号
	struct v4l2_capability cap;		//V4L2设备功能结构体变量
	struct v4l2_input i;		//V4L2设备输入信息
	struct v4l2_framebuffer fb;		//V4L2的一帧设备缓存
	int on=1;				//控制V4L2设备overlay的参数
	int tmp;
	fd_set fds1;			//监控键盘输入的select fd_set变量
	int fd;				//监控键盘输入的select句柄
	char cmd[256];			//存储从键盘读入的字符串
	
	cam_fp = cam_init();		//获得摄像头句柄
	fb_fp = fb_init();			//获得帧缓冲句柄
	
	size=width*height*fb_bpp/8;

	if((tmp=ioctl(cam_fp, VIDIOC_QUERYCAP, &cap))<0) {		//查询驱动功能
		printf("VIDIOC_QUERYCAP error, ret=0x%x\n",tmp);
		goto err;
	}
	printf("Driver:%s, Card:%s, cap=0x%x\n",cap.driver,cap.card,cap.capabilities);
	
	memset(&i, 0, sizeof(i));
	i.index=index;
	if(ioctl(cam_fp, VIDIOC_ENUMINPUT, &i)<0)		//枚举输入源
		goto err;
	printf("input name:%s\n",i.name);	
	
	index=0;
	if(ioctl(cam_fp, VIDIOC_S_INPUT, &index)<0)		//设置输入源
		goto err;

	if(ioctl(cam_fp, VIDIOC_S_OUTPUT, &index)<0)		//设置输出源
	        goto err;

	if(ioctl(cam_fp, VIDIOC_G_FBUF, &fb)<0)		//获取V4L2设备FB属性参数
		goto err;
	printf("g_fbuf:capabilities=0x%x,flags=0x%x,width=%d,height=%d\npixelformat=0x%x,bytesperline=%d,colorspace=%d,base=0x%x\n",
		fb.capability,fb.flags,fb.fmt.width,fb.fmt.height,fb.fmt.pixelformat,
		fb.fmt.bytesperline,fb.fmt.colorspace,fb.base);
	fb.capability = cap.capabilities;			//V4L2设备功能赋值给V4L2的FB功能属性
	fb.fmt.width =width;				//LCD的FB宽度赋值给V4L2的FB宽度
	fb.fmt.height = height;				//LCD的FB高度赋值给V4L2的FB高度
	fb.fmt.pixelformat = (fb_bpp==32)?V4L2_PIX_FMT_BGR32:V4L2_PIX_FMT_RGB565;		//赋值V4L2的FB像素位数

	if(ioctl(cam_fp, VIDIOC_S_FBUF, &fb)<0)		//设置新的FB属性给摄像头
		goto err;
	on = 1;
	if(ioctl(cam_fp, VIDIOC_OVERLAY, &on)<0)		//使能摄像头的overlay
		goto err;
	
	vf_buff = (char*)malloc(size);
	if(vf_buff==NULL)
		goto err;

	if(fb_bpp==16){			//16位BMP
	    *((unsigned int*)(bmp_head_t+18)) = width;
	    *((unsigned int*)(bmp_head_t+22)) = height;
	    *((unsigned short*)(bmp_head_t+28)) = 16;
	}else{
	bmp_head[0] = 'B';
	bmp_head[1] = 'M';
	*((unsigned int*)(bmp_head+2)) = (width*fb_bpp/8)*height+54;		//整个位图大小
	*((unsigned int*)(bmp_head+10)) = 54;				//从54字节开始存图像
	*((unsigned int*)(bmp_head+14)) = 40;				//图像描述信息块的大小
	*((unsigned int*)(bmp_head+18)) = width;
	*((unsigned int*)(bmp_head+22)) = height;
	*((unsigned short*)(bmp_head+26)) = 1;				//图像的plane总数
	*((unsigned short*)(bmp_head+28)) = fb_bpp;
	*((unsigned short*)(bmp_head+34)) = (width*fb_bpp/8)*height;		//图像数据区大小
	}
	
	while(1)
	{
	    if (!read_data(cam_fp, vf_buff, width, height, fb_bpp))		//读摄像头数据到vf_buff
	    {
		printf("read error\n");
	    }
	    memcpy(fb_addr,vf_buff,width*height*fb_bpp/8);		//将读到的图像数据从内存拷贝到帧缓冲地址
	    fd=0;							//键盘句柄
	    tv1.tv_sec=0;
	    tv1.tv_usec=0;						//无限等待
	    FD_ZERO(&fds1);
	    FD_SET(fd,&fds1);					//绑定句柄跟监控对象
	    select(fd+1,&fds1,NULL,NULL,&tv1);			//监控键盘输入
	    if(FD_ISSET(fd,&fds1))					//如果键盘有输入
	    {
		memset(cmd,0,sizeof(cmd));
		read(fd,cmd,256);					//读取键盘输入的字符
		if(strncmp(cmd,"quit",4)==0){			//如果键盘输入quit
		    printf("-->quit\n");
		    on=0;
		    if(ioctl(cam_fp, VIDIOC_OVERLAY, &on)<0)		//关掉V4L2设备的overlay
			goto err;
		    close(fb_fp);
		    close(cam_fp);					//释放FB跟摄像头的句柄
		    return 0;
		}else if(strncmp(cmd,"capt",4)==0){			//如果键盘输入capt
		    printf("-->capture\n");
		    printf("write to img --> ");
		    writeImageToFile(size);				//把FB数据保存到位图中
		    printf("OK\n");
		}
	    }
	}

err:
	if (cam_fp)
		close(cam_fp);
	if (fb_fp)
		close(fb_fp);
	return 1;
}

（2）子函数叙述如下。FB和摄像头的初始化如下：

[cpp] view plain copy print ?
  1. static inline int fb_init(void) 
  2. { 
  3.     int dev_fp = -1; 
  4.     int fb_size; 
  5.     struct fb_var_screeninfo vinfo; 
  6.  
  7.     dev_fp = open("/dev/graphics/fb0", O_RDWR); 
  8.     if (dev_fp < 0) { 
  9.         perror("/dev/fb0"); 
  10.         return -1; 
  11.     } 
  12.     if (ioctl(dev_fp, FBIOGET_VSCREENINFO, &vinfo)) {   //获取FB基本信息 
  13.             printf("Error reading variable information.\n"); 
  14.         exit(1); 
  15.     } 
  16.     width=vinfo.xres; 
  17.     height=vinfo.yres; 
  18.     fb_bpp=vinfo.bits_per_pixel;    //将FB值赋值给全局变量 
  19.     if(fb_bpp==24) fb_bpp=32; 
  20.     fb_size=width*height*fb_bpp/8;  //一帧FB的字节大小 
  21.     if ((fb_addr = (char*)mmap(0, fb_size,   
  22.             PROT_READ | PROT_WRITE, MAP_SHARED, dev_fp, 0)) < 0) {   //从文件的0位置开始在内存中自动映射fb_size大小空间 
  23.         perror("mmap()"); 
  24.         return -1; 
  25.     } 
  26.     printf("%dx%d bpp:%d mmaped 0x%08x\n",width,height,fb_bpp,fb_addr); 
  27.  
  28.     return dev_fp; 
  29. } 
  30. static inline int cam_init(void) 
  31. { 
  32.     int dev_fp = -1; 
  33.  
  34.     dev_fp = open(cam_name, O_RDWR); 
  35.     if (dev_fp < 0) { 
  36.         printf("error open %s\n",cam_name); 
  37.         return -1; 
  38.     } 
  39.  
  40.     return dev_fp; 
  41. }  
static inline int fb_init(void)
{
	int dev_fp = -1;
	int fb_size;
	struct fb_var_screeninfo vinfo;

	dev_fp = open("/dev/graphics/fb0", O_RDWR);
	if (dev_fp < 0) {
		perror("/dev/fb0");
		return -1;
	}
	if (ioctl(dev_fp, FBIOGET_VSCREENINFO, &vinfo)) {	//获取FB基本信息
	        printf("Error reading variable information.\n");
		exit(1);
	}
	width=vinfo.xres;
	height=vinfo.yres;
	fb_bpp=vinfo.bits_per_pixel;	//将FB值赋值给全局变量
	if(fb_bpp==24) fb_bpp=32;
	fb_size=width*height*fb_bpp/8;	//一帧FB的字节大小
	if ((fb_addr = (char*)mmap(0, fb_size, 	
			PROT_READ | PROT_WRITE, MAP_SHARED, dev_fp, 0)) < 0) {	//从文件的0位置开始在内存中自动映射fb_size大小空间
		perror("mmap()");
		return -1;
	}
	printf("%dx%d bpp:%d mmaped 0x%08x\n",width,height,fb_bpp,fb_addr);

	return dev_fp;
}
static inline int cam_init(void)
{
	int dev_fp = -1;

	dev_fp = open(cam_name, O_RDWR);
	if (dev_fp < 0) {
		printf("error open %s\n",cam_name);
		return -1;
	}

	return dev_fp;
}

       从摄像头读数据到内存中：

[cpp] view plain copy print ?
  1. static inline int read_data(int fp, char *buf, int width, int height, int bpp) 
  2. { 
  3.     int ret=0; 
  4.     if ((ret = read(fp, buf, (width*height*bpp/8))) != (width*height*bpp/8)) { 
  5.         printf("read %d--0x%x\n",ret,ret); 
  6.         return 0; 
  7.     } 
  8.     return ret; 
  9. }  
static inline int read_data(int fp, char *buf, int width, int height, int bpp)
{
	int ret=0;
	if ((ret = read(fp, buf, (width*height*bpp/8))) != (width*height*bpp/8)) {
	    printf("read %d--0x%x\n",ret,ret);
		return 0;
	}
	return ret;
}

        把内存中图像存储成BMP

[cpp] view plain copy print ?
  1. void writeImageToFile(unsigned int size) 
  2. { 
  3.     capframe++;       //图像序号计数 
  4.     sprintf(filename,"/tmp/0%d.bmp",capframe);   //位图的文件名 
  5.     bmpFile=fopen(filename, "w+");      //可写可追加内容的方式创建文件 
  6.     if(fb_bpp == 16) 
  7.         fwrite(bmp_head_t,1,66,bmpFile); 
  8.     else 
  9.         fwrite(bmp_head,1,54,bmpFile);      //往文件中写入BMP位图头 
  10.     fwrite(vf_buff,1,size,bmpFile);         //在继续往文件中追加位图数据 
  11.     fclose(bmpFile); 
  12. }  
void writeImageToFile(unsigned int size)
{
	capframe++;       //图像序号计数
	sprintf(filename,"/tmp/0%d.bmp",capframe);   //位图的文件名
   	bmpFile=fopen(filename, "w+");		//可写可追加内容的方式创建文件
	if(fb_bpp == 16)
		fwrite(bmp_head_t,1,66,bmpFile);
	else
		fwrite(bmp_head,1,54,bmpFile);		//往文件中写入BMP位图头
   	fwrite(vf_buff,1,size,bmpFile);			//在继续往文件中追加位图数据
   	fclose(bmpFile);
}

（3）使用的makefile如下：

[cpp] view plain copy print ?
  1. CROSS_COMPILE  = /home/zhangcheng/gcc/arm-2008q3/bin/arm-linux- 
  2. CC    = $(CROSS_COMPILE)gcc 
  3.  
  4. cam2fb: cam2fb.c 
  5.     $(CC)  -o cam2fb cam2fb.c -static  
CROSS_COMPILE  = /home/zhangcheng/gcc/arm-2008q3/bin/arm-linux-
CC    = $(CROSS_COMPILE)gcc

cam2fb: cam2fb.c
	$(CC)  -o cam2fb cam2fb.c -static

执行make编译后，看到属性是不可执行属性，所以先将其属性改成可执行。通过adb将这个可执行文件拷贝入/data内，先修改其属性后，再用./执行即可。过一会儿，即可在LCD上显示camera捕获的动态图像，同时adb显示如下：

（4）该程序还可以实现输入键盘字符quit退出，输入键盘字符capt保存当前图片到某个目前下成一个BMP，由于没有键盘输入，该部分无法验证。
嵌入式Linux下LCD应用编程: 读取摄像头画面完成本地视频监控画面显示
走向CTO的路上...
06-07 757
在嵌入式Linux系统中实现本地视频监控功能,需要从摄像头读取画面数据,并将其显示在LCD上。在嵌入式Linux系统中实现本地视频监控功能,需要从摄像头读取视频流数据、解码视频帧,并将解码后的视频帧绘制到LCD上。通过调用LCD驱动程序提供的接口,将解码后的视频帧绘制到LCD上,从而实现本地视频监控的显示功能。总之,通过持续优化和扩展,可以将嵌入式Linux系统中的本地视频监控功能发展为智能、高效、多功能的解决方案,满足不同行业和场景的需求。调用LCD驱动程序的绘图函数,将当前视频帧绘制到LCD上。
RK3568笔记六十二：使用V4L2读取摄像头并在LCD上显示
09-23 697
若该文为原创文章，转载请注明原文出处。测试在LCD显示的目的是想移植韦老师的基于LVGL的相机程序。LVGL前面有移植测试过是正常的，但使用V4L2读取MIPI摄像头并在LCD上显示没测试过。这里记录下测试的情况。
Linux摄像头驱动3——LCD显示
hceng_linux
05-06 1991
优快云仅用于增加百度收录权重，排版未优化，日常不维护。请访问：www.hceng.cn 查看、评论。 本博文对应地址: https://hceng.cn/2018/05/18/Linux摄像头驱动3——LCD显示/#more Linux摄像头驱动学习第三篇，在Tiny4412的LCD上显示摄像头采集图像。 前面的UVC驱动，实现了在Ubuntu主机上显示摄像头采集的图像，但那不是最终目的，最终...
LCD framebuffer
zhenwenxian的专栏
09-30 2093
一、FrameBuffer的原理    FrameBuffer 是出现在 2.2.xx 内核当中的一种驱动程序接口。    Linux是工作在保护模式下，所以用户态进程是无法象DOS那样使用显卡BIOS里提供的中断调用来实现直接写屏，Linux抽象出 FrameBuffer这个设备来供用户态进程实现直接写屏。Framebuffer机制模仿显卡的功能，将显卡硬件结构抽象掉，可以通过 Frameb
framebuffer框架与示例
最新发布
zxhssl的博客
05-06 975
是计算机图形系统中用于存储图像数据的一块内存区域，这些区域直接对应屏幕上的每个像素。当图形系统需要更新屏幕显示时，会从帧缓冲中读取数据并传输到显示设备。
Frame Buffer
guyun_shine的专栏
11-18 2281
<br /><br />Linux的帧缓冲（Frame Buffer）之一：原理及控制参数<br />大家都知道Unix/Linux系统是由命令驱动的。X－Window－System是Unix/Linux上的图形系统，它是通过X－Server来控制硬件的。但有一些Linux的发行版在引导的时候就会在屏幕上出现图形，这时的图形是不可能由X来完成的，那是什么机制呢？答案是FrameBuffer。<br />      帧缓冲（framebuffer）是 Linux 为显示设备提供的一个接口，把显存抽象后的一种设
关于FrameBuffer
afreez's home
05-30 6261
一、FrameBuffer的原理FrameBuffer 是出现在 2.2.xx 内核当中的一种驱动程序接口。Linux是工作在保护模式下，所以用户态进程是无法象DOS那样使用显卡BIOS里提供的中断调用来实现直接写屏，Linux抽象出FrameBuffer这个设备来供用户态进程实现直接写屏。Framebuffer机制模仿显卡的功能，将显卡硬件结构抽象掉，可以通过Framebuffer的读写
Linux中LCD设备驱动framebuffer(帧缓冲)
weixin_36339155的博客
04-04 2315
https://www.linuxidc.com/Linux/2012-05/61024.htm1、framebuffer 帧缓冲    帧缓冲（framebuffer）是Linux 系统为显示设备提供的一个接口，它将显示缓冲区抽象，屏蔽图像硬件的底层差异，允许上层应用程序在图形模式下直接对显示缓冲区进行读写操作。用户不必关心物理显示缓冲区的具体位置及存放方式，这些都由帧缓冲设备驱动本身来完成。 ...
韦东山第3期嵌入式Linux项目-视频监控-3-在LCD上显示摄像头图像
Iron_man的博客
07-10 3874
韦东山第3期嵌入式Linux项目-视频监控-3-在LCD上显示摄像头图像
linux下USB摄像头采集及通过framebuffer显示
02-15
### Linux 下 USB 摄像头采集及通过 Framebuffer 显示 #### 一、概述 在 Linux 系统中，实现 USB 摄像头的数据采集与显示是一项常见且实用的功能。这一过程主要包括三个关键步骤：通过 V4L2 接口从 USB 摄像头采集...
v4l2读取usb摄像头在lcd上显示
10-02
要在LCD屏幕上显示USB摄像头的内容，你需要遵循以下几个步骤： 1. **安装依赖库**：确保已经安装了必要的库，如libv4l-dev、ffmpeg等，可以使用apt-get或yum命令进行安装。 2. **打开设备**：使用`v4l2-ctl`工具...
Linux系统下用Frame Buffer来做摄像头编程
欲穷千里目，更上一层楼
08-05 2247
在Linux下开发摄像头的程序,主要用的是video4linux来做的,界面用qt来实现,开始准备用framebuffer来直接写屏但是效果不怎么好,后来就用qt来做了,这样用起来效果还蛮好的,帧率也可以,可以上到30fps;运用v4l来编程主要掌握其api,要提高帧率最重要的是用到内存映射,其实用qt和framebuffer的时候都要用到内存映射来做,只有这样才可以达到较高的帧率
The Frame Buffer
大汉李伟的专栏
11-23 3541
  光栅器将图形primitives转化成像素流，这些像素将与Frame buffer里的目的像素结合在一起。Frame buffer这个术语起源于早期的光栅图形，它就是一块能容纳一张图片的存储空间。随着计算机图形的发展，这个术语不仅包含图像数据，而且也包含一些图形渲染所需要的辅助信息。在Direct3D中，Frame Buffer 不仅包括当前所选择的render target的表面，而且也包含
FrameBuffer
farmwang的专栏
04-11 1690
FrameBuffer相关概念 FrameBuffer中文译名为帧缓冲驱动，它是出现在2.2.xx内核中的一种驱动程序接口。 Linux是工作在保护模式下，所以用户态进程是无法象DOS那样使用显卡BIOS里提供的中断调用来实现直接写屏，Linux抽象出FrameBuffer这个设备来供用户态进程实现直接写屏。FrameBuffer机制模仿显卡的功能，将显卡硬件结构抽象掉，可以通过Frame
Framebuffer
MRbrucewayne的博客
08-01 1091
framebuffer
framebuffer
2202_75449825的博客
03-27 1576
主要讲解了对于framebuffer的用法
闲聊Framebuffer
专注虚拟化的Linuxer
10-24 1476
接触过图形相关的同学应该对Framebuffer这个名词不陌生，但Framebuffer究竟是什么，用来做什么，在我接触图形相关工作以前，对我来说一直是模糊的。本文主要闲聊Framebuffer。 什么是Framebuffer？ Framebuffer，也叫帧缓冲，其内容对应于屏幕上的界面显示，可以将其简单理解为屏幕上显示内容对应的缓存，修改Framebuffer中的内容，即表示修改屏幕上的内容，所以，直接操作Framebuffer可以直接从显示器上观察到效果。 但Framebuffer并不是屏幕内容
framebuffer 帧缓冲
跬步千里，窥叶知秋
01-11 3582
1、framebuffer 帧缓冲        帧缓冲（framebuffer）是Linux 系统为显示设备提供的一个接口，它将显示缓冲区抽象，屏蔽图像硬件的底层差异，允许上层应用程序在图形模式下直接对显示缓冲区进行读写操作。用户不必关心物理显示缓冲区的具体位置及存放方式，这些都由帧缓冲设备驱动本身来完成。        framebuffer机制模仿显卡的功能，将显卡硬件结构抽象为一系列的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值