{

void * start;

size_t length;

{

int deviceHandle;

int bufferIndex;

int FirstCapture;

String deviceName;

char *memoryMap;

IplImage frame;

__u32 palette;

int width, height;

__u32 fps;

bool convert_rgb;

bool frame_allocated;

bool returnFrame;

/* V4L2 variables */

buffer buffers[MAX_V4L_BUFFERS + 1];

v4l2_capability cap;

v4l2_input inp;

v4l2_format form;

v4l2_crop crop;

v4l2_cropcap cropcap;

v4l2_requestbuffers req;

v4l2_buf_type type;

v4l2_queryctrl queryctrl;

timeval timestamp;

/* V4L2 control variables */

Range focus, brightness, contrast, saturation, hue, gain, exposure;

bool open(int _index);

bool open(const char* deviceName);

virtual double getProperty(int) const;

virtual bool setProperty(int, double);

virtual bool grabFrame();

virtual IplImage* retrieveFrame(int);

Range getRange(int property_id) const {

switch (property_id) {

case CV_CAP_PROP_BRIGHTNESS:

return brightness;

case CV_CAP_PROP_CONTRAST:

return contrast;

case CV_CAP_PROP_SATURATION:

return saturation;

case CV_CAP_PROP_HUE:

return hue;

case CV_CAP_PROP_GAIN:

return gain;

case CV_CAP_PROP_EXPOSURE:

return exposure;

case CV_CAP_PROP_FOCUS:

return focus;

case CV_CAP_PROP_AUTOFOCUS:

return Range(0, 1);

case CV_CAP_PROP_AUTO_EXPOSURE:

return Range(0, 4);

default:

return Range(0, 255);

}

}

virtual ~CvCaptureCAM_V4L();

int deviceHandle;

int CameraNumber;

char deviceName[MAX_DEVICE_DRIVER_NAME];

CameraNumber = 0;

while(CameraNumber < MAX_CAMERAS) {

/* Print the CameraNumber at the end of the string with a width of one character */

sprintf(deviceName, "/dev/video%1d", CameraNumber);

/* Test using an open to see if this new device name really does exists. */

deviceHandle = open(deviceName, O_RDONLY);

if (deviceHandle != -1) {

/* This device does indeed exist - add it to the total so far */

// add indexList

indexList|=(1 << CameraNumber);

numCameras++;

}

if (deviceHandle != -1)

close(deviceHandle);

/* Set up to test the next /dev/video source in line */

CameraNumber++;

} /* End while */

{

capture->form = v4l2_format();

capture->form.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

capture->form.fmt.pix.pixelformat = capture->palette;

capture->form.fmt.pix.field = V4L2_FIELD_ANY;

capture->form.fmt.pix.width = capture->width;

capture->form.fmt.pix.height = capture->height;

if (-1 == ioctl (capture->deviceHandle, VIDIOC_S_FMT, &capture->form))

return false;

return capture->palette == capture->form.fmt.pix.pixelformat;

{

// Test device for V4L2 compability

// Return value:

// -1 then unable to open device

// 0 then detected nothing

// 1 then V4L2 device

int deviceIndex;

/* Open and test V4L2 device */

capture->deviceHandle = open (deviceName, O_RDWR /* required */ | O_NONBLOCK, 0);

if (-1 == capture->deviceHandle)

{

#ifndef NDEBUG

fprintf(stderr, "(DEBUG) try_init_v4l2 open \"%s\": %s\n", deviceName, strerror(errno));

#endif

icvCloseCAM_V4L(capture);

return -1;

}

capture->cap = v4l2_capability();

if (-1 == ioctl (capture->deviceHandle, VIDIOC_QUERYCAP, &capture->cap))

{

#ifndef NDEBUG

fprintf(stderr, "(DEBUG) try_init_v4l2 VIDIOC_QUERYCAP \"%s\": %s\n", deviceName, strerror(errno));

#endif

icvCloseCAM_V4L(capture);

return 0;

}

/* Query channels number */

if (-1 == ioctl (capture->deviceHandle, VIDIOC_G_INPUT, &deviceIndex))

{

#ifndef NDEBUG

fprintf(stderr, "(DEBUG) try_init_v4l2 VIDIOC_G_INPUT \"%s\": %s\n", deviceName, strerror(errno));

#endif

icvCloseCAM_V4L(capture);

return 0;

}

/* Query information about current input */

capture->inp = v4l2_input();

capture->inp.index = deviceIndex;

if (-1 == ioctl (capture->deviceHandle, VIDIOC_ENUMINPUT, &capture->inp))

{

#ifndef NDEBUG

fprintf(stderr, "(DEBUG) try_init_v4l2 VIDIOC_ENUMINPUT \"%s\": %s\n", deviceName, strerror(errno));

#endif

icvCloseCAM_V4L(capture);

return 0;

}

return 1;

//in case palette is already set and works, no need to setup.

if(capture->palette != 0 and try_palette_v4l2(capture)){

return 0;

}

__u32 try_order[] = {

V4L2_PIX_FMT_BGR24,

V4L2_PIX_FMT_RGB24,

V4L2_PIX_FMT_YVU420,

V4L2_PIX_FMT_YUV411P,

V4L2_PIX_FMT_YUYV,

V4L2_PIX_FMT_UYVY,

V4L2_PIX_FMT_SBGGR8,

V4L2_PIX_FMT_SGBRG8,

V4L2_PIX_FMT_SN9C10X,

#ifdef HAVE_JPEG

V4L2_PIX_FMT_MJPEG,

V4L2_PIX_FMT_JPEG,

#endif

V4L2_PIX_FMT_Y16

};

for (size_t i = 0; i < sizeof(try_order) / sizeof(__u32); i++) {

capture->palette = try_order[i];

if (try_palette_v4l2(capture)) {

return 0;

}

}

fprintf(stderr,

"VIDEOIO ERROR: V4L2: Pixel format of incoming image is unsupported by OpenCV\n");

icvCloseCAM_V4L(capture);

return -1;

{

cap->queryctrl= v4l2_queryctrl();

cap->queryctrl.id = id;

if(0 != ioctl(cap->deviceHandle, VIDIOC_QUERYCTRL, &cap->queryctrl))

{

if (errno != EINVAL)

perror ("VIDIOC_QUERYCTRL");

return;

}

if (cap->queryctrl.flags & V4L2_CTRL_FLAG_DISABLED)

return;

Range range(cap->queryctrl.minimum, cap->queryctrl.maximum);

switch(cap->queryctrl.id) {

case V4L2_CID_BRIGHTNESS:

cap->brightness = range;

break;

case V4L2_CID_CONTRAST:

cap->contrast = range;

break;

case V4L2_CID_SATURATION:

cap->saturation = range;

break;

case V4L2_CID_HUE:

cap->hue = range;

break;

case V4L2_CID_GAIN:

cap->gain = range;

break;

case V4L2_CID_EXPOSURE_ABSOLUTE:

cap->exposure = range;

break;

case V4L2_CID_FOCUS_ABSOLUTE:

cap->focus = range;

break;

}

{

__u32 ctrl_id;

for (ctrl_id = V4L2_CID_BASE; ctrl_id < V4L2_CID_LASTP1; ctrl_id++)

{

v4l2_control_range(capture, ctrl_id);

}

for (ctrl_id = V4L2_CID_PRIVATE_BASE;;ctrl_id++)

{

v4l2_control_range(capture, ctrl_id);

if (errno == EINVAL)

break;

}

v4l2_control_range(capture, V4L2_CID_FOCUS_ABSOLUTE);

v4l2_streamparm setfps = v4l2_streamparm();

setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

setfps.parm.capture.timeperframe.numerator = 1;

setfps.parm.capture.timeperframe.denominator = capture->fps;

return ioctl (capture->deviceHandle, VIDIOC_S_PARM, &setfps);

switch(palette) {

case V4L2_PIX_FMT_YVU420:

case V4L2_PIX_FMT_MJPEG:

case V4L2_PIX_FMT_JPEG:

case V4L2_PIX_FMT_Y16:

return 1;

case V4L2_PIX_FMT_YUYV:

case V4L2_PIX_FMT_UYVY:

return 2;

case V4L2_PIX_FMT_BGR24:

case V4L2_PIX_FMT_RGB24:

return 3;

default:

return 0;

}

CvSize size(capture->form.fmt.pix.width, capture->form.fmt.pix.height);

int channels = 3;

int depth = IPL_DEPTH_8U;

if (!capture->convert_rgb) {

channels = v4l2_num_channels(capture->palette);

switch(capture->palette) {

case V4L2_PIX_FMT_MJPEG:

case V4L2_PIX_FMT_JPEG:

size = CvSize(capture->buffers[capture->bufferIndex].length, 1);

break;

case V4L2_PIX_FMT_YVU420:

size.height = size.height * 3 / 2; // "1.5" channels

break;

case V4L2_PIX_FMT_Y16:

if(!capture->convert_rgb){

depth = IPL_DEPTH_16U;

}

break;

}

}

/* Set up Image data */

cvInitImageHeader(&capture->frame, size, depth, channels);

/* Allocate space for pixelformat we convert to.

if(capture->convert_rgb) {

capture->frame.imageData = (char*)cvAlloc(capture->frame.imageSize);

}

capture->frame_allocated = capture->convert_rgb;

{

const char* deviceName = capture->deviceName.c_str();

if (try_init_v4l2(capture, deviceName) != 1) {

/* init of the v4l2 device is not OK */

return -1;

}

/* V4L2 control variables are zero (memset above) */

/* Scan V4L2 controls */

v4l2_scan_controls(capture);

if ((capture->cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) {

/* Nope. */

fprintf( stderr, "VIDEOIO ERROR: V4L2: device %s is unable to capture video memory.\n",deviceName);

icvCloseCAM_V4L(capture);

return -1;

}

/* The following code sets the CHANNEL_NUMBER of the video input. Some video sources

if(capture->inp.index > 0) {

capture->inp = v4l2_input();

capture->inp.index = CHANNEL_NUMBER;

/* Set only channel number to CHANNEL_NUMBER */

/* V4L2 have a status field from selected video mode */

if (-1 == ioctl (capture->deviceHandle, VIDIOC_ENUMINPUT, &capture->inp))

{

fprintf (stderr, "VIDEOIO ERROR: V4L2: Aren't able to set channel number\n");

icvCloseCAM_V4L (capture);

return -1;

}

} /* End if */

/* Find Window info */

capture->form = v4l2_format();

capture->form.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

if (-1 == ioctl (capture->deviceHandle, VIDIOC_G_FMT, &capture->form)) {

fprintf( stderr, "VIDEOIO ERROR: V4L2: Could not obtain specifics of capture window.\n\n");

icvCloseCAM_V4L(capture);

return -1;

}

if (autosetup_capture_mode_v4l2(capture) == -1)

return -1;

/* try to set framerate */

v4l2_set_fps(capture);

unsigned int min;

/* Buggy driver paranoia. */

min = capture->form.fmt.pix.width * 2;

if (capture->form.fmt.pix.bytesperline < min)

capture->form.fmt.pix.bytesperline = min;

min = capture->form.fmt.pix.bytesperline * capture->form.fmt.pix.height;

if (capture->form.fmt.pix.sizeimage < min)

capture->form.fmt.pix.sizeimage = min;

capture->req = v4l2_requestbuffers();

unsigned int buffer_number = DEFAULT_V4L_BUFFERS;

try_again:

capture->req.count = buffer_number;

capture->req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

capture->req.memory = V4L2_MEMORY_MMAP;

if (-1 == ioctl (capture->deviceHandle, VIDIOC_REQBUFS, &capture->req))

{

if (EINVAL == errno)

{

fprintf (stderr, "%s does not support memory mapping\n", deviceName);

} else {

perror ("VIDIOC_REQBUFS");

}

/* free capture, and returns an error code */

icvCloseCAM_V4L (capture);

return -1;

}

if (capture->req.count < buffer_number)

{

if (buffer_number == 1)

{

fprintf (stderr, "Insufficient buffer memory on %s\n", deviceName);

/* free capture, and returns an error code */

icvCloseCAM_V4L (capture);

return -1;

} else {

buffer_number--;

fprintf (stderr, "Insufficient buffer memory on %s -- decreaseing buffers\n", deviceName);

goto try_again;

}

}

for (n_buffers = 0; n_buffers < capture->req.count; ++n_buffers)

{

v4l2_buffer buf = v4l2_buffer();

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = n_buffers;

if (-1 == ioctl (capture->deviceHandle, VIDIOC_QUERYBUF, &buf)) {

perror ("VIDIOC_QUERYBUF");

/* free capture, and returns an error code */

icvCloseCAM_V4L (capture);

return -1;

}

capture->buffers[n_buffers].length = buf.length;

capture->buffers[n_buffers].start =

mmap (NULL /* start anywhere */,

buf.length,

PROT_READ | PROT_WRITE /* required */,

MAP_SHARED /* recommended */,

capture->deviceHandle, buf.m.offset);

if (MAP_FAILED == capture->buffers[n_buffers].start) {

perror ("mmap");

/* free capture, and returns an error code */

icvCloseCAM_V4L (capture);

return -1;

}

if (n_buffers == 0) {

capture->buffers[MAX_V4L_BUFFERS].start = malloc( buf.length );

capture->buffers[MAX_V4L_BUFFERS].length = buf.length;

}

}

v4l2_create_frame(capture);

// reinitialize buffers

capture->FirstCapture = 1;

return 1;

String deviceName = capture->deviceName;

icvCloseCAM_V4L(capture);

capture->deviceName = deviceName;

return _capture_V4L2(capture) == 1;

{

int autoindex = 0;

char _deviceName[MAX_DEVICE_DRIVER_NAME];

if (!numCameras)

icvInitCapture_V4L(); /* Havent called icvInitCapture yet - do it now! */

if (!numCameras)

return false; /* Are there any /dev/video input sources? */

//search index in indexList

if ( (_index>-1) && ! ((1 << _index) & indexList) )

{

fprintf( stderr, "VIDEOIO ERROR: V4L: index %d is not correct!\n",_index);

return false; /* Did someone ask for not correct video source number? */

}

/* Select camera, or rather, V4L video source */

if (_index<0) { // Asking for the first device available

for (; autoindex<MAX_CAMERAS;autoindex++)

if (indexList & (1<<autoindex))

break;

if (autoindex==MAX_CAMERAS)

return false;

_index=autoindex;

autoindex++;// i can recall icvOpenCAM_V4l with index=-1 for next camera

}

/* Print the CameraNumber at the end of the string with a width of one character */

sprintf(_deviceName, "/dev/video%1d", _index);

return open(_deviceName);

{

FirstCapture = 1;

width = DEFAULT_V4L_WIDTH;

height = DEFAULT_V4L_HEIGHT;

fps = DEFAULT_V4L_FPS;

convert_rgb = true;

deviceName = _deviceName;

returnFrame = true;

return _capture_V4L2(this) == 1;

v4l2_buffer buf = v4l2_buffer();

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

if (-1 == ioctl (capture->deviceHandle, VIDIOC_DQBUF, &buf)) {

switch (errno) {

case EAGAIN:

return 0;

case EIO:

if (!(buf.flags & (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE)))

{

if (ioctl(capture->deviceHandle, VIDIOC_QBUF, &buf) == -1)

{

return 0;

}

}

return 0;

default:

/* display the error and stop processing */

capture->returnFrame = false;

perror ("VIDIOC_DQBUF");

return -1;

}

}

assert(buf.index < capture->req.count);

memcpy(capture->buffers[MAX_V4L_BUFFERS].start,

capture->buffers[buf.index].start,

capture->buffers[MAX_V4L_BUFFERS].length );

capture->bufferIndex = MAX_V4L_BUFFERS;

//printf("got data in buff %d, len=%d, flags=0x%X, seq=%d, used=%d)\n",

// buf.index, buf.length, buf.flags, buf.sequence, buf.bytesused);

//set timestamp in capture struct to be timestamp of most recent frame

capture->timestamp = buf.timestamp;

if (-1 == ioctl (capture->deviceHandle, VIDIOC_QBUF, &buf))

perror ("VIDIOC_QBUF");

return 1;

unsigned int count;

count = 1;

while (count-- > 0) {

for (;;) {

fd_set fds;

struct timeval tv;

int r;

FD_ZERO (&fds);

FD_SET (capture->deviceHandle, &fds);

/* Timeout. */

tv.tv_sec = 10;

tv.tv_usec = 0;

r = select (capture->deviceHandle+1, &fds, NULL, NULL, &tv);

if (-1 == r) {

if (EINTR == errno)

continue;

perror ("select");

}

if (0 == r) {

fprintf (stderr, "select timeout\n");

/* end the infinite loop */

break;

}

int returnCode = read_frame_v4l2 (capture);

if(returnCode == -1)

return -1;

if(returnCode == 1)

break;

}

}

return 0;

if (capture->FirstCapture) {

/* Some general initialization must take place the first time through */

/* This is just a technicality, but all buffers must be filled up before any

{

for (capture->bufferIndex = 0;

capture->bufferIndex < ((int)capture->req.count);

++capture->bufferIndex)

{

v4l2_buffer buf = v4l2_buffer();

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = (unsigned long)capture->bufferIndex;

if (-1 == ioctl (capture->deviceHandle, VIDIOC_QBUF, &buf)) {

perror ("VIDIOC_QBUF");

return false;

}

}

/* enable the streaming */

capture->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

if (-1 == ioctl (capture->deviceHandle, VIDIOC_STREAMON,

&capture->type)) {

/* error enabling the stream */

perror ("VIDIOC_STREAMON");

return false;

}

}

#if defined(V4L_ABORT_BADJPEG)

// skip first frame. it is often bad -- this is unnotied in traditional apps,

// but could be fatal if bad jpeg is enabled

if(mainloop_v4l2(capture) == -1)

return false;

#endif

/* preparation is ok */

capture->FirstCapture = 0;

}

if(mainloop_v4l2(capture) == -1) return false;

return true;