Linux下实现视频读取

　　V4L（video4linux是一些视频系统，视频软件、音频软件的基础，经常时候在需要采集图像的场合，如视频监控，webcam,可视电话，经常
使用在embedded linux中是linux嵌入式开发中经常使用的系统接口。它是linux内核提供给用户空间的编程接口，各种的视频和音频设备开
发相应的驱动程序后，就可以通过v4l提供的系统API来控制视频和音频设备，也就是说v4l分为两层，底层为音视频设备在内核中的驱动，上
层为系统提供的API，而对于我们来说需要的就是使用这些系统API。
V4L2是V4L的升级版本，为linux下视频设备程序提供了一套接口规范。包括一套数据结构和底层V4L2驱动接口。V4L2采用流水线的方式，
操作更简单直观，基本遵循打开视频设备、设置格式、处理数据、关闭设备，更多的具体操作通过ioctl函数来实现。

1、打开设备
　　int open(const char *device_name, int flags);
　　int fd = open("/dev/video0", O_RDONLY); //O_NONBLOCK --非阻塞（不推荐使用）
2、关闭设备 int close(int fd)
　　int ret = close(fd);
3、v4l2_capability 查看属性
　　int ioctl(int fd, int request, struct v4l2_capability *argp);
　　struct v4l2_capability
　　{
　　　　u8 driver[16]; // 驱动名字
　　　　u8 card[32]; // 设备名字
　　　　u8 bus_info[32]; // 设备在系统中的位置
　　　　u32 version; // 驱动版本号
　　　　u32 capabilities; // 设备支持的操作
　　　　u32 reserved[4]; // 保留字段
　　};

4、设置视频格式与制式
相关函数：
int ioctl(int fd, int request, struct v4l2_fmtdesc *argp);
int ioctl(int fd, int request, struct v4l2_format *argp);

相关结构体：
v4l2_cropcap 结构体用来设置摄像头的捕捉能力，在捕捉上视频时应先先设置
v4l2_cropcap 的 type 域，再通过 VIDIO_CROPCAP 操作命令获取设备捕捉能力的参数，保存于 v4l2_cropcap 结构体中，包括 bounds
（最大捕捉方框的左上角坐标和宽高），defrect（默认捕捉方框的左上角坐标和宽高）等。
v4l2_format 结构体用来设置摄像头的视频制式、帧格式等，在设置这个参数时应先填 好 v4l2_format 的各个域，如 type（传输流类型），
fmt.pix.width(宽)，fmt.pix.heigth(高)，fmt.pix.field(采样区域，如隔行采样)，fmt.pix.pixelformat(采样类型，如 YUV4:2:2)，
然后通过 VIDIO_S_FMT 操作命令设置视频捕捉格式。
struct v4l2_fmtdesc
{
u32 index; // 要查询的格式序号，应用程序设置
enum v4l2_buf_type type; // 帧类型，应用程序设置
u32 flags; // 是否为压缩格式
u8 description[32]; // 格式名称
u32 pixelformat; // 格式
u32 reserved[4]; // 保留
};
所有的视频格式可以能下面的方法查看
#define v4l2_fourcc(a, b, c, d) ((a) | ((b) << 8) | ((c) << 16) | ((d) << 24))
All format : VIDIOC_ENUM_FMT, v4l2_fmtdesc

struct v4l2_format
{
enum v4l2_buf_type type; // 帧类型，应用程序设置
union fmt
{
struct v4l2_pix_format pix; // 视频设备使用
struct v4l2_window win;
struct v4l2_vbi_format vbi;
struct v4l2_sliced_vbi_format sliced;
u8 raw_data[200];
};
};

struct v4l2_pix_format
{
u32 width; // 帧宽，单位像素
u32 height; // 帧高，单位像素
u32 pixelformat; // 帧格式
enum v4l2_field field;
u32 bytesperline;
u32 sizeimage;
enum v4l2_colorspace colorspace;
u32 priv;
};

5、查看视频的帧率
int ioctl(int fd, int request, struct v4l2_streamparm parm* argp);
struct v4l2_streamparm parm;
parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
其中VIDIOC_G_PARM是用取帧率的，VIDIOC_S_PARM是用来设定帧率

6、定制ioctl函数
在内核目录下找到kernel/include/linux/videodev2.h头文件，你可查看所有的io控制的命令
/*
* Experimental, third param 0--video, 1--tracking
*/
#define VIDIOC_POCCESS_NOTIFY _IOW('V', 99, int) //add by Henry.Wen 20131126

实例：

#ifndef CAMERA_V4L2CAMERA_H
#define CAMERA_V4L2CAMERA_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <getopt.h>             /* getopt_long() */
#include <fcntl.h>              /* low-level i/o */
#include <unistd.h>
#include <errno.h>
#include <malloc.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <asm/types.h>          /* for videodev2.h */
#include <linux/videodev2.h>

#define CONFIG_CAMERA_UVC_INVAL_FRAMECNT    5

namespace v4l2
{
	/**
	 * return error code
	 */
	enum _RET_ERROR_CODE
	{
		RET_ERROR_FAIL = -1,
		RET_ERROR_OK = 0,
		RET_ERROR_CAPTURE_NULL = -9999,
		RET_ERROR_CAPTURE_NAME,
		RET_ERROR_CAPTURE_CAPABILITY,
		RET_ERROR_CAPTURE_FORMAT,
		RET_ERROR_CAPTURE_BUFFER,
		RET_ERROR_CAPTURE_OUTMEMORY,
		RET_ERROR_CAPTURE_MMAP,
		RET_ERROR_CAPTURE_FORM,
		RET_ERROR_CAPTURE_MUMAP,
		RET_ERROR_CAPTURE_VIDIOC,
	};

	/**
	 *  Name: video_format enum
	 *  Function: Describe formats V4L2 will support
	 */
	typedef enum _pFormat
	{
		UNKNOWN,
		YUYV,
		MJPEG,
		YV12,
		YU12,
		NV12,
		NV21,
		H264,
	}pFormat;

	/**
	 * frame width and height infomation
	 */
	typedef struct _V4l2Info
	{
		unsigned int width;
		unsigned int height;
		unsigned int stepWidth;
		unsigned int length;
		void*        buffer;
	}V4l2Info;

	/**
	 * caputre properties
	 */
	typedef struct _V4l2Capture
	{
		pFormat      format;
		char         name[31];//dev_name
		int          fd;
		unsigned int rate;
		unsigned int quality;
		unsigned int brightness;
		V4l2Info     v4l2Info;
	}V4l2Capture;

	/**
	 *
	 */
	class V4l2Camera
	{
	public:
		V4l2Camera();
		virtual ~V4l2Camera();

	public:
		/**
		 * get the number of cameras
		 *
		 * @return the number of camera
		 */
		static int getNumberOfCameras();

		/**
		 * initialize v4l2 device
		 * @param capture v4l2 capture handl
		 * @param width frame width
		 * @param height fram height
		 *
		 * @return 0/other successful or failure
		 */
		int InitDevice(V4l2Capture *capture, pFormat format, const char* name, unsigned int rate, unsigned int width, unsigned int height);

		/**
		 * initialize v4l2 device
		 * @param capture v4l2 capture handl
		 * @param width frame width
		 * @param height fram height
		 *
		 * @return 0/other successful or failure
		 */
		int UninitDevice(V4l2Capture *capture);

		/**
		 * Set v4l2 device brightness
		 * @param capture v4l2 capture handl
		 * @param value brightness value
		 *
		 * @return 0/other successful or failure
		 */
		int SetBrightness(V4l2Capture *capture, unsigned int value);

		/**
		 * start v4l2 device
		 * @param fd v4l2 capture handl
		 *
		 * @return 0/other successful or failure
		 */
		int StartDevice(int fd);

		/**
		 * stop v4l2 device
		 * @fd capture v4l2 capture handl
		 *
		 * @return 0/other successful or failure
		 */
		int StopDevice(int fd);

		/**
		 * Get frame data
		 * @param capture v4l2 capture handl
		 *
		 * @return 0/other successful or failure
		 */
		int GetFrame(V4l2Capture *capture);

	private:
		int InitMmap(int fd);

		int xioctl(int fd, int request, void *arg);

		unsigned int GetCameraFormat(pFormat format);

		int AdjustV4l2Info(unsigned int& width, unsigned int& height);

		int MSleep(int fd, unsigned int msec);

		int MatchCameraAuto(int cameraId);

	private:
		typedef struct _Buffers
		{
			void *start;
			size_t length;
		}V4l2Buffers;

		int                    m_stime;
		V4l2Buffers*           m_buffers;
		unsigned int           m_nBuffers;
		V4l2Capture*           m_capture;

		static int mNumberOfCameras;
		static int mCameraIndex[10];
		int mUsbCameraIvalidFrameCnt;
		bool m_InitDevice;
	};
}//end namespace
#endif //CAMERA_V4L2CAMERA_H

　　V4l2Camera.cpp

#include "V4l2Camera.h"

namespace v4l2
{
	#define BUFFERS_COUNT  4
	#define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
	#define MEMST_VALUE(x) memset(&(x), 0, sizeof (x))

	const V4l2Info g_v4l2Info[] = {{160, 120}, {320, 240}, {640, 480}, {1024, 768}, {1200, 900}, {1440, 1080}, {1600, 900}, {1600, 1200}};

	V4l2Camera::V4l2Camera()
	{
		// TODO Auto-generated constructor stub
		m_capture = NULL;
		mUsbCameraIvalidFrameCnt = 0;
		m_InitDevice = false;
	}

	V4l2Camera::~V4l2Camera()
	{
		// TODO Auto-generated destructor stub
		if(m_capture)
			UninitDevice(m_capture);
	}

	int V4l2Camera::xioctl(int fd, int request, void *arg)
	{
		int r;
		int nCount= 0;

		do
		{
			r = ioctl (fd, request, arg);
		}while (RET_ERROR_FAIL == r && (EINTR == errno) && (++nCount < 100));

		return r;
	}

	int V4l2Camera::mNumberOfCameras = 0;
	int V4l2Camera::mCameraIndex[] = {0};

	unsigned int V4l2Camera::GetCameraFormat(pFormat format)
	{
		unsigned int ret = UNKNOWN;
		switch(format)
		{
		case YUYV:
			ret = V4L2_PIX_FMT_YUYV;
			break;
		case MJPEG:
			ret = V4L2_PIX_FMT_MJPEG;
			break;
		case YV12:
			ret = V4L2_PIX_FMT_YVU420;
			break;
		case YU12:
			ret = V4L2_PIX_FMT_YUV420;
			break;
		case NV12:
			ret = V4L2_PIX_FMT_NV12;
			break;
		case NV21:
			ret = V4L2_PIX_FMT_NV21;
			break;
		case H264:
			ret = V4L2_PIX_FMT_MPEG;
			break;
		default:
			break;
		}
		return ret;
	}

	int V4l2Camera::InitMmap(int fd)
	{
		int ret = RET_ERROR_OK;
		struct v4l2_requestbuffers req;
		req.count = BUFFERS_COUNT;
		req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		req.memory = V4L2_MEMORY_MMAP;

		if (RET_ERROR_FAIL == xioctl (fd, VIDIOC_REQBUFS, &req) || req.count < 2)
		{
			return RET_ERROR_CAPTURE_BUFFER;
		}

		m_buffers = (V4l2Buffers*)calloc(req.count, sizeof(V4l2Buffers));

		if (!m_buffers)
		{
			return RET_ERROR_CAPTURE_OUTMEMORY;
		}

		for (m_nBuffers = 0; m_nBuffers < req.count; ++m_nBuffers)
		{
			struct v4l2_buffer buf;

			MEMST_VALUE (buf);

			buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
			buf.memory = V4L2_MEMORY_MMAP;
			buf.index = m_nBuffers;

			if (RET_ERROR_FAIL == xioctl (fd, VIDIOC_QUERYBUF, &buf))
			{
				ret = RET_ERROR_CAPTURE_BUFFER;
				break;
			}

			m_buffers[m_nBuffers].length = buf.length;
			m_buffers[m_nBuffers].start = mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.offset);

			if (MAP_FAILED == m_buffers[m_nBuffers].start)
			{
				ret = RET_ERROR_CAPTURE_MMAP;
				break;
			}
		}
		return ret;
	}

	int V4l2Camera::AdjustV4l2Info(unsigned int& width, unsigned int& height)
	{
		int ret = RET_ERROR_FAIL;
		int index = 0;
		for(int nCount = ARRAY_LEN(g_v4l2Info) - 1, i = nCount; i >= 0; --i)
		{
			if(width <= (g_v4l2Info[i].width + 50))
			{
				index = i;
				ret = RET_ERROR_OK;
			}
			else if(0 != nCount)
			{
				width  = g_v4l2Info[index].width;
				height = g_v4l2Info[index].height;
				break;
			}
		}
		return ret;
	}

	int V4l2Camera::getNumberOfCameras()
	{
		char cam_path[20];
		int fd = -1, i=0;
		struct v4l2_capability capability;

		mNumberOfCameras = 0;
		memset(mCameraIndex,0x00,sizeof(mCameraIndex));

		for (i = 0; i < 10; ++i)
		{
			memset(cam_path,0x00,20);
			sprintf(cam_path, "/dev/video%d",i);
			fd = open(cam_path, O_RDONLY);
			if (fd < 0)
				continue;

			memset(&capability, 0, sizeof(struct v4l2_capability));
			if (ioctl(fd, VIDIOC_QUERYCAP, &capability) < 0)
			{
				//LOGE("Video device(%s): query capability not supported.\n", cam_path);
				goto loop_continue;
			}

			if ((capability.capabilities
					& (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING))
					!= (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING))
			{
			}
			else
			{
				mCameraIndex[mNumberOfCameras] = i;
				mNumberOfCameras++;
			}

	loop_continue:
			if (fd > 0)
			{
				close(fd);
				fd = -1;
			}
			continue;
		}

		return mNumberOfCameras;
	}

	int V4l2Camera::MatchCameraAuto(int cameraId)
	{
		if (mNumberOfCameras <= 0 || mNumberOfCameras > 10 || cameraId < 0)
		{
			return -1;
		}

		// search for camera ID normally
		for (int i = 0; i < mNumberOfCameras; ++i)
		{
			if (cameraId == mCameraIndex[i])
			{
				return cameraId;
			}
		}

		if (mNumberOfCameras == 1)
		{
			return mCameraIndex[0];
		}

		return cameraId > mCameraIndex[mNumberOfCameras -1] ? mCameraIndex[mNumberOfCameras -1] : mCameraIndex[0];
	}

	int V4l2Camera::InitDevice(V4l2Capture *capture, pFormat format, const char* name, unsigned int rate, unsigned int width, unsigned int height)
	{
		// TODO Auto-generated function stub
		struct stat st;
		int fd = 0, nRealCameraNameLen = 0, nMinCameraNameLen = 0;
		int ret = RET_ERROR_OK;
		char szcameraID[4], szCameraName[20];
		int cameraId = 0;
		struct v4l2_capability cap;
		struct v4l2_cropcap cropcap;
		struct v4l2_crop crop;

		if(NULL == capture || NULL == name || 0 == rate || 0 == width || 0 == height) {
			ret = RET_ERROR_CAPTURE_NULL;
			goto InitDeviceFAILED;
		}

		if ((nRealCameraNameLen = strlen(name)) < (nMinCameraNameLen =strlen("/dev/video0"))) {
			ret = RET_ERROR_CAPTURE_NULL;
			goto InitDeviceFAILED;
		}
		// Get camera ID

		memset(szcameraID,0x00,4);
		for (int i=0;i<3;i++) {
			if (nRealCameraNameLen >= (nMinCameraNameLen + i))
				szcameraID[i] = name[nMinCameraNameLen - 1 + i];
		}

		cameraId = atoi(szcameraID);
		mNumberOfCameras = 0;
		memset(mCameraIndex, 0x00, sizeof(mCameraIndex));
		if (0 == getNumberOfCameras()) {
			//LOGE("There is NO camera!");
			ret = RET_ERROR_CAPTURE_NAME;
			goto InitDeviceFAILED;
		}

		if (-1 == (cameraId = MatchCameraAuto(cameraId))) {
			//LOGE("There is NO camera!");
			ret = RET_ERROR_CAPTURE_NAME;
			goto InitDeviceFAILED;
		}

		memset(szCameraName, 0x00, 20);
		sprintf(szCameraName, "/dev/video%d", cameraId);
		//LOGI("camera name is %s.", name);
		//
		if ((RET_ERROR_FAIL == stat (szCameraName, &st)) || (!S_ISCHR (st.st_mode))
				|| (RET_ERROR_FAIL == (fd = open(szCameraName, O_RDWR | O_NONBLOCK, 0))))
		{
			ret = RET_ERROR_CAPTURE_NAME;
			goto InitDeviceFAILED;
		}

		if (RET_ERROR_FAIL == xioctl(fd, VIDIOC_QUERYCAP, &cap) || !(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)
				|| !(cap.capabilities & V4L2_CAP_STREAMING))
		{
			ret = RET_ERROR_CAPTURE_CAPABILITY;
			goto InitDeviceFAILED;
		}

		MEMST_VALUE(cropcap);
		cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

		if(RET_ERROR_OK == xioctl (fd, VIDIOC_CROPCAP, &cropcap))
		{
			crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
			crop.c = cropcap.defrect; /* reset to default */

			xioctl(fd, VIDIOC_S_CROP, &crop);
		}

		struct v4l2_format fmt;
		MEMST_VALUE (fmt);

		ret = GetCameraFormat(format);
		if(UNKNOWN == ret) {
			return RET_ERROR_CAPTURE_FORMAT;
			goto InitDeviceFAILED;
		}

		if(RET_ERROR_OK != AdjustV4l2Info(width, height))
		{
			ret = RET_ERROR_CAPTURE_FORM;
			goto InitDeviceFAILED;
		}

		//SetBrightness(capture, capture->brightness);
		fmt.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		fmt.fmt.pix.width       = width;
		fmt.fmt.pix.height      = height;
		fmt.fmt.pix.pixelformat = ret;
		fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;
		printf("%s(%d) pixel format is %d\n", __FUNCTION__,__LINE__,ret);

		if (RET_ERROR_FAIL == xioctl (fd, VIDIOC_S_FMT, &fmt)) {
			ret = RET_ERROR_CAPTURE_FORMAT;
			goto InitDeviceFAILED;
		}

		if(RET_ERROR_OK != (ret = InitMmap(fd)) ) {// || RET_ERROR_OK != (ret = SetBrightness(capture, capture->brightness)))
			goto InitDeviceFAILED;
		}

		// set video frame rate
		struct v4l2_streamparm parm;
		parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		if (RET_ERROR_OK != ioctl(fd, VIDIOC_G_PARM, &parm)) {
			//LOGI("VIDIOC_G_PARM fail....");
		}

		parm.parm.capture.timeperframe.numerator = 1;
		parm.parm.capture.timeperframe.denominator = rate;
		if (RET_ERROR_OK != ioctl(fd, VIDIOC_S_PARM, &parm)) {
			//LOGI("VIDIOC_S_PARM  Fail....");
		}

		//check setting of frame rate
		memset(&parm, 0x00, sizeof(v4l2_streamparm));
		parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

		ret = ioctl(fd, VIDIOC_G_PARM, &parm);
		if (ret != RET_ERROR_OK) {
			//LOGI("VIDIOC_G_PARM fail....");
		}

		capture->fd = fd;
		capture->v4l2Info.width = fmt.fmt.pix.width;
		capture->v4l2Info.height = fmt.fmt.pix.height;
		capture->format = format;
		capture->rate = rate;
		capture->v4l2Info.length = fmt.fmt.pix.sizeimage;
		capture->v4l2Info.stepWidth = fmt.fmt.pix.bytesperline;
		capture->v4l2Info.buffer = malloc(fmt.fmt.pix.sizeimage);
		strncpy(capture->name, name, sizeof(capture->name));

		m_stime = 1000 / rate;
		m_capture = capture;
		m_InitDevice = true;

		return ret;

InitDeviceFAILED:
		if (fd >= 0)
		{
			close(fd);
			fd = -1;
		}

	return ret;
	}

	int V4l2Camera::UninitDevice(V4l2Capture *capture)
	{
		// TODO Auto-generated function stub
		printf("%s(%d)...[BEGIN]\n", __FUNCTION__, __LINE__);
		int ret = RET_ERROR_OK;
		if (!m_InitDevice) {
			return ret;
		} else {
			m_InitDevice = false;
		}
		if (m_buffers) {
			for (unsigned int i = 0; i < m_nBuffers; ++i) {
				printf("%s(%d) munmap() i = %d\n", __FUNCTION__, __LINE__, i);
				if (RET_ERROR_FAIL == munmap(m_buffers[i].start, m_buffers[i].length)) {
					ret = RET_ERROR_CAPTURE_MUMAP;
					break;
				}
			}

			if (RET_ERROR_OK == ret) {
				printf("%s(%d) free(m_buffers)\n", __FUNCTION__, __LINE__);
				free(m_buffers);
			}
			m_buffers = NULL;
			if (capture) {
				if (capture->v4l2Info.buffer) {
					printf("%s(%d) free(capture->v4l2Info.buffer)\n", __FUNCTION__,
							__LINE__);
					free(capture->v4l2Info.buffer);
					capture->v4l2Info.buffer = NULL;
				}

				if (capture->fd >= 0) {
					printf("%s(%d) close(capture->fd)\n", __FUNCTION__, __LINE__);
					ret = close(capture->fd);
				}
			}

		}
		printf("%s(%d)...[END]\n", __FUNCTION__, __LINE__);
		return ret;
	}

	int V4l2Camera::SetBrightness(V4l2Capture *capture, unsigned int value)
	{
		// TODO Auto-generated function stub
		if(!capture || value > 10000)
			return RET_ERROR_FAIL;

		struct v4l2_control control;
		control.id = V4L2_CID_BRIGHTNESS;
		control.value = 255;

		if(RET_ERROR_FAIL == xioctl(capture->fd, VIDIOC_S_CTRL, &control))
		{
			return RET_ERROR_FAIL;
		}
		capture->brightness = control.value;

		return RET_ERROR_OK;
	}

	int V4l2Camera::StartDevice(int fd)
	{
		// TODO Auto-generated function stub
		if(fd < 0)
			return RET_ERROR_FAIL;

		int ret = RET_ERROR_OK;
		for (unsigned int i = 0; i < m_nBuffers; ++i)
		{
			struct v4l2_buffer buf;
			MEMST_VALUE(buf);

			buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
			buf.memory      = V4L2_MEMORY_MMAP;
			buf.index       = i;

			if (RET_ERROR_FAIL == xioctl(fd, VIDIOC_QBUF, &buf))
			{
				ret = RET_ERROR_CAPTURE_VIDIOC;
				break;
			}
		}

		enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

		if (RET_ERROR_FAIL == xioctl(fd, VIDIOC_STREAMON, &type))
			ret = RET_ERROR_CAPTURE_VIDIOC;

		return ret;
	}

	int V4l2Camera::StopDevice(int fd)
	{
		// TODO Auto-generated function stub
		enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		if (RET_ERROR_FAIL == xioctl(fd, VIDIOC_STREAMOFF, &type))
		{
			return RET_ERROR_FAIL;
		}
		return 0;
	}

	int V4l2Camera::MSleep(int fd, unsigned int msec)
	{
		fd_set fds;
		FD_ZERO (&fds);
		FD_SET (fd, &fds);

		struct timeval tv;
		tv.tv_sec = msec;
		tv.tv_usec = 0;

		return select (fd + 1, &fds, NULL, NULL, &tv);
	}

	int V4l2Camera::GetFrame(V4l2Capture *capture)
	{
		// TODO Auto-generated function stub
		if(!capture)
			return RET_ERROR_FAIL;

		int fd = capture->fd;

		if(RET_ERROR_FAIL == MSleep(capture->fd, m_stime))
			return RET_ERROR_FAIL;

		struct v4l2_buffer buf;

		MEMST_VALUE(buf);
		buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		buf.memory = V4L2_MEMORY_MMAP;
		buf.reserved = 0;

		// Skip the first CONFIG_CAMERA_UVC_INVAL_FRAMECNT video frames
		// because they are possibly invalid
		if (mUsbCameraIvalidFrameCnt< CONFIG_CAMERA_UVC_INVAL_FRAMECNT) {
			mUsbCameraIvalidFrameCnt++;
			if(xioctl(fd, VIDIOC_DQBUF, &buf) >= 0) {
				xioctl(fd, VIDIOC_QBUF, &buf);
			}
			return RET_ERROR_OK;
		}

		if(RET_ERROR_FAIL == xioctl(fd, VIDIOC_DQBUF, &buf) || buf.index >=  m_nBuffers)
		{
			return RET_ERROR_FAIL;
		}

		memcpy(capture->v4l2Info.buffer, m_buffers[buf.index].start, buf.bytesused);

		if(RET_ERROR_FAIL == xioctl(fd, VIDIOC_QBUF, &buf))
			return RET_ERROR_FAIL;

		return RET_ERROR_OK;
	}
}//end namespace