FFMPEG 网上找的程序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <assert.h>
#include <fcntl.h>
#include <malloc.h>
#include <math.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/poll.h>
#include <linux/types.h>
#include <linux/videodev2.h>
#include <libavutil/time.h>
#include <libavutil/imgutils.h>
#include <libavutil/mathematics.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavdevice/avdevice.h>

#define DEV_TYPE		"video4linux2"
#define DEV_NAME		"/dev/video1"
#define MAX_CHANNEL 	(4)
#define AV_IO_BUF_SIZE	(96*1024)
#define CLEAR(x) 		memset(&(x), 0, sizeof(x))

struct buffer {
	void   *start;
	size_t length;
};

struct usbcamera_node
{
	int channel;
	char id[32];
	int usb_port;
	//V4L2
	char devname[32];
	int fd;
	struct v4l2_format fmt;
	struct v4l2_streamparm parm;
	struct v4l2_requestbuffers req;
	struct buffer *buffers;
	int n_buffers;
	int poll_index[MAX_CHANNEL];

};

struct usbcamera_node usbcamra;
struct pollfd usbcamra_poll_fd[MAX_CHANNEL];
nfds_t usbcamra_poll_fd_num = 0;
unsigned int frame_len = 0;
unsigned int frame_cnt = 0;

int avError(int errNum);

static int xioctl(int fh, int request, void *arg)
{
	int r;
	do
	{
		r = ioctl(fh, request, arg);
	} while (-1 == r && EINTR == errno);

	return r;
}

static int video_init(struct usbcamera_node *camera_node)
{
	struct v4l2_capability cap;
	struct v4l2_fmtdesc fmtdesc;
	int ret = 0;

	// open the video device with the API of open()
	camera_node->fd = open(camera_node->devname, O_RDWR | O_NONBLOCK, 0);

	if (-1 == camera_node->fd)
	{
		fprintf(stderr, "Cannot open '%s': %d, %s\n", camera_node->devname, errno, strerror(errno));
		return -1;
	}

	// inquire video device capability with the API of ioctl
	if (-1 == xioctl(camera_node->fd, VIDIOC_QUERYCAP, &cap))
	{
		fprintf(stderr, "%s is no V4L2 device\n", camera_node->devname);
		return -1;
	}

	// Set video device settings
	if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
	{
		fprintf(stderr, "%s is no video capture device\n", camera_node->devname);
		return -1;
	}

	if (!(cap.capabilities & V4L2_CAP_STREAMING))
	{
		fprintf(stderr, "%s does not support streaming i/o\n", camera_node->devname);
		return -1;
	}

	printf("\nVIDOOC_QUERYCAP\n");
	printf("the camera driver is: %s\n", cap.driver);
	printf("the camera card is: %s\n", cap.card);
	printf("the camera bus info is: %s\n", cap.bus_info);
	printf("the version is: %d\n", cap.version);
	printf("the capabilities is: 0x%x\n", cap.capabilities);
	printf("the device_caps is: 0x%x\n", cap.device_caps);

	fmtdesc.index = 0; //form number
	fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//frame type
	while(ioctl(camera_node->fd, VIDIOC_ENUM_FMT, &fmtdesc) != -1)
	{
		printf("VIDIOC_ENUM_FMT success! fmtdesc.index:%d, fmtdesc.type:%d, fmtdesc.flags:%d, "
			   "fmtdesc.description:%s, fmtdesc.pixelformat:%d\n",
			   fmtdesc.index, fmtdesc.type, fmtdesc.flags, fmtdesc.description, fmtdesc.pixelformat);
		fmtdesc.index ++;
	}

	if (-1 == xioctl(camera_node->fd, VIDIOC_S_FMT, &camera_node->fmt))
	{
		fprintf(stderr, "%s set fmt failed\n", camera_node->devname);
		return -1;
	}

	printf("VIDIOC_S_FMT success! width:%d, height:%d, pixelformat:%x, field:%d, bytesperline:%d, "
		   "sizeimage:%d, colorspace:%d, priv:%d, flags:%x, ycbcr_enc:%d, quantization:%d, xfer_func:%d\n",
		   camera_node->fmt.fmt.pix.width, camera_node->fmt.fmt.pix.height, camera_node->fmt.fmt.pix.pixelformat,
		   camera_node->fmt.fmt.pix.field, camera_node->fmt.fmt.pix.bytesperline, camera_node->fmt.fmt.pix.sizeimage,
		   camera_node->fmt.fmt.pix.colorspace, camera_node->fmt.fmt.pix.priv, camera_node->fmt.fmt.pix.flags,
		   camera_node->fmt.fmt.pix.ycbcr_enc, camera_node->fmt.fmt.pix.quantization, camera_node->fmt.fmt.pix.xfer_func);

	struct v4l2_streamparm parm = {0};
	parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	xioctl(camera_node->fd, VIDIOC_G_PARM, &parm);
	parm.parm.capture.timeperframe.numerator = 1;
	parm.parm.capture.timeperframe.denominator = camera_node->parm.parm.capture.timeperframe.denominator;
	ret = xioctl(camera_node->fd, VIDIOC_S_PARM, &parm);
	if(ret !=0 )
	{
		printf("line:%d parm set error, errno:%d, str:%s\n", __LINE__, errno, strerror(errno));
		return -1;
	}
	printf("fd %d ret %d set Frame rate %.3f fps\n", camera_node->fd, ret,
		   1.0 * parm.parm.capture.timeperframe.denominator / parm.parm.capture.timeperframe.numerator);

	// Require the Driver of V4L2 buffers for MMAP
	if (-1 == xioctl(camera_node->fd, VIDIOC_REQBUFS, &camera_node->req))
	{
		if (EINVAL == errno)
		{
			fprintf(stderr, "%s does not support memory mapping\n", "USBCAMERA");
			return -1;
		}
		else
		{
			return -1;
		}
	}

	// Make the buffers map to the user space
	for (cam