{

void * start;

size_t length;

Memory() : start(NULL), length(0) {}

{

Memory memories[VIDEO_MAX_PLANES];

v4l2_plane planes[VIDEO_MAX_PLANES] = {};

// Total number of bytes occupied by data in the all planes (payload)

__u32 bytesused;

// This is dequeued buffer. It used for to put it back in the queue.

// The buffer is valid only if capture->bufferIndex >= 0

v4l2_buffer buffer;

Buffer()

{

buffer = v4l2_buffer();

}

deviceHandle(-1),

v4l_buffersRequested(false),

v4l_streamStarted(false),

bufferIndex(-1),

FirstCapture(true),

palette(0),

width(0), height(0), width_set(0), height_set(0),

bufferSize(DEFAULT_V4L_BUFFERS),

fps(0), convert_rgb(0), returnFrame(false),

channelNumber(-1), normalizePropRange(false),

type(V4L2_BUF_TYPE_VIDEO_CAPTURE),

num_planes(0),

havePendingFrame(false)

{

memset(&timestamp, 0, sizeof(timestamp));

{

if (v4l_streamStarted)

streaming(false);

if (v4l_buffersRequested)

releaseBuffers();

if(deviceHandle != -1)

{

CV_LOG_DEBUG(NULL, "VIDEOIO(V4L2:" << deviceName << "): close(" << deviceHandle << ")");

close(deviceHandle);

}

deviceHandle = -1;

{

form = v4l2_format();

form.type = type;

if (V4L2_TYPE_IS_MULTIPLANAR(type)) {

form.fmt.pix_mp.pixelformat = palette;

form.fmt.pix_mp.field = V4L2_FIELD_ANY;

form.fmt.pix_mp.width = width;

form.fmt.pix_mp.height = height;

} else {

form.fmt.pix.pixelformat = palette;

form.fmt.pix.field = V4L2_FIELD_ANY;

form.fmt.pix.width = width;

form.fmt.pix.height = height;

}

if (!tryIoctl(VIDIOC_S_FMT, &form, true))

{

return false;

}

if (V4L2_TYPE_IS_MULTIPLANAR(type))

return palette == form.fmt.pix_mp.pixelformat;

return palette == form.fmt.pix.pixelformat;

{

if(channelNumber < 0)

return true;

/* Query channels number */

int channel = 0;

if (!tryIoctl(VIDIOC_G_INPUT, &channel))

return false;

if(channel == channelNumber)

return true;

/* Query information about new input channel */

videoInput = v4l2_input();

videoInput.index = channelNumber;

if (!tryIoctl(VIDIOC_ENUMINPUT, &videoInput))

return false;

//To select a video input applications store the number of the desired input in an integer

// and call the VIDIOC_S_INPUT ioctl with a pointer to this integer. Side effects are possible.

// For example inputs may support different video standards, so the driver may implicitly

// switch the current standard.

// It is good practice to select an input before querying or negotiating any other parameters.

return tryIoctl(VIDIOC_S_INPUT, &channelNumber);

{

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

// The cv::CAP_PROP_MODE used for set the video input channel number

if (!setVideoInputChannel())

{

CV_LOG_DEBUG(NULL, "VIDEOIO(V4L2:" << deviceName << "): Unable to set Video Input Channel");

return false;

}

// Test device for V4L2 compatibility

capability = v4l2_capability();

if (!tryIoctl(VIDIOC_QUERYCAP, &capability))

{

CV_LOG_DEBUG(NULL, "VIDEOIO(V4L2:" << deviceName << "): Unable to query capability");

return false;

}

if ((capability.capabilities & (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_CAPTURE_MPLANE)) == 0)

{

/* Nope. */

CV_LOG_INFO(NULL, "VIDEOIO(V4L2:" << deviceName << "): not supported - device is unable to capture video (missing V4L2_CAP_VIDEO_CAPTURE or V4L2_CAP_VIDEO_CAPTURE_MPLANE)");

return false;

}

if (capability.capabilities & V4L2_CAP_VIDEO_CAPTURE_MPLANE)

type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;

return true;

{

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

if (palette != 0)

{

if (try_palette_v4l2())

{

return true;

}

else if (errno == EBUSY)

{

CV_LOG_INFO(NULL, "VIDEOIO(V4L2:" << deviceName << "): device is busy");

closeDevice();

return false;

}

}

__u32 try_order[] = {

V4L2_PIX_FMT_BGR24,

V4L2_PIX_FMT_RGB24,

V4L2_PIX_FMT_YVU420,

V4L2_PIX_FMT_YUV420,

V4L2_PIX_FMT_YUV411P,

V4L2_PIX_FMT_YUYV,

V4L2_PIX_FMT_UYVY,

V4L2_PIX_FMT_NV12,

V4L2_PIX_FMT_NV21,

V4L2_PIX_FMT_SBGGR8,

V4L2_PIX_FMT_SGBRG8,

V4L2_PIX_FMT_SGRBG8,

V4L2_PIX_FMT_XBGR32,

V4L2_PIX_FMT_ABGR32,

V4L2_PIX_FMT_SN9C10X,

#ifdef HAVE_JPEG

V4L2_PIX_FMT_MJPEG,

V4L2_PIX_FMT_JPEG,

#endif

V4L2_PIX_FMT_Y16,

V4L2_PIX_FMT_Y16_BE,

V4L2_PIX_FMT_Y12,

V4L2_PIX_FMT_Y10,

V4L2_PIX_FMT_GREY,

};

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

palette = try_order[i];

if (try_palette_v4l2()) {

return true;

} else if (errno == EBUSY) {

CV_LOG_INFO(NULL, "VIDEOIO(V4L2:" << deviceName << "): device is busy");

closeDevice();

return false;

}

}

return false;

{

if (!isOpened())

return false;

v4l2_streamparm streamparm = v4l2_streamparm();

streamparm.type = type;

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

streamparm.parm.capture.timeperframe.denominator = __u32(value);

if (!tryIoctl(VIDIOC_S_PARM, &streamparm) || !tryIoctl(VIDIOC_G_PARM, &streamparm))

{

CV_LOG_INFO(NULL, "VIDEOIO(V4L2:" << deviceName << "): can't set FPS: " << value);

return false;

}

CV_LOG_DEBUG(NULL, "VIDEOIO(V4L2:" << deviceName << "): FPS="

<< streamparm.parm.capture.timeperframe.denominator << "/"

<< streamparm.parm.capture.timeperframe.numerator);

fps = streamparm.parm.capture.timeperframe.denominator; // TODO use numerator

return true;

{

switch (palette) {

case V4L2_PIX_FMT_YVU420:

case V4L2_PIX_FMT_YUV420:

case V4L2_PIX_FMT_NV12:

case V4L2_PIX_FMT_NV21:

case V4L2_PIX_FMT_YUV411P:

#ifdef HAVE_JPEG

case V4L2_PIX_FMT_MJPEG:

case V4L2_PIX_FMT_JPEG:

#endif

case V4L2_PIX_FMT_YUYV:

case V4L2_PIX_FMT_UYVY:

case V4L2_PIX_FMT_SBGGR8:

case V4L2_PIX_FMT_SN9C10X:

case V4L2_PIX_FMT_SGBRG8:

case V4L2_PIX_FMT_SGRBG8:

case V4L2_PIX_FMT_RGB24:

case V4L2_PIX_FMT_Y16:

case V4L2_PIX_FMT_Y16_BE:

case V4L2_PIX_FMT_Y10:

case V4L2_PIX_FMT_GREY:

case V4L2_PIX_FMT_BGR24:

case V4L2_PIX_FMT_XBGR32:

case V4L2_PIX_FMT_ABGR32:

return true;

default:

break;

}

return false;

{

if (!isOpened())

return false;

if (!try_init_v4l2())

{

CV_LOG_DEBUG(NULL, "VIDEOIO(V4L2:" << deviceName << "): init failed: errno=" << errno << " (" << strerror(errno) << ")");

return false;

}

/* Find Window info */

form = v4l2_format();

form.type = type;

if (!tryIoctl(VIDIOC_G_FMT, &form))

{

CV_LOG_DEBUG(NULL, "VIDEOIO(V4L2:" << deviceName << "): Could not obtain specifics of capture window (VIDIOC_G_FMT): errno=" << errno << " (" << strerror(errno) << ")");

return false;

}

if (!autosetup_capture_mode_v4l2())

{

if (errno != EBUSY)

{

CV_LOG_INFO(NULL, "VIDEOIO(V4L2:" << deviceName << "): Pixel format of incoming image is unsupported by OpenCV");

}

return false;

}

/* try to set framerate */

setFps(fps);

/* Buggy driver paranoia. */

if (V4L2_TYPE_IS_MULTIPLANAR(type)) {

// TODO: add size adjustment if needed

} else {

unsigned int min;

min = form.fmt.pix.width * 2;

if (form.fmt.pix.bytesperline < min)

form.fmt.pix.bytesperline = min;

min = form.fmt.pix.bytesperline * form.fmt.pix.height;

if (form.fmt.pix.sizeimage < min)

form.fmt.pix.sizeimage = min;

}

if (V4L2_TYPE_IS_MULTIPLANAR(type))

num_planes = form.fmt.pix_mp.num_planes;

else

num_planes = 1;

if (!requestBuffers())

return false;

if (!createBuffers()) {

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

releaseBuffers();

return false;

}

// reinitialize buffers

FirstCapture = true;

return true;

{

unsigned int buffer_number = bufferSize;

while (buffer_number > 0) {

if (requestBuffers(buffer_number) && req.count >= buffer_number)

{

break;

}

buffer_number--;

CV_LOG_DEBUG(NULL, "VIDEOIO(V4L2:" << deviceName << "): Insufficient buffer memory -- decreasing buffers: " << buffer_number);

}

if (buffer_number < 1) {

CV_LOG_WARNING(NULL, "VIDEOIO(V4L2:" << deviceName << "): Insufficient buffer memory");

return false;

}

bufferSize = req.count;

return true;

{

if (!isOpened())

return false;

req = v4l2_requestbuffers();

req.count = buffer_number;

req.type = type;

req.memory = V4L2_MEMORY_MMAP;

if (!tryIoctl(VIDIOC_REQBUFS, &req)) {

int err = errno;

if (EINVAL == err)

{

CV_LOG_WARNING(NULL, "VIDEOIO(V4L2:" << deviceName << "): no support for memory mapping");

}

else

{

CV_LOG_WARNING(NULL, "VIDEOIO(V4L2:" << deviceName << "): failed VIDIOC_REQBUFS: errno=" << err << " (" << strerror(err) << ")");

}

return false;

}

v4l_buffersRequested = true;

return true;

{

size_t maxLength = 0;

for (unsigned int n_buffers = 0; n_buffers < req.count; ++n_buffers) {

v4l2_buffer buf = v4l2_buffer();

v4l2_plane mplanes[VIDEO_MAX_PLANES];

size_t length = 0;

off_t offset = 0;

buf.type = type;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = n_buffers;

if (V4L2_TYPE_IS_MULTIPLANAR(type)) {

buf.m.planes = mplanes;

buf.length = VIDEO_MAX_PLANES;

}

if (!tryIoctl(VIDIOC_QUERYBUF, &buf)) {

CV_LOG_WARNING(NULL, "VIDEOIO(V4L2:" << deviceName << "): failed VIDIOC_QUERYBUF: errno=" << errno << " (" << strerror(errno) << ")");

return false;

}

CV_Assert(1 <= num_planes && num_planes <= VIDEO_MAX_PLANES);

for (unsigned char n_planes = 0; n_planes < num_planes; n_planes++) {

if (V4L2_TYPE_IS_MULTIPLANAR(type)) {

length = buf.m.planes[n_planes].length;

offset = buf.m.planes[n_planes].m.mem_offset;

} else {

length = buf.length;

offset = buf.m.offset;

}

buffers[n_buffers].memories[n_planes].length = length;

buffers[n_buffers].memories[n_planes].start =

mmap(NULL /* start anywhere */,

length,

PROT_READ /* required */,

MAP_SHARED /* recommended */,

deviceHandle, offset);

if (MAP_FAILED == buffers[n_buffers].memories[n_planes].start) {

CV_LOG_WARNING(NULL, "VIDEOIO(V4L2:" << deviceName << "): failed mmap(" << length << "): errno=" << errno << " (" << strerror(errno) << ")");

return false;

}

}

maxLength = maxLength > length ? maxLength : length;

}

if (maxLength > 0) {

maxLength *= num_planes;

buffers[MAX_V4L_BUFFERS].memories[MEMORY_ORIG].start = malloc(maxLength);

buffers[MAX_V4L_BUFFERS].memories[MEMORY_ORIG].length = maxLength;

buffers[MAX_V4L_BUFFERS].memories[MEMORY_RGB].start = malloc(maxLength);

buffers[MAX_V4L_BUFFERS].memories[MEMORY_RGB].length = maxLength;

}

return (buffers[MAX_V4L_BUFFERS].memories[MEMORY_ORIG].start != 0) &&

(buffers[MAX_V4L_BUFFERS].memories[MEMORY_RGB].start != 0);

{

streaming(false);

releaseBuffers();

return initCapture();

{

cv::String name;

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

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

{

for (int autoindex = 0; autoindex < MAX_CAMERAS; ++autoindex)

{

name = cv::format("/dev/video%d", autoindex);

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

int h = ::open(name.c_str(), O_RDONLY);

if (h != -1)

{

::close(h);

_index = autoindex;

break;

}

}

if (_index < 0)

{

CV_LOG_WARNING(NULL, "VIDEOIO(V4L2): can't find camera device");

name.clear();

return false;

}

}

else

{

name = cv::format("/dev/video%d", _index);

}

bool res = open(name);

if (!res)

{

CV_LOG_WARNING(NULL, "VIDEOIO(V4L2:" << deviceName << "): can't open camera by index");

}

return res;

{

CV_LOG_DEBUG(NULL, "VIDEOIO(V4L2:" << _deviceName << "): opening...");

FirstCapture = true;

width = utils::getConfigurationParameterSizeT("OPENCV_VIDEOIO_V4L_DEFAULT_WIDTH", DEFAULT_V4L_WIDTH);

height = utils::getConfigurationParameterSizeT("OPENCV_VIDEOIO_V4L_DEFAULT_HEIGHT", DEFAULT_V4L_HEIGHT);

width_set = height_set = 0;

bufferSize = DEFAULT_V4L_BUFFERS;

fps = DEFAULT_V4L_FPS;

convert_rgb = true;

deviceName = _deviceName;

returnFrame = true;

normalizePropRange = utils::getConfigurationParameterBool("OPENCV_VIDEOIO_V4L_RANGE_NORMALIZED", false);

channelNumber = -1;

bufferIndex = -1;

deviceHandle = ::open(deviceName.c_str(), O_RDWR /* required */ | O_NONBLOCK, 0);

CV_LOG_DEBUG(NULL, "VIDEOIO(V4L2:" << _deviceName << "): deviceHandle=" << deviceHandle);

if (deviceHandle == -1)

return false;

return initCapture();

{

v4l2_buffer buf = v4l2_buffer();

v4l2_plane mplanes[VIDEO_MAX_PLANES];

buf.type = type;

buf.memory = V4L2_MEMORY_MMAP;

if (V4L2_TYPE_IS_MULTIPLANAR(type)) {

buf.m.planes = mplanes;

buf.length = VIDEO_MAX_PLANES;

}

while (!tryIoctl(VIDIOC_DQBUF, &buf)) {

int err = errno;

if (err == EIO && !(buf.flags & (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE))) {

// Maybe buffer not in the queue? Try to put there

if (!tryIoctl(VIDIOC_QBUF, &buf))

return false;

continue;

}

/* display the error and stop processing */

returnFrame = false;

CV_LOG_DEBUG(NULL, "VIDEOIO(V4L2:" << deviceName << "): can't read frame (VIDIOC_DQBUF): errno=" << err << " (" << strerror(err) << ")");

return false;

}

CV_Assert(buf.index < req.count);

if (V4L2_TYPE_IS_MULTIPLANAR(type)) {

for (unsigned char n_planes = 0; n_planes < num_planes; n_planes++)

CV_Assert(buffers[buf.index].memories[n_planes].length == buf.m.planes[n_planes].length);

} else

CV_Assert(buffers[buf.index].memories[MEMORY_ORIG].length == buf.length);

//We shouldn't use this buffer in the queue while not retrieve frame from it.

buffers[buf.index].buffer = buf;

bufferIndex = buf.index;

if (V4L2_TYPE_IS_MULTIPLANAR(type)) {

__u32 offset = 0;

buffers[buf.index].buffer.m.planes = buffers[buf.index].planes;

memcpy(buffers[buf.index].planes, buf.m.planes, sizeof(mplanes));

for (unsigned char n_planes = 0; n_planes < num_planes; n_planes++) {

__u32 bytesused;

bytesused = buffers[buf.index].planes[n_planes].bytesused -

buffers[buf.index].planes[n_planes].data_offset;

offset += bytesused;

}

buffers[buf.index].bytesused = offset;

} else

buffers[buf.index].bytesused = buffers[buf.index].buffer.bytesused;

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

timestamp = buf.timestamp;

return true;