修改树莓派内核bcm2835-v4l2模块，增加h264关键帧强制刷新功能

最新推荐文章于 2024-07-06 22:11:47 发布
最新推荐文章于 2024-07-06 22:11:47 发布
阅读量3.3k 收藏 11
点赞数
分类专栏： 树莓派
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aphero/article/details/104451692
版权

最近使用csi摄像头做网络视频的项目，需要用到关键帧强制刷新功能，经测试bcm2835-v4l2模块不支持V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME的调用，于是重新编译内核源码，添加相应的功能。
内核编译详见树莓派官方网站的Kernel building,网址：https://www.raspberrypi.org/documentation/linux/kernel/building.md。我的是树莓派4。
1.修改kernel-src/linux/drivers/staging/vc04_services/bcm2835-camera/controls.c
在static int bm2835_mmal_s_ctrl(struct v4l2_ctrl *ctrl)的结构体

V4L2_CID_MPEG_VIDEO_H264_I_PERIOD, MMAL_CONTROL_TYPE_STD的下面添加：
    //by aphero 2020年2月22日 添加关键帧刷新	
    	{
    		V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME, MMAL_CONTROL_TYPE_STD,
    		1, 1, 1, 1, NULL,//未使用
    		MMAL_PARAMETER_VIDEO_REQUEST_I_FRAME,
    		&ctrl_set_forcekeyframe,
    		false
    	},
    //by aphero end

2.添加调用函数：参考ctrl_set_bitrate()函数修改：

//by aphero 
static int ctrl_set_forcekeyframe(struct bm2835_mmal_dev *dev,
			    struct v4l2_ctrl *ctrl,
			    const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
{
	int ret;
	struct vchiq_mmal_port *encoder_out;
	u32 mmal_bool = 1;

	encoder_out = &dev->component[COMP_VIDEO_ENCODE]->output[0];

	ret = vchiq_mmal_port_parameter_set(dev->instance, encoder_out,
					    mmal_ctrl->mmal_id,
					    &mmal_bool, sizeof(mmal_bool));
	ret = 0;
	return ret;
}//by aphero end

3.修改bcm2835-camera.h文件

#define V4L2_CTRL_COUNT 30 /* number of v4l controls  by aphero 添加帧刷新*/

4.安装新模块–手动安装

make modules
sudo cp ./drivers/staging/vc04_services/bcm2835-camera/bcm2835-v4l2.ko /lib/modules/$(uname -r)/kernel/drivers/staging/vc04_services/bcm2835-camera/bcm2835-v4l2.ko
sudo depmod -a   #重新建立模块的依赖关系
sudo reboot

5.测试程序：通过v4l2方式从csi摄像头直接读取h264格式的视频，在采集的时候临时调用新添加的key_frame强制刷新功能：

/*=============================================================================
#     FileName: v4l2.c
#     Desc: this program aim to get image from rpi csi camera, used the V4L2 interface.
#     Author: aphero  修改于capture   详见https://linuxtv.org/downloads/v4l-dvb-apis/uapi/v4l/capture.c.html
#     LastChange: 2020-2-10 
#
# 编译：gcc ./v4l2.c -o v4l2
=============================================================================*/
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <linux/types.h>
#include <linux/videodev2.h>
#include <malloc.h>
#include <math.h>
#include <string.h>
#include <sys/mman.h>
#include <errno.h>
#include <assert.h>
#include <sys/time.h>
#include <linux/uvcvideo.h> //for c920
#include "uvch264.h" for c920

#define FILE_VIDEO  "/dev/video0"
#define WIDTH 1920;
#define HEIGHT 1080;
#define FPS  30
#define BIT_RATE 1024000*2;
#define KEYFRAME_PERIOD 200
#define LOOP 30*60*60;
 
typedef struct{
    void *start;
	int length;
	int bytesused;
}BUFTYPE;
 
BUFTYPE *usr_buf;
static unsigned int n_buffer = 0;
struct timeval first_time, second_time;
int j=0;
FILE *f;


/*set video capture ways(mmap)*/
int init_mmap(int fd)
{
	/*to request frame cache, contain requested counts*/
	struct v4l2_requestbuffers reqbufs;
 
	memset(&reqbufs, 0, sizeof(reqbufs));
	reqbufs.count = 4; 	 							/*the number of buffer*/
	reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;    
	reqbufs.memory = V4L2_MEMORY_MMAP;				
 
	if(-1 == ioctl(fd,VIDIOC_REQBUFS,&reqbufs))
	{
		perror("Fail to ioctl 'VIDIOC_REQBUFS'");
		exit(EXIT_FAILURE);
	}
	
	n_buffer = reqbufs.count;
	printf("n_buffer = %d\n", n_buffer);
	//usr_buf = calloc(reqbufs.count, sizeof(usr_buf));
	usr_buf = calloc(reqbufs.count, sizeof(BUFTYPE));
	if(usr_buf == NULL)
	{
		printf("Out of memory\n");
		exit(-1);
	}
 
	/*map kernel cache to user process*/
	for(n_buffer = 0; n_buffer < reqbufs.count; ++n_buffer)
	{
		//stand for a frame
		struct v4l2_buffer buf;
		memset(&buf, 0, sizeof(buf));
		buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		buf.memory = V4L2_MEMORY_MMAP;
		buf.index = n_buffer;
		
		/*check the information of the kernel cache requested*/
		if(-1 == ioctl(fd,VIDIOC_QUERYBUF,&buf))
		{
			perror("Fail to ioctl : VIDIOC_QUERYBUF");
			exit(EXIT_FAILURE);
		}
 
		usr_buf[n_buffer].length = buf.length;//注意：h264的时候使用buf.bytesused，420p等使用buf.length
		usr_buf[n_buffer].bytesused = buf.bytesused;//for h264
		usr_buf[n_buffer].start = (char *)mmap(NULL,buf.length,PROT_READ | PROT_WRITE,MAP_SHARED, fd,buf.m.offset);
		//由原来的MAP_PRIVATE 模式改为MAP_SHARED方式
		if(MAP_FAILED == usr_buf[n_buffer].start)
		{
			perror("Fail to mmap");
			exit(EXIT_FAILURE);
		}
 
	}

}
 
int open_camera(void)
{
	int fd;
	struct v4l2_input inp;
 
	fd = open(FILE_VIDEO, O_RDWR | O_NONBLOCK,0);//camera 打开由阻塞打开改为了非阻塞方式打开
	if(fd < 0)
	{	
		fprintf(stderr, "%s open err \n", FILE_VIDEO);
		exit(EXIT_FAILURE);
	};
 
	inp.index = 0;
	if (-1 == ioctl (fd, VIDIOC_S_INPUT, &inp))
	{
		fprintf(stderr, "VIDIOC_S_INPUT \n");
	}
 
	return fd;
}
//下面是uvc的摄像头(罗技c920)的关键帧刷新方式，不能适用于树莓派的csi摄像头
int get_key_frame(int fd,int type) {//0=I-Frame, 1=IDR, 2=IDR+SPS+PPS  
	u_int16_t len;
	struct uvc_xu_control_query ctrl;
	uvcx_picture_type_control_t conf;
	ctrl.unit = 12;//H264_ctrl_unit_id;
	ctrl.size = sizeof(len);
	ctrl.selector = UVCX_PICTURE_TYPE_CONTROL;
	ctrl.query = UVC_GET_LEN;
	ctrl.data = (unsigned char*)&len;

        if (-1 == ioctl(fd, UVCIOC_CTRL_QUERY, &ctrl)){
                printf("v4l2_codec: get key frame fail \n");
       }
       //printf("----------------------get key frame len=%d----\n",len);
	
	conf.wLayerID = 0;
	conf.wPicType = type;
	ctrl.query = UVC_SET_CUR;
	if(len == sizeof(conf)) {
		ctrl.size = sizeof(conf);
		ctrl.data = (unsigned char*)&conf;
	} else if(len == 2) {
		len = type;
	}
        if (-1 == ioctl(fd, UVCIOC_CTRL_QUERY, &ctrl)){
                printf("v4l2_codec: get key frame fail \n");
       
	}
    return 0;
}

int init_camera(int fd)
{
	struct v4l2_capability 	cap;	/* decive fuction, such as video input */
	struct v4l2_format 		tv_fmt; /* frame format */  
	struct v4l2_fmtdesc 	fmtdesc;  	/* detail control value */
	struct v4l2_control 	ctrl;
	int ret;
	
	/*show all the support format*/
	memset(&fmtdesc, 0, sizeof(fmtdesc));
	fmtdesc.index = 0 ;                 /* the number to check */
	fmtdesc.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
	/* check video decive driver capability */
	if(ret=ioctl(fd, VIDIOC_QUERYCAP, &cap)<0)
	{
		fprintf(stderr, "fail to ioctl VIDEO_QUERYCAP \n");
		exit(EXIT_FAILURE);
	}
	
	/*judge wherher or not to be a video-get device*/
	if(!(cap.capabilities & V4L2_BUF_TYPE_VIDEO_CAPTURE))
	{
		fprintf(stderr, "The Current device is not a video capture device \n");
		exit(EXIT_FAILURE);
	}
 
	/*judge whether or not to supply the form of video stream*/
	if(!(cap.capabilities & V4L2_CAP_STREAMING))
	{
		printf("The Current device does not support streaming i/o\n");
		exit(EXIT_FAILURE);
	}
	
	printf("\ncamera driver name is : %s\n",cap.driver);
	printf("camera device name is : %s\n",cap.card);
	printf("camera bus information: %s\n",cap.bus_info);
 
	/*display the format device support*/
	printf("\n");
	while(ioctl(fd,VIDIOC_ENUM_FMT,&fmtdesc)!=-1)
	{	
		printf("support device %d.%s\n",fmtdesc.index+1,fmtdesc.description);
		fmtdesc.index++;
	}
	printf("\n");
 
	/*set the form of camera capture data*/
	tv_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;      /*v4l2_buf_typea,camera must use V4L2_BUF_TYPE_VIDEO_CAPTURE*/
	tv_fmt.fmt.pix.width = WIDTH;
	tv_fmt.fmt.pix.height = HEIGHT;
	tv_fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_H264;//V4L2_PIX_FMT_H264;//V4L2_PIX_FMT_YUV420;	/*V4L2_PIX_FMT_YYUV*/YUYV
	tv_fmt.fmt.pix.field = V4L2_FIELD_NONE;   		/*V4L2_FIELD_NONE*/
	if (ioctl(fd, VIDIOC_S_FMT, &tv_fmt)< 0) 
	{
		fprintf(stderr,"VIDIOC_S_FMT set err\n");
		exit(-1);
		close(fd);
	}
	
	//----------------------fps---------------------------------
	printf("set fps\n");
 	struct v4l2_streamparm* setfps;
	setfps=(struct v4l2_streamparm *) calloc(1, sizeof(struct v4l2_streamparm));
	memset(setfps, 0, sizeof(struct v4l2_streamparm));
	setfps->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	if (-1 == ioctl(fd, VIDIOC_G_PARM, setfps)) {
			perror("v4l2-1: get fps fail\n");
	}
	printf("get-1 fps:%d/%d\n",setfps->parm.output.timeperframe.denominator,setfps->parm.output.timeperframe.numerator);
	setfps->parm.output.timeperframe.numerator = 1;
	setfps->parm.output.timeperframe.denominator =FPS;
	if (-1 == ioctl(fd, VIDIOC_S_PARM, setfps)) {
			perror("v4l2-2: set fps fail\n");
	}
 	if (-1 == ioctl(fd, VIDIOC_G_PARM, setfps)) {
			perror("v4l2-3: get fps fail\n");
	}
	printf("get-2 fps:%d/%d\n",setfps->parm.output.timeperframe.denominator,setfps->parm.output.timeperframe.numerator);
	
	
	//----------------------bitrate------hdmi输入板也可以用---------------------------
	printf("set bitrate\n");
	struct v4l2_control bitrate_ctrl;
	bitrate_ctrl.id = V4L2_CID_MPEG_VIDEO_BITRATE;
	if (-1 == ioctl(fd, VIDIOC_G_CTRL, &bitrate_ctrl)) {
			fprintf(stderr,"v4l2: get bitrate fail\n");
	}
	printf("get-1 bitrate:%d\n",bitrate_ctrl.value);
	bitrate_ctrl.value = BIT_RATE;
	if (ioctl(fd, VIDIOC_S_CTRL, &bitrate_ctrl) == -1) {
		printf("ERR(%s):v4l2_s_bitrate failed\n", __func__);
	}
	if (-1 == ioctl(fd, VIDIOC_G_CTRL, &bitrate_ctrl)) {
			fprintf(stderr,"v4l2: get bitrate fail\n");
	}
	printf("get-2 bitrate:%d\n",bitrate_ctrl.value);
	
	//----------------------I帧间隔---------hdmi输入板也可以用------------------------
	printf("set period\n");
	struct v4l2_control period_ctrl;
	period_ctrl.id = V4L2_CID_MPEG_VIDEO_H264_I_PERIOD;
	if (-1 == ioctl(fd, VIDIOC_G_CTRL, &period_ctrl)) {
			fprintf(stderr,"v4l2: get period fail\n");
	}
	printf("get-1 period:%d\n",period_ctrl.value);
	period_ctrl.value = KEYFRAME_PERIOD;
	if (ioctl(fd, VIDIOC_S_CTRL, &period_ctrl) == -1) {
		printf("ERR(%s):v4l2_s_period failed\n", __func__);
		return -1;
	}
	if (-1 == ioctl(fd, VIDIOC_G_CTRL, &period_ctrl)) {
			fprintf(stderr,"v4l2: get period fail\n");
	}
	printf("get-2 period:%d\n",period_ctrl.value);
	
	init_mmap(fd);
}
 
int start_capture(int fd)
{
	unsigned int i;
	enum v4l2_buf_type type;
	

		struct v4l2_buffer buf;
		memset(&buf, 0, sizeof(buf));
		buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		buf.memory = V4L2_MEMORY_MMAP;
		buf.index = 0;
		if(-1 == ioctl(fd, VIDIOC_QBUF, &buf))
		{
			perror("Fail to ioctl 'VIDIOC_QBUF'");
			exit(EXIT_FAILURE);
		}
	
	if(-1 == ioctl(fd, VIDIOC_STREAMON, &buf.type))
	{
		perror("VIDIOC_STREAMON");
		close(fd);
		exit(EXIT_FAILURE);
	}
 
	return 0;
}
 

int process_image(void *addr, int length,int fd)
{
	//fwrite(addr, 1, length, f);//写入文件
	char *data = (char *)malloc(length);
	memcpy(data,addr,length);
	fwrite(data, 1, length, f);
/*	
	for(int i=0;i<10;i++)		printf("[%02x] ",data[i]);	
	printf("\n");
*/	
	if((data[4]&0x7)==7) printf("sps\n");
	if((data[4]&0x7)==8) printf("pps\n");
	if((data[4]&0x7)==5) printf("IDR\n");
	
	if(j==0) gettimeofday(&first_time, NULL);//开始计时
	j++;
	if(!(j % 30)){//打印编码信息
		gettimeofday(&second_time, NULL);
		double time_val = (second_time.tv_sec - first_time.tv_sec) * 1000000 + second_time.tv_usec - first_time.tv_usec;
		printf("capture frame %3d (size=%5d) time(ms) = %lf fps=%lf\n", j, length,time_val / 1000.0, j*1000.0/(time_val/1000.0));
	}

	if(!(j % 60)){//用于模拟关键帧强制刷新
		//get_key_frame(fd,2);//强制I帧,for c920
		struct v4l2_control key_ctrl;
		key_ctrl.id = V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME;//修改了内核中bcm2835-v4l2模块，添加了相应功能
		if (-1 == ioctl(fd, VIDIOC_S_CTRL, &key_ctrl)) {
				fprintf(stderr,"v4l2: Set key_ctrl fail\n");
		}
	}
	return 0;
}
 
int read_frame(int fd)
{
	struct v4l2_buffer buf;
	unsigned int i;
	memset(&buf, 0, sizeof(buf));
	buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	buf.memory = V4L2_MEMORY_MMAP;
	//put cache from queue
	if(-1 == ioctl(fd, VIDIOC_DQBUF,&buf))
	{
		perror("Fail to ioctl 'VIDIOC_DQBUF'");
		exit(EXIT_FAILURE);
	}
	assert(buf.index < n_buffer);
	//read process space's data to a file
	//process_image(usr_buf[buf.index].start, usr_buf[buf.index].length);
	process_image(usr_buf[buf.index].start, buf.bytesused,fd);

	if(-1 == ioctl(fd, VIDIOC_QBUF,&buf))
	{
		perror("Fail to ioctl 'VIDIOC_QBUF'");
		exit(EXIT_FAILURE);
	}
	return 1;
}
 
 
int mainloop(int fd)
{
	int count = 1000;
	while(count-- > 0)
	{
		for(;;)
		{
			fd_set fds;
			struct timeval tv;
			int r;
 
			FD_ZERO(&fds);
			FD_SET(fd,&fds);
 
			/*Timeout*/
			tv.tv_sec = 1;
			tv.tv_usec = 0;
			r = select(fd + 1,&fds,NULL,NULL,&tv);
			
			if(-1 == r)
			{
				 if(EINTR == errno)
					continue;
				perror("Fail to select");
				exit(EXIT_FAILURE);
			}
			if(0 == r)
			{
				fprintf(stderr,"select Timeout\n");
				exit(-1);
			}
 
			if(read_frame(fd))
			break;
		}
	}
	return 0;
}
 
void stop_capture(int fd)
{
	enum v4l2_buf_type type;
	type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	if(-1 == ioctl(fd,VIDIOC_STREAMOFF,&type))
	{
		perror("Fail to ioctl 'VIDIOC_STREAMOFF'");
		exit(EXIT_FAILURE);
	}
}
 
void close_camera_device(int fd)
{
	unsigned int i;
	for(i = 0;i < n_buffer; i++)
	{
		if(-1 == munmap(usr_buf[i].start,usr_buf[i].length))
		{
			exit(-1);
		}
	}
 
	free(usr_buf);
 
	if(-1 == close(fd))
	{
		perror("Fail to close fd");
		exit(EXIT_FAILURE);
	}
}
 
 
void main(void)
{
	int fd;
	f= fopen("csi.264", "wb");
	fd = open_camera();
	init_camera(fd);
	start_capture(fd);
	mainloop(fd);
	stop_capture(fd);
	close_camera_device(fd);
	fclose(f);
}

运行测试：

pi@raspberrypi:~/v4l2-encode $ ./v4l2

camera driver name is : bm2835 mmal
camera device name is : mmal service 16.1
camera bus information: platform:bcm2835-v4l2

support device 1.Planar YUV 4:2:0
support device 2.YUYV 4:2:2
support device 3.24-bit RGB 8-8-8
support device 4.JFIF JPEG
support device 5.H.264
support device 6.Motion-JPEG
support device 7.YVYU 4:2:2
support device 8.VYUY 4:2:2
support device 9.UYVY 4:2:2
support device 10.Y/CbCr 4:2:0
support device 11.24-bit BGR 8-8-8
support device 12.Planar YVU 4:2:0
support device 13.Y/CrCb 4:2:0
support device 14.32-bit BGRA/X 8-8-8-8

set fps
get-1 fps:30/1
get-2 fps:30/1
set bitrate
get-1 bitrate:1000000
get-2 bitrate:2050000
set period
get-1 period:100
get-2 period:200
n_buffer = 4
sps
IDR
capture frame  30 (size=10336) time(ms) = 980.206000 fps=30.605811
capture frame  60 (size= 9957) time(ms) = 1979.443000 fps=30.311557
IDR
capture frame  90 (size= 9741) time(ms) = 2978.976000 fps=30.211724
capture frame 120 (size= 9867) time(ms) = 3978.102000 fps=30.165139
IDR
capture frame 150 (size=10135) time(ms) = 4977.559000 fps=30.135253
capture frame 180 (size= 9733) time(ms) = 5976.824000 fps=30.116329
IDR
capture frame 210 (size= 6193) time(ms) = 6975.564000 fps=30.105093
capture frame 240 (size= 5737) time(ms) = 7974.643000 fps=30.095391
IDR
capture frame 270 (size= 9753) time(ms) = 8974.832000 fps=30.084129
capture frame 300 (size= 9292) time(ms) = 9974.089000 fps=30.077935
IDR
capture frame 330 (size= 9468) time(ms) = 10973.688000 fps=30.071932
capture frame 360 (size= 9360) time(ms) = 11972.855000 fps=30.068016
IDR
capture frame 390 (size= 9690) time(ms) = 12972.313000 fps=30.064029
capture frame 420 (size= 5921) time(ms) = 13970.772000 fps=30.062762
IDR
capture frame 450 (size= 9463) time(ms) = 14971.081000 fps=30.057950
capture frame 480 (size= 9314) time(ms) = 15970.215000 fps=30.055951
IDR
capture frame 510 (size= 9385) time(ms) = 16969.614000 fps=30.053718
capture frame 540 (size= 9094) time(ms) = 17968.907000 fps=30.051911
IDR
capture frame 570 (size= 9250) time(ms) = 18967.688000 fps=30.051106
capture frame 600 (size= 5978) time(ms) = 19966.885000 fps=30.049755
IDR
capture frame 630 (size= 5893) time(ms) = 20966.259000 fps=30.048279
capture frame 660 (size= 9158) time(ms) = 21966.289000 fps=30.046040
IDR
capture frame 690 (size= 9416) time(ms) = 22965.743000 fps=30.044750
capture frame 720 (size= 6625) time(ms) = 23964.501000 fps=30.044439
IDR
capture frame 750 (size= 9188) time(ms) = 24965.954000 fps=30.040911
capture frame 780 (size= 9079) time(ms) = 25963.696000 fps=30.041948
IDR
capture frame 810 (size= 9017) time(ms) = 26962.996000 fps=30.041172
capture frame 840 (size= 5899) time(ms) = 27965.858000 fps=30.036625
IDR
capture frame 870 (size= 6049) time(ms) = 28961.101000 fps=30.040294
capture frame 900 (size= 6105) time(ms) = 29960.513000 fps=30.039539
IDR
capture frame 930 (size= 9271) time(ms) = 30960.524000 fps=30.038251
capture frame 960 (size= 8929) time(ms) = 31959.759000 fps=30.037773
IDR
capture frame 990 (size= 9255) time(ms) = 32959.217000 fps=30.037121
aphero
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
linux-v4l2-source_pianoabk_文件采集器_v4l2编码并生成h264文件_v4l2采集_v4l2h264
04-16
Linux-v4l2-source_pianoabk_文件采集器_v4l2编码并生成h264文件_v4l2采集_v4l2h264这个项目涉及到的是在Linux环境下，利用Video for Linux 2 (V4L2) API进行视频采集，并将捕获的摄像头数据编码为H.264格式的文件。...
基于V4L2 MFC 视频编解码 H264参数设置
liujia2100的专栏
04-07 6046
4412 H264 硬件编码
树莓派raspberry摄像头相关
rabbit0206的博客
10-05 1303
树莓派下的v4l2-ctl ffmpeg命令使用
V4L2框架获取CSI摄像头视频流
最新发布
qq_38343693的博客
07-06 121
【代码】V4L2框架获取CSI摄像头视频流。
V4L2下摄像头的详细参数调整
转载和创作优秀的博客
04-03 6608
(Linux下V4L2相关头文件所在路径为/内核源码目录/include/linux/videodev2.h，V4L2相关API文档可查看链接https://linuxtv.org/downloads/v4l-dvb-apis/uapi/v4l/v4l2.html) 摄像头（相机）常见参数：白平衡（自动白平衡AWB）及色温、曝光（自动曝光AE、曝光补偿EV）、亮度、对比度、饱和度、色度（色调+饱和度）、锐度（也叫清晰度）、背光补偿（也叫逆光补偿）、增益、对焦等 （注：不同摄像头开放的参数不一致，需提前确
【树莓派4B】Manjaro-ARM配置CSI摄像头
Joke
11-01 759
参考：[树莓派]aarch64系统使用CSI摄像头 1.修改配置 由于此系统没有raspi-config ，rpi-update等，所以需要自己修改/boot/config.txt来增加摄像头 start_x=1 # essential gpu_mem=128 # at least, or maybe more if you wish disable_camera_led=1 # optional, if you don't want the led to gl
linux的v4l2运行源码,v4l2的源码，适合Linux下摄像头的开发
weixin_36371924的博客
05-05 415
也可以下载附件，内容一样v4l2源码.txt/**Video for Linux Two**A generic video device interface for the LINUX operating system*using a set of device structures/vectors for low level operations.**This file replace...
v4l2编码并转化为h264文件.rar
02-25
【标题】"v4l2编码并转化为h264文件.rar" 提供了一个关于视频处理的话题，涉及了从视频捕获设备（如摄像头）通过Video4Linux2（V4L2）接口获取原始视频数据，并将其编码为高效视频编码（H.264）格式的过程。V4L2是...
camera_arm.rar_H264 camera_V4L2采集视频_arm h264_视频传输_视频采集压缩
07-14
在本项目中，"camera_arm.rar_H264 camera_V4L2采集视频_arm h264_视频传输_视频采集压缩"是一个针对ARM架构的视频处理系统的设计，主要涉及了几个关键的技术点：H264编码、V4L2（Video for Linux Two）接口的视频...
embeded--system-V4L2.rar_v4l_v4l2
09-21
总之，V4L2是嵌入式系统中处理视频设备的关键接口，它的学习和应用对于提升嵌入式设备的多媒体功能具有重要意义。通过深入研究“embeded--system-V4L2.rar_v4l_v4l2”提供的源代码，开发者可以快速掌握V4L2的核心...
使用树莓派实现的口罩检测
热门推荐
Nie_Hen的博客
05-17 3万+
基于树莓派3B+ 官方摄像头 两个指示灯 实现的口罩检测 项目演示 链接 口罩检测项目地址 使用的口罩检测 项目是AIZOO团队实现的 使用的是目标检测常用的SSD算法。 （由于疫情在家 连不上实验室的服务器我无法训练） 项目GitHub链接 AIZOO团队给出的 代码在Windows上很容易以跑通。配置的环境相对比较容易。也不需要很复杂的更改代码。 因为模型较小 我想出要在树莓派上运行，就进行了一些尝试。 但是要在树莓派上运行需要修改一些代码。 树莓派配置 参考链接有很多基础配置 对树莓派进行换源.
树莓派配置Opencv（C++）
gaoxukkk888的博客
08-20 2689
树莓派上Opencv C++的配置。
快乐树莓派视频监控系列（一）motion监控方案
sherlockcool的博客
11-29 2030
采用树莓派+Motion可以实现简单的远程视频监控；该方案的特点是操作简单，但视频会有卡顿现象，可能无法满足实时监控的要求。
树莓派--V4L2编程入门1
qq_53154054的博客
07-25 674
ioctl函数主要用于控制设备。
树莓派——CSI摄像头和USB摄像头的配置与调试
简简单单的学习笔记，致力于帮助更多前进路上的朋友~
01-30 5034
这篇文章教你如何在树莓派上配置SCI摄像头和USB摄像头。
【上海晶珩】【树莓派】播放音频和视频-2
EDATEC的博客
11-03 182
在Raspberry Pi 4 上，已删除对 MPEG2 和 VC-1 编解码器的硬件支持，因此我们建议使用 VLC 应用程序，该应用程序在软件中支持这些格式。然后，可以使用该 jobs 命令检查此后台作业的状态。默认情况下，工作将在`omxplayer`播放完成后完成，但如有需要，您可以随时使用 kill 命令停止它。如果在没有tty(用户输入)的情况下在后台运行 omxplayer 将立即关闭，因此要成功运行，您需要使用 --no-keys 选项告诉 omxplayer 不需要任何用户输入。
关于树莓派专用相机的初始化问题
longtails的博客
03-18 2265
关于树莓派专用相机的初始化问题 初始化相机board模块。加载bcm2835-v4l2模块
树莓派4B “vcgencmd get_camera“ “supported=0 detected=0“的解决办法
Michael的博客
07-13 3118
树莓派4B接摄像头模块时，输入指令vcgencmd get_camera，得到结果supported=0 detected=0，表明系统未检测到摄像头。本文通过修改系统相关文件配置使系统能检测到摄像头模块。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值