• c 实用化的摄像头生成avi视频程序（加入精确的时间控制和随时停止录像功能）

    利用mmap 内存共享，用另一个进程来控制录像循环的退出。甚至添加延时停止录像等功能。

    时间控制是指：生成了n张图片帧用了多少时间m。帧率等于n/m。对应于头文件，m等于scale,  n等于rate.为了精确，采用微秒计时。

    I此程序生成的视频远好于ffmpeg，可能是此程序没有压缩数据原因吧。

    我的摄像头支持 YUYV422 和MJPG 两种格式，YUYV是不压缩的，MJPG是压缩的，查v4l2.h

    头文件得知：YUV422有4种，可任选一种，看到视频采样宽度为16 字节。也就是说每个像素点用16个字节的数据表示图像的亮度，色彩。mjpg  没有说用多少个字节表示一个像素点。我用16 ，24试过都可以用。如果实际观看时帧率不对，则大方向是此值没置错误。

    #define V4L2_PIX_FMT_YUYV    v4l2_fourcc('Y', 'U', 'Y', 'V') /* 16  YUV 4:2:2     */
    #define V4L2_PIX_FMT_YYUV    v4l2_fourcc('Y', 'Y', 'U', 'V') /* 16  YUV 4:2:2     */
    #define V4L2_PIX_FMT_YVYU    v4l2_fourcc('Y', 'V', 'Y', 'U') /* 16 YVU 4:2:2 */
    #define V4L2_PIX_FMT_UYVY    v4l2_fourcc('U', 'Y', 'V', 'Y') /* 16  YUV 4:2:2     */
    #define V4L2_PIX_FMT_VYUY    v4l2_fourcc('V', 'Y', 'U', 'Y') /* 16  YUV 4:2:2     */

    /* compressed formats （压缩格式） */
    #define V4L2_PIX_FMT_MJPEG    v4l2_fourcc('M', 'J', 'P', 'G') /* Motion-JPEG   */

    MJPG 格式为压缩格式

    这两种支持格式可任选一种，摄像头与avi文件的视频格式必须一致

    也就是程序中  vfmt.fmt.pix.pixelformat    与 strh .codec       strf.compression ,这三者要一致。   

     

    avi 头文件

    1.  
    2. #ifndef AVI_H
    3. #define AVI_H
    4. #include <stdio.h>
    5.  
    6.  
    7. //FILE * avi_ks(void);
    8. //int avi_add(FILE*fp,char *data,int size);
    9. //int avi_end(FILE *f_file);
    10.  
    11. struct avi{
    12. 	struct riff{
    13. 		unsigned char id[4];
    14. 		unsigned int size;
    15. 		unsigned char type[4];
    16. 	}ri1;
    17. 	
    18. 	
    19. 	struct hdrl{
    20. 		unsigned char id[4];    //块ID，固定为LIST
    21. 		unsigned int size;      //块大小，等于struct avi_hdrl_list去掉id和size的大小
    22. 		unsigned char type[4];  //块类型，固定为hdrl
    23. 		
    24. 		struct avih{
    25. 			unsigned char id[4];            //块ID，固定为avih
    26. 			unsigned int size;              //块大小，等于struct avi_avih_chunk去掉id和size的大小
    27. 			unsigned int us_per_frame;      //视频帧间隔时间(以微秒为单位)
    28. 			unsigned int max_bytes_per_sec; //AVI文件的最大数据率
    29. 			unsigned int padding;           //设为0即可
    30. 			unsigned int flags;             //AVI文件全局属性，如是否含有索引块、音视频数据是否交叉存储等
    31. 			unsigned int total_frames;      //总帧数
    32. 			unsigned int init_frames;       //为交互格式指定初始帧数(非交互格式应该指定为0)
    33. 			unsigned int streams;           //文件包含的流的个数，仅有视频流时为1
    34. 			unsigned int suggest_buff_size; //指定读取本文件建议使用的缓冲区大小，通常为存储一桢图像                                            //以及同步声音所需的数据之和，不指定时设为0
    35. 			unsigned int width;             //视频主窗口宽度（单位：像素）
    36. 			unsigned int height;            //视频主窗口高度（单位：像素）
    37. 			unsigned int reserved[4];       //保留段，设为0即可
    38. 		}ah1;
    39. 		
    40. 		struct   strl{
    41. 			unsigned char id[4];    //块ID，固定为LIST
    42. 			unsigned int size;      //块大小，等于struct avi_strl_list去掉id和size的大小
    43. 			unsigned char type[4];  //块类型，固定为strl
    44. 			
    45. 			struct strh{
    46. 				unsigned char id[4];            //块ID，固定为strh
    47. 				unsigned int size;              //块大小，等于struct avi_strh_chunk去掉id和size的大小
    48. 				unsigned char stream_type[4];   //流的类型，vids表示视频流，auds表示音频流
    49. 				unsigned char codec[4];         //指定处理这个流需要的解码器，如JPEG
    50. 				unsigned int flags;             //标记，如是否允许这个流输出、调色板是否变化等，一般设为0即可
    51. 				unsigned short priority;        //流的优先级，视频流设为0即可
    52. 				unsigned short language;        //音频语言代号，视频流设为0即可
    53. 				unsigned int init_frames;       //为交互格式指定初始帧数(非交互格式应该指定为0)
    54. 				unsigned int scale;             //
    55. 				unsigned int rate;              //对于视频流，rate / scale = 帧率fps
    56. 				unsigned int start;             //对于视频流，设为0即可
    57. 				unsigned int length;            //对于视频流，length即总帧数
    58. 				unsigned int suggest_buff_size; //读取这个流数据建议使用的缓冲区大小
    59. 				unsigned int quality;           //流数据的质量指标
    60. 				unsigned int sample_size;       //音频采样大小，视频流设为0即可
    61. 				struct rcFrame{                 //这个流在视频主窗口中的显示位置，设为{0,0，width,height}即可
    62. 					
    63. 					short left;
    64. 					short top;
    65. 					short right;
    66. 					short bottom;
    67. 				} AVI_RECT_FRAME;      
    68. 			}sh1;
    69. 			
    70. 			struct strf{
    71. 				unsigned char id[4];             //块ID，固定为strf
    72. 				unsigned int size;               //块大小，等于struct avi_strf_chunk去掉id和size的大小
    73. 				unsigned int size1;              //size1含义和值同size一样
    74. 				unsigned int width;              //视频主窗口宽度（单位：像素）
    75. 				unsigned int height;             //视频主窗口高度（单位：像素）
    76. 				unsigned short planes;           //始终为1
    77. 				unsigned short bitcount;         //每个像素占的位数，只能是1、4、8、16、24和32中的一个
    78. 				unsigned char compression[4];    //视频流编码格式，如JPEG、MJPG等
    79. 				unsigned int image_size;         //视频图像大小，等于width * height * bitcount / 8
    80. 				unsigned int x_pixels_per_meter; //显示设备的水平分辨率，设为0即可
    81. 				unsigned int y_pixels_per_meter; //显示设备的垂直分辨率，设为0即可
    82. 				unsigned int num_colors;         //含义不清楚，设为0即可
    83. 				unsigned int imp_colors;         //含义不清楚，设为0即可
    84. 			}sf1;
    85. 			
    86. 		}sl1;
    87. 		
    88. 	}hd1;
    89. 	
    90. 	struct movi{
    91. 		unsigned char id[4];
    92. 		unsigned int size;
    93. 		unsigned char type[4];
    94. 	}movi1;
    95. 	
    96. }HEAD;
    97.  
    98. #endif

    主程序

    1.  
    2. #include <stdio.h>
    3. #include <sys/types.h>
    4. #include <sys/stat.h>
    5. #include <fcntl.h>
    6. #include <stdlib.h>
    7. #include <unistd.h>
    8. #include <sys/ioctl.h>
    9. #include <linux/videodev2.h>
    10. #include <string.h>
    11. #include <sys/mman.h>
    12. #include "Avi.h"
    13. #include <sys/time.h>
    14.  
    15. #define wid   1920          //摄像头图像宽度
    16. #define hei  1080             //图像高度
    17. #define bitlen 16            //图像采样宽度 如不正确，会影响帧率，必须设置正确，一般是8,16,24,32 之一，可试
    18. #define perframe  50          //先预估一帧率，可设为摄像头最大帧率，实际使用时的帧率小于次值，主要用于程序设定数据缓冲区大小
    19. #define   jhframe  2000      //准备要录像的图片帧数，控制录像的时间长度
    20.  
    21. #define  HCQ  10              //v4l2 缓冲区个数
    22.  
    23. #define vcodes {'M','J','P','G'}
    24. //#define vcodes {'Y','U','Y','V'}
    25.  
    26. static int nframes = 0;         //总帧数
    27. static int totalsize = 0;       //总字节数
    28.  
    29.  
    30. FILE * avi_ks(void) {
    31. 	chdir("/home/wzpc/Videos/");
    32. 	FILE *fp = fopen("sample.avi", "w+b");
    33.  
    34. 	fseek(fp, sizeof(HEAD), SEEK_SET);
    35.  
    36. 	return fp;
    37. }
    38.  
    39. int avi_add(FILE*fp, char *data, int size) {
    40.  
    41. 	unsigned char tmp[4] = {'0', '0', 'd', 'c'};  //00dc = 压缩的视频数据00db:未压缩
    42. 	fwrite(tmp, 4, 1, fp);    //写入是否是压缩的视频数据信息
    43. 	fwrite(&size, 4, 1, fp);   //写入4字节对齐后的JPEG图像大小
    44. 	fwrite(data, size, 1, fp); //写入真正的JPEG数据
    45. 	return 0;
    46. }
    47.  
    48. //----------------------------------------------------------------------------------
    49. int avi_end(FILE *f_file) {
    50.  
    51. 	int width = wid;
    52. 	int height = hei;
    53.  
    54. 	typedef  struct hdrl AVI_HDRL_LIST;
    55. 	typedef  struct movi AVI_LIST_HEAD;
    56. 	typedef  struct avih AVI_AVIH_CHUNK;
    57. 	typedef  struct strl AVI_STRL_LIST;
    58. 	typedef  struct strh  AVI_STRH_CHUNK;
    59. 	typedef  struct strf  AVI_STRF_CHUNK;
    60. 	typedef  struct  avi   AVI_HEAD;
    61.  
    62. 	AVI_HEAD  avi_head = {
    63.  
    64. 		{
    65. 			{'R', 'I', 'F', 'F'},
    66. 			4 + sizeof(AVI_HDRL_LIST) + sizeof(AVI_LIST_HEAD) + nframes * 8 + totalsize,
    67. 			{'A', 'V', 'I', ' '}
    68. 		},
    69.  
    70. 		{
    71. 			{'L', 'I', 'S', 'T'},
    72. 			sizeof(AVI_HDRL_LIST) - 8,
    73. 			{'h', 'd', 'r', 'l'},
    74. 			{
    75. 				{'a', 'v', 'i', 'h'},
    76. 				sizeof(AVI_AVIH_CHUNK) - 8,
    77. 				1000000 / perframe, width*height*bitlen*perframe / 8, 0, 0, nframes,
    78. 				0, 1, width*height*bitlen / 8, width, height,
    79. 				{0, 0, 0, 0}
    80. 			},
    81. 			{
    82. 				{'L', 'I', 'S', 'T'},
    83. 				sizeof(AVI_STRL_LIST) - 8,
    84. 				{'s', 't', 'r', 'l'},
    85. 				{
    86. 					{'s', 't', 'r', 'h'},
    87. 					sizeof(AVI_STRH_CHUNK) - 8,
    88. 					{'v', 'i', 'd', 's'},
    89. 					vcodes,
    90. 					//	{'J','P','E','G'},
    91. 					//	{'Y', 'U', 'Y', 'V'},
    92. 					0, 0, 0, 0,
    93. 					1,         //4750
    94. 					perframe,        //20000
    95. 					0, nframes, width*height*bitlen*perframe / 8, 10000, 0,
    96. 					{0, 0, width, height}
    97. 				},
    98. 				{
    99. 					{'s', 't', 'r', 'f'},
    100. 					sizeof(AVI_STRF_CHUNK) - 8,
    101. 					sizeof(AVI_STRF_CHUNK) - 8,
    102. 					width, height, 1,
    103. 					bitlen,
    104. 					vcodes,
    105. 					//	{'J', 'P', 'E', 'G'},
    106. 					//	{'Y','U','Y','V'},
    107. 					width * height *bitlen / 8, 0, 0, 0, 0
    108. 				}
    109. 			}
    110.  
    111. 		},
    112.  
    113. 		{
    114. 			{'L', 'I', 'S', 'T'},
    115. 			4 + nframes * 8 + totalsize,
    116. 			{'m', 'o', 'v', 'i'}
    117. 		}
    118. 	};
    119.  
    120.  
    121. 	fseek(f_file, 0, SEEK_SET);
    122.  
    123. 	fwrite(&avi_head, sizeof(HEAD), 1, f_file);
    124.  
    125.  
    126. 	return 0;
    127. }
    128.  
    129.  
    130. int main(void) {
    131. 	
    132. 	int fd1=open("/home/wzpc/1.txt",O_RDWR);                     //进程mmap共享，用于控制录像的停止
    133. 	char *p=mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd1,0);
    134.  
    135. 		
    136. 	//	memcpy(p,&bz,4);	
    137. 	
    138. 	int fd = open("/dev/video0", O_RDWR);
    139. 	if (fd < 0) {
    140. 		perror("打开设备失败");
    141. 		return -1;
    142. 	}
    143. 	struct v4l2_format vfmt;
    144. 	vfmt.type = 1;
    145. 	vfmt.fmt.pix.width = wid;
    146. 	vfmt.fmt.pix.height = hei;
    147. 	vfmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
    148. 	//  vfmt.fmt.pix.pixelformat=V4L2_PIX_FMT_YUYV;    //重要  MJPG  YUYV422
    149. //	 vfmt.fmt.pix.pixelformat=v4l2_fourcc('Y','U','Y','V');
    150.  
    151. 	int ret = ioctl(fd, VIDIOC_S_FMT, &vfmt);
    152. 	if (ret < 0) {
    153. 		perror("设置格式失败");
    154. 	}
    155.  
    156. 	struct v4l2_requestbuffers reqbuffer;
    157. 	reqbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    158.  
    159. 	reqbuffer.count = HCQ;
    160. 	reqbuffer.memory = V4L2_MEMORY_MMAP ;
    161. 	ret  = ioctl(fd, VIDIOC_REQBUFS, &reqbuffer);
    162. 	if (ret < 0) {
    163. 		perror("申请队列空间失败");
    164. 	}
    165.                                   //我理解以下部分
    166. 	struct v4l2_buffer mapbuffer; //相当于在为mapbuffer 设置读写规则，还没有开始数据传输，怎样从摄像头buf传输数据保存在多少个mmap中
    167. 	mapbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    168. 	unsigned char *mptr[HCQ];
    169. 	unsigned size[HCQ];
    170.  
    171. 	for (int t = 0; t < HCQ; t++) {
    172.  
    173. 		mapbuffer.index = t;
    174. 			ret = ioctl(fd, VIDIOC_QUERYBUF, &mapbuffer);//读摄像头缓冲区数据，为映射mmap准备
    175. 		   if(ret < 0)
    176. 			{
    177. 			     perror("查询内核空间队列失败");
    178. 		 	}
    179.  
    180. 		mptr[t] = mmap(NULL, mapbuffer.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, mapbuffer.m.offset); //摄像头缓冲区映射到内存
    181. 		size[t] = mapbuffer.length;
    182.  
    183. 		ret  = ioctl(fd, VIDIOC_QBUF, &mapbuffer);    //释放一个buf缓冲区空间，摄像头可以为此buf写入数据
    184. 		if (ret < 0) {
    185. 			perror("放回失败");
    186. 		}
    187. 	}
    188. //--------------------------我的理解：以上都是设置---------------------------------------------
    189. //============================================================================================	
    190.  
    191. 	int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    192. 	ret = ioctl(fd, VIDIOC_STREAMON, &type);     //启动流，数据开始传输
    193. 	if (ret < 0) {
    194. 		perror("开启失败");
    195. 	}
    196.  
    197.  
    198. //---------------------------------------------------------------------------
    199. 	FILE *file = avi_ks();
    200. 	
    201. 	struct v4l2_buffer readbuffer;
    202. 	readbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  //安装mapbuffer设置的规矩来读，数据从mmap中提取
    203.  
    204. 	
    205. 	struct timeval start, end;
    206. 	gettimeofday(&start, NULL );         //微秒记时开始
    207.  
    208.     int bz=1;
    209. 	while ((nframes < jhframe)&&(bz))  {     //开另一进程控制录像停止
    210. 			puts("录像中.....");
    211. 		ret = ioctl(fd, VIDIOC_DQBUF, &readbuffer); //读当前队列缓冲区的数据  index循环+1,VIDIOC_DQBUF执行一次，index加1
    212. 		if (ret < 0) {
    213. 			perror("提取数据失败");
    214. 		}
    215. 		int i=readbuffer.index;
    216. 		//	printf("%d\n",mapbuffer.index);   //验证index的循环变化
    217. 		
    218. 		int len = readbuffer.length;     //每一个mapbuff等于一帧字节,每一帧的字节数都是相同的
    219. 		//  int len=wid*hei*bitlen/8;
    220.  
    221. 		unsigned char tmp[4] = {'0', '0', 'd', 'c'};  //00dc = 压缩的视频数据
    222. 		fwrite(tmp, 4, 1, file);
    223. 		fwrite(&len, 4, 1, file);
    224. 		fwrite(mptr[i],len, 1, file); //写入真正的JPEG数据
    225.  
    226. 		ret  = ioctl(fd, VIDIOC_QBUF, &readbuffer);    //把缓冲区数据放入读队列中
    227. 		if (ret < 0) {
    228. 			perror("放回失败");
    229. 		}
    230. 		nframes++;
    231. 		totalsize++;
    232. 		memcpy(&bz,p,4);
    233. 	}
    234. 	
    235. 	static float timeuse1 = 0;
    236. 	gettimeofday(&end, NULL );       //记时结束
    237. 	timeuse1 = 1000 * (1000000 * ( end.tv_sec - start.tv_sec ) + end.tv_usec - start.tv_usec);
    238. 	int timeuse = (int)(timeuse1 / 1000000); //转换为豪秒
    239.  
    240. //---------------------------------------------------------
    241. 	ret = ioctl(fd, VIDIOC_STREAMOFF, &type);
    242. 	avi_end(file);
    243.  
    244. 	int scale = timeuse;
    245.  
    246. 	int rate = nframes * 1000;     //重写实际帧率=rate/scale ,乘1000是timeuse 为毫秒，转换为秒
    247. 	printf("帧率:%d\n", rate / timeuse);
    248.  
    249. 	fseek(file, 128, SEEK_SET);    //128 为scale 在文件中的字节位数（偏移）
    250. 	fwrite(&scale, 4, 1, file);
    251. 	fwrite(&rate, 4, 1, file);     //rate 为128+4 位
    252.  
    253. 	fclose(file);
    254.  
    255. 	for (int n = 0; n < HCQ; n++) {
    256. 		munmap(mptr, size[n]);
    257. 	}
    258.     int kz1=1;                //控制位复位1
    259. 	memcpy(p,&kz1,4);
    260. 	munmap(p,4);
    261.  
    262.  
    263. 	close(fd);
    264. 	puts("end");
    265. 	return 0;
    266. }

    3.停止录像进程

    1. #include <sys/mman.h>
    2.  
    3. #include <stdio.h>
    4.  
    5. #include <string.h>
    6.  
    7. #include <fcntl.h>
    8.  
    9. #include <unistd.h>
    10.  
    11.  
    12.  
    13. int main(void){
    14.  
    15. 	int fd=open("/home/wzpc/1.txt",O_RDWR);
    16.  
    17. 	char *p=mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    18.  
    19. 	puts("start:t=0\n");
    20.  
    21. 	int t=0;	
    22.  
    23.         memcpy(p,&t,4);
    24.        
    25.  
    26.  
    27. 	return 0;
    28.  
    29. }

     

     

     

     

     

  • 相关阅读:
    使用mysql语句进行分组查询
    MMdetection训练配置
    昨天同事lastday，把前端测试包扔线上去了
    最详解决：jupyter notebook不会自动打开浏览器问题
    XXL-JOB 分布式任务调度中心搭建
    js中使用原型链增加方法后，遍历对象的key-value时会遍历出方法
    python 控制包是否可导入
    Flutter组件--AppBar相关属性
    基于主动视觉机制的深度学习--一个综合池化框架
    TPS63020DSJR(LDO)NCP51200MNTXG IC REG 稳压器参数
  • 原文地址：https://blog.csdn.net/m0_59802969/article/details/134374822