YUY2和MJPG视频编码格式区别
标签: 编码视频
现在绝大多数摄像头所采用的是免驱摄像头,一般有两种传输格式,YUY2和MJPG,
前者是无压缩图像格式的视频,系统资源占用少(因为不用解码),不需要解码器,缺点是帧率稍慢(受限于USB分配的带宽),
后者是相当于JPEG图像压缩格式,优点是帧率高(视频开启快,曝光快),缺点是影像有马赛克,并且需要解码器,会占用PC系统资源。
插入usb摄像头自动生成设备文件/dev/video0,或者接入cmos摄像头后装载驱动后自动生成/dev/video0设备文件
通过dmesg可以查看内核打印信息
视频会议摄像头通用uvc驱动,输出yuy2原始数据
在hisi3536平台中内核打印如下
usb 1-1: USB disconnect, device number 2
usb 1-1: new high-speed USB device number 3 using hiusb-ehci
uvcvideo: Found UVC 1.00 device USB3.0 FULL HD PTZ (045e:8888)
input: USB3.0 FULL HD PTZ as /devices/platform/hiusb-ehci.0/usb1/1-1/1-1:1.0/input/input1
usb 1-1: USB disconnect, device number 3
usb 1-1: new high-speed USB device number 4 using hiusb-ehci
uvcvideo: Found UVC 1.00 device USB3.0 FULL HD PTZ (045e:8888)
input: USB3.0 FULL HD PTZ as /devices/platform/hiusb-ehci.0/usb1/1-1/1-1:1.0/input/input2
测试工具:
./v4l2
现在把采集到每帧的数据(每张图片)保存到fp文件中,就是视频数据流,
有可能在nfs文件系统中操作,采集到的视频流每帧出现花屏现象,可以在开发板中的tmpfs中操作,在内存中操作就不会出现这个问题。
=====================================================================================
由于cmos摄像头模组或者usb摄像头采集的数据为yuy2格式的视频数据,所以需要安装一个yuy2的播放器播放这种格式的视频数据,
由于公司关闭了上传功能,不能上传这个软件,大家搜索软件名YUVPlayer.exe下载
/*============================================================================
FileName: v4l2.c
# Desc: this program aim to get video file from USB camera or cmos ovxx,
# used the V4L2 interface.
# Author: LiangJianhui
# Email:
# HomePage:
# Version: 0.0.1
# LastChange: 20170503
# History:
w 打开只写文件,若文件存在则文件长度清为0,即该文件内容会消失。若文件不存在则建立该文件。
w+ 打开可读写文件,若文件存在则文件长度清为零,即该文件内容会消失。若文件不存在则建立该文件。
a 以附加的方式打开只写文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾,即文件原先的内容会被保留。(EOF符保留)
a+ 以附加方式打开可读写的文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾后,即文件原先的内容会被保留。 (原来的EOF符不保留)
在进行V4L2开发中,常用的命令标志符如下(some are optional):
? VIDIOC_REQBUFS:分配内存
? VIDIOC_QUERYBUF:把VIDIOC_REQBUFS中分配的数据缓存转换成物理地址
? VIDIOC_QUERYCAP:查询驱动功能
? VIDIOC_ENUM_FMT:获取当前驱动支持的视频格式
? VIDIOC_S_FMT:设置当前驱动的频捕获格式
? VIDIOC_G_FMT:读取当前驱动的频捕获格式
? VIDIOC_TRY_FMT:验证当前驱动的显示格式
? VIDIOC_CROPCAP:查询驱动的修剪能力
? VIDIOC_S_CROP:设置视频信号的边框
? VIDIOC_G_CROP:读取视频信号的边框
? VIDIOC_QBUF:把数据从缓存中读取出来
? VIDIOC_DQBUF:把数据放回缓存队列
? VIDIOC_STREAMON:开始视频显示函数
? VIDIOC_STREAMOFF:结束视频显示函数
? VIDIOC_QUERYSTD:检查当前视频设备支持的标准,例如PAL或NTSC。
=============================================================================*/
#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>
#define FILE_VIDEO "/dev/video0"
#define JPG "./image%d.yuv"
typedef struct{
void *start;
int length;
} BUFTYPE;
BUFTYPE *usr_buf;
static unsigned int n_buffer = 0;
//set video capture ways(mmap)
int init_mmap(int fd)
{
//to request frame cache, contain requested counts
struct v4l2_requestbuffers reqbufs;
//request V4L2 driver allocation video cache
//this cache is locate in kernel and need mmap mapping
memset(&reqbufs, 0, sizeof(reqbufs));
reqbufs.count = 4;
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(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;
printf("buf.length=%d\n",buf.length);
printf("buf.m.offset=%d\n\n",buf.m.offset);
//printf("fd=%d\n\n",fd);
usr_buf[n_buffer].start =
/*
(char *)mmap(
NULL,
buf.length,
PROT_READ | PROT_WRITE,
MAP_PRIVATE,
fd,
buf.m.offset
);
*/
(char *)mmap(
NULL,
buf.length,
PROT_READ | PROT_WRITE,
MAP_SHARED,//MAP_PRIVATE,
fd,
buf.m.offset
);
printf("usr_buf[%d].start=0x%x\n",n_buffer,usr_buf[n_buffer].start);
if(MAP_FAILED == usr_buf[n_buffer].start)
{
perror("Fail to mmap");
exit(EXIT_FAILURE);
}
printf("usr_buf %d: address=0x%x, length=%d\n", n_buffer, (unsigned int)usr_buf[n_buffer].start, usr_buf[n_buffer].length);
}
return 0;
}
//initial camera device
int init_camera_device(int fd)
{
//decive fuction, such as video input
struct v4l2_capability cap;
//video standard,such as PAL,NTSC
struct v4l2_standard std;
//frame format
struct v4l2_format tv_fmt;
//check control
struct v4l2_queryctrl query;
//detail control value
struct v4l2_fmtdesc fmt;
int ret;
//get the format of video supply
memset(&fmt, 0, sizeof(fmt));
fmt.index = 0;
//supply to image capture
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
// show all format of supply
printf("Support format:\n");
while(ioctl(fd, VIDIOC_ENUM_FMT, &fmt) == 0)
{
fmt.index++;
printf("pixelformat = ''%c%c%c%c''\ndescription = ''%s''\n",fmt.pixelformat & 0xFF, (fmt.pixelformat >> 8) & 0xFF,(fmt.pixelformat >> 16) & 0xFF, (fmt.pixelformat >> 24) & 0xFF,fmt.description);
}
//check video decive driver capability
ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);
if(ret < 0){
perror("Fail to ioctl VIDEO_QUERYCAP");
exit(EXIT_FAILURE);
}
// Print capability infomations
printf("Capability Informations:\n");
printf(" driver: %s\n", cap.driver);
printf(" card: %s\n", cap.card);
printf(" bus_info: %s\n", cap.bus_info);
printf(" version: %08X\n", cap.version);
printf(" capabilities: %08X\n", cap.capabilities);
printf("----------------------------\n");
//judge wherher or not to be a video-get device
if(!(cap.capabilities & V4L2_BUF_TYPE_VIDEO_CAPTURE))
{
printf("The Current device is not a video capture device\n");
exit(-1);
}
//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);
}
//set the form of camera capture data
memset(&fmt, 0, sizeof(tv_fmt)); // very important!must clear 0
tv_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
tv_fmt.fmt.pix.width = 640; //1280; //680;
tv_fmt.fmt.pix.height = 480; //720; //480;
tv_fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; //V4L2_PIX_FMT_YUYV;
tv_fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
if (ioctl(fd, VIDIOC_S_FMT, &tv_fmt)< 0) {
printf("VIDIOC_S_FMT FAIL!\n");
exit(-1);
close(fd);
}
if(ioctl(fd, VIDIOC_G_FMT, &tv_fmt) < 0)
{
printf("VIDIOC_G_FMT FAIL!\n");
exit(-1);
close(fd);
}
// Print Stream Format
printf("Stream Format Informations:\n");
printf(" type: %d\n", tv_fmt.type);
printf(" width: %d\n", tv_fmt.fmt.pix.width);
printf(" height: %d\n", tv_fmt.fmt.pix.height);
char fmtstr[8];
memset(fmtstr, 0, 8);
memcpy(fmtstr, &tv_fmt.fmt.pix.pixelformat, 4);
printf(" pixelformat: %s\n", fmtstr);
printf(" field: %d\n", tv_fmt.fmt.pix.field);
printf(" bytesperline: %d\n", tv_fmt.fmt.pix.bytesperline);
printf(" sizeimage: %d\n", tv_fmt.fmt.pix.sizeimage);
printf(" colorspace: %d\n", tv_fmt.fmt.pix.colorspace);
printf(" priv: %d\n", tv_fmt.fmt.pix.priv);
printf(" raw_date: %s\n", tv_fmt.fmt.raw_data);
//initial video capture way(mmap)
init_mmap(fd);
return 0;
}
int open_camera_device()
{
int fd;
//open video device with block
fd = open(FILE_VIDEO, O_RDWR,0);
if(fd < 0){
perror(FILE_VIDEO);
exit(EXIT_FAILURE);
}
return fd;
}
int start_capture(int fd)
{
unsigned int i;
enum v4l2_buf_type type;
//place the kernel cache to a queue
for(i = 0; i < n_buffer; i++){
struct v4l2_buffer buf;
memset(&buf, 0, sizeof(buf));
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = i;
if(-1 == ioctl(fd, VIDIOC_QBUF, &buf)){
perror("Fail to ioctl 'VIDIOC_QBUF'");
exit(EXIT_FAILURE);
}
}
//start capture data
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if(-1 == ioctl(fd, VIDIOC_STREAMON, &type)){
printf("i=%d.\n", i);
perror("VIDIOC_STREAMON");
close(fd);
exit(EXIT_FAILURE);
}
return 0;
}
#if 0
int process_image(void *addr, int length)
{
FILE *fp;
static int num = 0;
char image_name[20];
sprintf(image_name, JPG, num++);
if((fp = fopen(image_name, "w")) == NULL){
perror("Fail to fopen");
exit(EXIT_FAILURE);
}
fwrite(addr, length, 1, fp);
usleep(500);
fclose(fp);
return 0;
}
#else
int process_image(void *addr, int length)
{
FILE *fp;
FILE *fptest;
int tmp=0;
static int num = 0;
char image_name[20]="abc";
//sprintf(image_name, JPG, num++);
//printf("image_name=%s\n",image_name);
if((fp = fopen(image_name, "a+")) == NULL){
perror("Fail to fopen");
exit(EXIT_FAILURE);
}
//
#if 0
//debug
if((fptest = fopen("test.img", "w")) == NULL){
perror("Fail to fopen");
exit(EXIT_FAILURE);
}
if(length != fwrite(addr, 1,length, fptest))
{
printf("debugfwrite a frame image fail!\n");
}
usleep(500);
fclose(fptest);
#endif
//
tmp = fwrite(addr, 1,length, fp);
printf("tmp=0x%x\n",tmp);
if(length != tmp)
{
printf("fwrite a frame image fail!\n");
}
usleep(500);
fclose(fp);
return 0;
}
#endif
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);
printf("buf.index=%d,n_buffer=%d\n",buf.index,n_buffer);
printf(" usr_buf[%d].start=0x%x,usr_buf[%d].length=0x%x\n", buf.index,usr_buf[buf.index].start,buf.index,usr_buf[buf.index].length);
//read process space's data to a file
process_image(usr_buf[buf.index].start, usr_buf[buf.index].length);
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 = 2;
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);
}
return;
}
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);
}
return;
}
int fd;
int main()
{
fd = open_camera_device();
init_camera_device(fd);
start_capture(fd);
mainloop(fd);
stop_capture(fd);
close_camera_device(fd);
return 0;
}
#endif