捕捉摄像头数据显示

【核心代码】

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include <malloc.h>

#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <errno.h>
#include <asm/types.h>
#include <linux/videodev2.h>

#include "videocapture.h"
#include "yuv2rgb.h"

#define WIDTH  640
#define HEIGHT  480
#define BUFFER_NUM 1


VideoBuffer *buffers;
v4l2_std_id std;
struct v4l2_requestbuffers reqbuf;
struct v4l2_buffer buf;
enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
struct v4l2_control reg;
unsigned char rgbBuffer[WIDTH * HEIGHT * 3];
int fd;

int openDevice()
{
	fd = open("/dev/video0", O_RDWR);
	if (fd < 0) {
			printf("== open device error ==\n");
//			exit(-1);
            return -1;
	}

	memset(&std, 0, sizeof(std));
	int ret;
	do {
		ret = ioctl(fd, VIDIOC_QUERYSTD, &std);
		printf("== std %d ==\n", ret);
	} while (ret == -1 && errno == EAGAIN);
	
        printf("== std: %x ==\n", (unsigned int)std);
	switch(std) {
	case V4L2_STD_NTSC:
		printf("== std : NTSC ==\n");	
		break;
	case V4L2_STD_PAL:
		printf("== std : PAL ==\n");	
		break;
	case V4L2_STD_PAL_D:
		printf("== std : PAL_D ==\n");	
		break;
	default:
		printf("== std : other %d==\n", ret);	
		break;
	}

	struct v4l2_capability capa;
	ret = ioctl(fd, VIDIOC_QUERYCAP, &capa);
	if (ret < 0) {
		printf("== get capability failed ==\n");
	}

	if (! (capa.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
		printf("== do not support capture ==\n");
	} 

	if (! (capa.capabilities & V4L2_CAP_STREAMING)) {
		printf("== do not support streaming ==\n");
	}

	struct v4l2_format fmt;
	memset(&fmt, 0, sizeof(fmt)); 
	fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
	fmt.fmt.pix.width = WIDTH;
	fmt.fmt.pix.height = HEIGHT;
	fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
	fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
	fmt.fmt.pix.bytesperline = WIDTH  * 2 ;
	fmt.fmt.pix.sizeimage = WIDTH * HEIGHT * 2;
	ret = ioctl(fd, VIDIOC_S_FMT, &fmt);
	if (ret < 0) {
		printf("======set format failed %d========\n", errno);
	}

	reqbuf.count = BUFFER_NUM;
	reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	reqbuf.memory = V4L2_MEMORY_MMAP;

	ret = ioctl(fd, VIDIOC_REQBUFS, &reqbuf);
	if (ret == EINVAL) {
		printf("== do not support mmap==\n");
	}
	if (ret < 0) {
		printf("== reqbufs buffers failed %d ==\n", errno);
		return ret;
	}

	buffers = calloc(reqbuf.count, sizeof(*buffers));

	memset(rgbBuffer, 0, sizeof(rgbBuffer));

	int i;
	for (i = 0; i < reqbuf.count; i  ) {
		memset(&buf, 0, sizeof(buf));
		buf.index = i;
		buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		buf.memory = V4L2_MEMORY_MMAP;
		
		ret = ioctl(fd, VIDIOC_QUERYBUF, &buf);
		if (ret < 0) {
			printf("== query buffer failed ==\n");
			return ret;
		}
		
		buffers[i].length = buf.length;
		buffers[i].start = (char *) mmap(NULL, buf.length, PROT_READ | PROT_WRITE,
						MAP_SHARED, fd, buf.m.offset);
		if (buffers[i].start == MAP_FAILED) {
			printf("== mmap %d failed: %d ==\n", i, strerror(errno));
			return -1;
		}

		ret = ioctl(fd, VIDIOC_QBUF, &buf);
		if (ret < 0) {
			printf("== QBUF %d failed: %d ==\n", i, strerror(errno));
			return -1;
		}
	//	printf("== buffer %d  addr: 0x%x, length: %d== \n", i, (unsigned int)buffers[i].start, buffers[i].length);
	}
	//printf("== mmap done %d == \n", i);

	ret = ioctl(fd, VIDIOC_STREAMON, &type);
	if (ret < 0) {
		printf("== STREAMON failed == \n");
		return ret;
	}

	return fd;
}
int startCapture(unsigned char *distBuffer)
{

	int ret;
//	static int counter = 0;
//        while (1)  {
		ret = ioctl(fd, VIDIOC_DQBUF, &buf);
//		if (ret < 0) {
//			printf("== DQBUF failed == \n");
//			return ret;
//		}

//		if (counter   > 10)
//				return 0;

//                convertYUV2RGB(buffers[buf.index].start, distBuffer, WIDTH, HEIGHT);
                yuyv_bgr32(WIDTH, HEIGHT, buffers[buf.index].start, distBuffer );
	
//		printf("frame %d\n", counter);
		ret = ioctl(fd, VIDIOC_QBUF, &buf);
		if (ret < 0) {
			printf("== QBUF failed ==\n");
			return ret;
		}
//        }
                return 0;
}

int startCapture_YUV_TO_RGB(const unsigned char *srcBuffer, unsigned char *distBuffer)
{

	int ret;



                yuyv_bgr32(WIDTH, HEIGHT, srcBuffer, distBuffer );
	



                return 0;
}

int stopCapture()
{
    return 0;
}

int closeDevice()
{
	int ret, i;
	for (i = 0; i < BUFFER_NUM; i  ) {
		munmap(buffers[i].start, buffers[i].length);
	}

	ret = ioctl(fd, VIDIOC_STREAMOFF, &type);
	if (ret < 0) {
		printf("== Stream off failed ==\n");
		return ret;
	}
	return close(fd);
}

int setRegister(unsigned id, signed value)
{
    printf("-- set register --");
    int ret;
    reg.id =(unsigned) id;
    reg.value = (signed) value;
    ret = ioctl(fd, VIDIOC_S_CTRL, &reg);
    if (ret < 0) {
            printf("== set register failed %d ==\n", errno);
            return ret;
    }
    return 0;
}