frodovdr/hyperion.ng
1
0
Fork 0
mirror of https://github.com/hyperion-project/hyperion.ng.git synced 2023-10-10 13:36:59 +02:00
Code Issues Releases Wiki Activity

Crash on unsupported control commands prevented

Browse Source
This commit is contained in:
Paulchen-Panther 2019-05-03 22:38:28 +02:00
parent c6de5173ec
commit 849f737db7
No known key found for this signature in database
GPG Key ID: 84E3B692456B6840
2 changed files with 294 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
include/grabber/V4L2Grabber.h
View File

@ -37,8 +37,12 @@ public:
); );
virtual ~V4L2Grabber(); virtual ~V4L2Grabber();
QRectF getSignalDetectionOffset(); QRectF getSignalDetectionOffset()
bool getSignalDetectionEnabled(); {
return QRectF(_x_frac_min, _y_frac_min, _x_frac_max, _y_frac_max);
}
bool getSignalDetectionEnabled() { return _signalDetectionEnabled; }
int grabFrame(Image<ColorRgb> &); int grabFrame(Image<ColorRgb> &);
@ -125,9 +129,15 @@ private:
int xioctl(int request, void *arg); int xioctl(int request, void *arg);
void throw_exception(const QString &error); void throw_exception(const QString & error)
{
Error(_log, "Throws error: %s", QSTRING_CSTR(error));
}
void throw_errno_exception(const QString &error); void throw_errno_exception(const QString & error)
{
Error(_log, "Throws error nr: %s", QSTRING_CSTR(QString(error + " error code " + QString::number(errno) + ", " + strerror(errno))));
}
private: private:
enum io_method enum io_method

532
libsrc/grabber/v4l2/V4L2Grabber.cpp
View File

@ -206,11 +206,6 @@ void V4L2Grabber::setSignalDetectionOffset(double horizontalMin, double vertical
Info(_log, "Signal detection area set to: %f,%f x %f,%f", _x_frac_min, _y_frac_min, _x_frac_max, _y_frac_max ); Info(_log, "Signal detection area set to: %f,%f x %f,%f", _x_frac_min, _y_frac_min, _x_frac_max, _y_frac_max );
} }
QRectF V4L2Grabber::getSignalDetectionOffset()
{
return QRectF(_x_frac_min, _y_frac_min, _x_frac_max, _y_frac_max);
}
bool V4L2Grabber::start() bool V4L2Grabber::start()
{ {
try try
@ -298,7 +293,8 @@ void V4L2Grabber::init_read(unsigned int buffer_size)
_buffers[0].length = buffer_size; _buffers[0].length = buffer_size;
_buffers[0].start = malloc(buffer_size); _buffers[0].start = malloc(buffer_size);
if (!_buffers[0].start) { if (!_buffers[0].start)
{
throw_exception("Out of memory"); throw_exception("Out of memory");
return; return;
} }
@ -314,31 +310,37 @@ void V4L2Grabber::init_mmap()
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_MMAP; req.memory = V4L2_MEMORY_MMAP;
if (-1 == xioctl(VIDIOC_REQBUFS, &req)) { if (-1 == xioctl(VIDIOC_REQBUFS, &req))
if (EINVAL == errno) { {
if (EINVAL == errno)
{
throw_exception("'" + _deviceName + "' does not support memory mapping"); throw_exception("'" + _deviceName + "' does not support memory mapping");
return; return;
} else { }
else
{
throw_errno_exception("VIDIOC_REQBUFS"); throw_errno_exception("VIDIOC_REQBUFS");
return; return;
} }
} }
if (req.count < 2) { if (req.count < 2)
{
throw_exception("Insufficient buffer memory on " + _deviceName); throw_exception("Insufficient buffer memory on " + _deviceName);
return; return;
} }
_buffers.resize(req.count); _buffers.resize(req.count);
for (size_t n_buffers = 0; n_buffers < req.count; ++n_buffers) { for (size_t n_buffers = 0; n_buffers < req.count; ++n_buffers)
{
struct v4l2_buffer buf; struct v4l2_buffer buf;
CLEAR(buf); CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP; buf.memory = V4L2_MEMORY_MMAP;
buf.index = n_buffers; buf.index = n_buffers;
if (-1 == xioctl(VIDIOC_QUERYBUF, &buf)) if (-1 == xioctl(VIDIOC_QUERYBUF, &buf))
{ {
@ -347,12 +349,12 @@ void V4L2Grabber::init_mmap()
} }
_buffers[n_buffers].length = buf.length; _buffers[n_buffers].length = buf.length;
_buffers[n_buffers].start = _buffers[n_buffers].start = mmap(NULL /* start anywhere */,
mmap(NULL /* start anywhere */, buf.length,
buf.length, PROT_READ | PROT_WRITE /* required */,
PROT_READ | PROT_WRITE /* required */, MAP_SHARED /* recommended */,
MAP_SHARED /* recommended */, _fileDescriptor, buf.m.offset
_fileDescriptor, buf.m.offset); );
if (MAP_FAILED == _buffers[n_buffers].start) if (MAP_FAILED == _buffers[n_buffers].start)
{ {
@ -372,12 +374,15 @@ void V4L2Grabber::init_userp(unsigned int buffer_size)
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_USERPTR; req.memory = V4L2_MEMORY_USERPTR;
if (-1 == xioctl(VIDIOC_REQBUFS, &req)) { if (-1 == xioctl(VIDIOC_REQBUFS, &req))
{
if (EINVAL == errno) if (EINVAL == errno)
{ {
throw_exception("'" + _deviceName + "' does not support user pointer"); throw_exception("'" + _deviceName + "' does not support user pointer");
return; return;
} else { }
else
{
throw_errno_exception("VIDIOC_REQBUFS"); throw_errno_exception("VIDIOC_REQBUFS");
return; return;
} }
@ -385,11 +390,13 @@ void V4L2Grabber::init_userp(unsigned int buffer_size)
_buffers.resize(4); _buffers.resize(4);
for (size_t n_buffers = 0; n_buffers < 4; ++n_buffers) { for (size_t n_buffers = 0; n_buffers < 4; ++n_buffers)
{
_buffers[n_buffers].length = buffer_size; _buffers[n_buffers].length = buffer_size;
_buffers[n_buffers].start = malloc(buffer_size); _buffers[n_buffers].start = malloc(buffer_size);
if (!_buffers[n_buffers].start) { if (!_buffers[n_buffers].start)
{
throw_exception("Out of memory"); throw_exception("Out of memory");
return; return;
} }
@ -401,10 +408,13 @@ void V4L2Grabber::init_device(VideoStandard videoStandard, int input)
struct v4l2_capability cap; struct v4l2_capability cap;
if (-1 == xioctl(VIDIOC_QUERYCAP, &cap)) if (-1 == xioctl(VIDIOC_QUERYCAP, &cap))
{ {
if (EINVAL == errno) { if (EINVAL == errno)
{
throw_exception("'" + _deviceName + "' is no V4L2 device"); throw_exception("'" + _deviceName + "' is no V4L2 device");
return; return;
} else { }
else
{
throw_errno_exception("VIDIOC_QUERYCAP"); throw_errno_exception("VIDIOC_QUERYCAP");
return; return;
} }
@ -416,21 +426,26 @@ void V4L2Grabber::init_device(VideoStandard videoStandard, int input)
return; return;
} }
switch (_ioMethod) { switch (_ioMethod)
case IO_METHOD_READ: {
if (!(cap.capabilities & V4L2_CAP_READWRITE)) case IO_METHOD_READ:
{ {
throw_exception("'" + _deviceName + "' does not support read i/o"); if (!(cap.capabilities & V4L2_CAP_READWRITE))
return; {
throw_exception("'" + _deviceName + "' does not support read i/o");
return;
}
} }
break; break;
case IO_METHOD_MMAP: case IO_METHOD_MMAP:
case IO_METHOD_USERPTR: case IO_METHOD_USERPTR:
if (!(cap.capabilities & V4L2_CAP_STREAMING))
{ {
throw_exception("'" + _deviceName + "' does not support streaming i/o"); if (!(cap.capabilities & V4L2_CAP_STREAMING))
return; {
throw_exception("'" + _deviceName + "' does not support streaming i/o");
return;
}
} }
break; break;
} }
@ -443,27 +458,32 @@ void V4L2Grabber::init_device(VideoStandard videoStandard, int input)
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 == xioctl(VIDIOC_CROPCAP, &cropcap)) { if (0 == xioctl(VIDIOC_CROPCAP, &cropcap))
{
struct v4l2_crop crop; struct v4l2_crop crop;
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; /* reset to default */ crop.c = cropcap.defrect; /* reset to default */
if (-1 == xioctl(VIDIOC_S_CROP, &crop)) { if (-1 == xioctl(VIDIOC_S_CROP, &crop))
switch (errno) { {
case EINVAL: switch (errno)
/* Cropping not supported. */ {
break; case EINVAL: /* Cropping not supported. */
default: default: /* Errors ignored. */
/* Errors ignored. */ break;
break;
} }
} }
} else { }
else
{
/* Errors ignored. */ /* Errors ignored. */
} }
// set input if needed // set input if needed and supported
if (input >= 0) struct v4l2_input v4l2Input;
v4l2Input.index = input;
if (input >= 0 && 0 == xioctl(VIDIOC_ENUMINPUT,&v4l2Input))
{ {
if (-1 == xioctl(VIDIOC_S_INPUT, &input)) if (-1 == xioctl(VIDIOC_S_INPUT, &input))
{ {
@ -472,44 +492,52 @@ void V4L2Grabber::init_device(VideoStandard videoStandard, int input)
} }
} }
// set the video standard if needed // set the video standard if needed and supported
switch (videoStandard) v4l2_std_id std_id;
if (0 == xioctl(VIDIOC_QUERYSTD, &std_id))
{ {
case VIDEOSTANDARD_PAL: switch (videoStandard)
{
v4l2_std_id std_id = V4L2_STD_PAL;
if (-1 == xioctl(VIDIOC_S_STD, &std_id))
{ {
throw_errno_exception("VIDIOC_S_STD"); case VIDEOSTANDARD_PAL:
return; {
std_id = V4L2_STD_PAL;
if (-1 == xioctl(VIDIOC_S_STD, &std_id))
{
throw_errno_exception("VIDIOC_S_STD");
return;
}
}
break;
case VIDEOSTANDARD_NTSC:
{
std_id = V4L2_STD_NTSC;
if (-1 == xioctl(VIDIOC_S_STD, &std_id))
{
throw_errno_exception("VIDIOC_S_STD");
return;
}
}
break;
case VIDEOSTANDARD_SECAM:
{
std_id = V4L2_STD_SECAM;
if (-1 == xioctl(VIDIOC_S_STD, &std_id))
{
throw_errno_exception("VIDIOC_S_STD");
return;
}
}
break;
case VIDEOSTANDARD_NO_CHANGE:
default:
// No change to device settings
break;
} }
} }
break;
case VIDEOSTANDARD_NTSC:
{
v4l2_std_id std_id = V4L2_STD_NTSC;
if (-1 == xioctl(VIDIOC_S_STD, &std_id))
{
throw_errno_exception("VIDIOC_S_STD");
return;
}
}
break;
case VIDEOSTANDARD_SECAM:
{
v4l2_std_id std_id = V4L2_STD_SECAM;
if (-1 == xioctl(VIDIOC_S_STD, &std_id))
{
throw_errno_exception("VIDIOC_S_STD");
return;
}
}
break;
case VIDEOSTANDARD_NO_CHANGE:
default:
// No change to device settings
break;
}
// get the current settings // get the current settings
@ -528,12 +556,15 @@ void V4L2Grabber::init_device(VideoStandard videoStandard, int input)
case PIXELFORMAT_UYVY: case PIXELFORMAT_UYVY:
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY; fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
break; break;
case PIXELFORMAT_YUYV: case PIXELFORMAT_YUYV:
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
break; break;
case PIXELFORMAT_RGB32: case PIXELFORMAT_RGB32:
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB32; fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB32;
break; break;
#ifdef HAVE_JPEG #ifdef HAVE_JPEG
case PIXELFORMAT_MJPEG: case PIXELFORMAT_MJPEG:
{ {
@ -542,10 +573,11 @@ void V4L2Grabber::init_device(VideoStandard videoStandard, int input)
} }
break; break;
#endif #endif
case PIXELFORMAT_NO_CHANGE: case PIXELFORMAT_NO_CHANGE:
default: default:
// No change to device settings // No change to device settings
break; break;
} }
// set the settings // set the settings
@ -571,7 +603,7 @@ void V4L2Grabber::init_device(VideoStandard videoStandard, int input)
streamparms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; streamparms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (-1 == xioctl(VIDIOC_G_PARM, &streamparms)) if (-1 == xioctl(VIDIOC_G_PARM, &streamparms))
{ {
throw_errno_exception("VIDIOC_G_PARM"); Debug(_log, "Frame rate settings not supported");
// continue // continue
} }
else else
@ -586,7 +618,7 @@ void V4L2Grabber::init_device(VideoStandard videoStandard, int input)
if(-1 == xioctl(VIDIOC_S_PARM, &streamparms)) if(-1 == xioctl(VIDIOC_S_PARM, &streamparms))
{ {
throw_errno_exception("VIDIOC_S_PARM"); throw_errno_exception("VIDIOC_S_PARM");
return; // continue
} }
} }
} }
@ -604,6 +636,7 @@ void V4L2Grabber::init_device(VideoStandard videoStandard, int input)
Debug(_log, "Pixel format=UYVY"); Debug(_log, "Pixel format=UYVY");
} }
break; break;
case V4L2_PIX_FMT_YUYV: case V4L2_PIX_FMT_YUYV:
{ {
_pixelFormat = PIXELFORMAT_YUYV; _pixelFormat = PIXELFORMAT_YUYV;
@ -611,6 +644,7 @@ void V4L2Grabber::init_device(VideoStandard videoStandard, int input)
Debug(_log, "Pixel format=YUYV"); Debug(_log, "Pixel format=YUYV");
} }
break; break;
case V4L2_PIX_FMT_RGB32: case V4L2_PIX_FMT_RGB32:
{ {
_pixelFormat = PIXELFORMAT_RGB32; _pixelFormat = PIXELFORMAT_RGB32;
@ -618,6 +652,7 @@ void V4L2Grabber::init_device(VideoStandard videoStandard, int input)
Debug(_log, "Pixel format=RGB32"); Debug(_log, "Pixel format=RGB32");
} }
break; break;
#ifdef HAVE_JPEG #ifdef HAVE_JPEG
case V4L2_PIX_FMT_MJPEG: case V4L2_PIX_FMT_MJPEG:
{ {
@ -626,45 +661,56 @@ void V4L2Grabber::init_device(VideoStandard videoStandard, int input)
} }
break; break;
#endif #endif
default: default:
#ifdef HAVE_JPEG
throw_exception("Only pixel formats UYVY, YUYV, RGB32 and MJPEG are supported");
#else
throw_exception("Only pixel formats UYVY, YUYV, and RGB32 are supported"); throw_exception("Only pixel formats UYVY, YUYV, and RGB32 are supported");
#endif
return; return;
} }
switch (_ioMethod) { switch (_ioMethod)
case IO_METHOD_READ: {
init_read(fmt.fmt.pix.sizeimage); case IO_METHOD_READ:
init_read(fmt.fmt.pix.sizeimage);
break; break;
case IO_METHOD_MMAP: case IO_METHOD_MMAP:
init_mmap(); init_mmap();
break; break;
case IO_METHOD_USERPTR: case IO_METHOD_USERPTR:
init_userp(fmt.fmt.pix.sizeimage); init_userp(fmt.fmt.pix.sizeimage);
break; break;
} }
} }
void V4L2Grabber::uninit_device() void V4L2Grabber::uninit_device()
{ {
switch (_ioMethod) { switch (_ioMethod)
case IO_METHOD_READ: {
free(_buffers[0].start); case IO_METHOD_READ:
free(_buffers[0].start);
break; break;
case IO_METHOD_MMAP: case IO_METHOD_MMAP:
for (size_t i = 0; i < _buffers.size(); ++i) {
if (-1 == munmap(_buffers[i].start, _buffers[i].length)) for (size_t i = 0; i < _buffers.size(); ++i)
{ if (-1 == munmap(_buffers[i].start, _buffers[i].length))
throw_errno_exception("munmap"); {
return; throw_errno_exception("munmap");
} return;
}
}
break; break;
case IO_METHOD_USERPTR: case IO_METHOD_USERPTR:
for (size_t i = 0; i < _buffers.size(); ++i) {
free(_buffers[i].start); for (size_t i = 0; i < _buffers.size(); ++i)
free(_buffers[i].start);
}
break; break;
} }
@ -673,61 +719,64 @@ void V4L2Grabber::uninit_device()
void V4L2Grabber::start_capturing() void V4L2Grabber::start_capturing()
{ {
switch (_ioMethod) { switch (_ioMethod)
case IO_METHOD_READ:
/* Nothing to do. */
break;
case IO_METHOD_MMAP:
{ {
for (size_t i = 0; i < _buffers.size(); ++i) { case IO_METHOD_READ:
struct v4l2_buffer buf; /* Nothing to do. */
break;
CLEAR(buf); case IO_METHOD_MMAP:
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; {
buf.memory = V4L2_MEMORY_MMAP; for (size_t i = 0; i < _buffers.size(); ++i)
buf.index = i;
if (-1 == xioctl(VIDIOC_QBUF, &buf))
{ {
throw_errno_exception("VIDIOC_QBUF"); struct v4l2_buffer buf;
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = i;
if (-1 == xioctl(VIDIOC_QBUF, &buf))
{
throw_errno_exception("VIDIOC_QBUF");
return;
}
}
v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (-1 == xioctl(VIDIOC_STREAMON, &type))
{
throw_errno_exception("VIDIOC_STREAMON");
return; return;
} }
break;
} }
v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE; case IO_METHOD_USERPTR:
if (-1 == xioctl(VIDIOC_STREAMON, &type))
{ {
throw_errno_exception("VIDIOC_STREAMON"); for (size_t i = 0; i < _buffers.size(); ++i)
return;
}
break;
}
case IO_METHOD_USERPTR:
{
for (size_t i = 0; i < _buffers.size(); ++i) {
struct v4l2_buffer buf;
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_USERPTR;
buf.index = i;
buf.m.userptr = (unsigned long)_buffers[i].start;
buf.length = _buffers[i].length;
if (-1 == xioctl(VIDIOC_QBUF, &buf))
{ {
throw_errno_exception("VIDIOC_QBUF"); struct v4l2_buffer buf;
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_USERPTR;
buf.index = i;
buf.m.userptr = (unsigned long)_buffers[i].start;
buf.length = _buffers[i].length;
if (-1 == xioctl(VIDIOC_QBUF, &buf))
{
throw_errno_exception("VIDIOC_QBUF");
return;
}
}
v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (-1 == xioctl(VIDIOC_STREAMON, &type))
{
throw_errno_exception("VIDIOC_STREAMON");
return; return;
} }
break;
} }
v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (-1 == xioctl(VIDIOC_STREAMON, &type))
{
throw_errno_exception("VIDIOC_STREAMON");
return;
}
break;
}
} }
} }
@ -735,15 +784,17 @@ void V4L2Grabber::stop_capturing()
{ {
enum v4l2_buf_type type; enum v4l2_buf_type type;
switch (_ioMethod) { switch (_ioMethod)
case IO_METHOD_READ: {
/* Nothing to do. */ case IO_METHOD_READ:
break; break; /* Nothing to do. */
case IO_METHOD_MMAP: case IO_METHOD_MMAP:
case IO_METHOD_USERPTR: case IO_METHOD_USERPTR:
type = V4L2_BUF_TYPE_VIDEO_CAPTURE; {
ErrorIf((xioctl(VIDIOC_STREAMOFF, &type) == -1), _log, "VIDIOC_STREAMOFF error code %d, %s", errno, strerror(errno)); type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
ErrorIf((xioctl(VIDIOC_STREAMOFF, &type) == -1), _log, "VIDIOC_STREAMOFF error code %d, %s", errno, strerror(errno))
}
break; break;
} }
} }
@ -754,108 +805,101 @@ int V4L2Grabber::read_frame()
try try
{ {
struct v4l2_buffer buf; struct v4l2_buffer buf;
switch (_ioMethod) switch (_ioMethod)
{ {
case IO_METHOD_READ: case IO_METHOD_READ:
int size;
if ((size = read(_fileDescriptor, _buffers[0].start, _buffers[0].length)) == -1)
{ {
switch (errno) int size;
if ((size = read(_fileDescriptor, _buffers[0].start, _buffers[0].length)) == -1)
{ {
case EAGAIN: switch (errno)
return 0; {
case EAGAIN:
return 0;
case EIO: case EIO: /* Could ignore EIO, see spec. */
/* Could ignore EIO, see spec. */ default:
throw_errno_exception("read");
/* fall through */ return 0;
}
default:
throw_errno_exception("read");
return 0;
} }
}
rc = process_image(_buffers[0].start, size); rc = process_image(_buffers[0].start, size);
}
break; break;
case IO_METHOD_MMAP: case IO_METHOD_MMAP:
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
if (-1 == xioctl(VIDIOC_DQBUF, &buf))
{ {
switch (errno) CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
if (-1 == xioctl(VIDIOC_DQBUF, &buf))
{ {
case EAGAIN: switch (errno)
return 0; {
case EAGAIN:
return 0;
case EIO: case EIO: /* Could ignore EIO, see spec. */
/* Could ignore EIO, see spec. */ default:
throw_errno_exception("VIDIOC_DQBUF");
return 0;
}
}
/* fall through */ assert(buf.index < _buffers.size());
default: rc = process_image(_buffers[buf.index].start, buf.bytesused);
throw_errno_exception("VIDIOC_DQBUF");
if (-1 == xioctl(VIDIOC_QBUF, &buf))
{
throw_errno_exception("VIDIOC_QBUF");
return 0; return 0;
} }
} }
assert(buf.index < _buffers.size());
rc = process_image(_buffers[buf.index].start, buf.bytesused);
if (-1 == xioctl(VIDIOC_QBUF, &buf))
{
throw_errno_exception("VIDIOC_QBUF");
return 0;
}
break; break;
case IO_METHOD_USERPTR: case IO_METHOD_USERPTR:
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_USERPTR;
if (-1 == xioctl(VIDIOC_DQBUF, &buf))
{ {
switch (errno) CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_USERPTR;
if (-1 == xioctl(VIDIOC_DQBUF, &buf))
{ {
case EAGAIN: switch (errno)
return 0; {
case EAGAIN:
return 0;
case EIO: case EIO: /* Could ignore EIO, see spec. */
/* Could ignore EIO, see spec. */ default:
throw_errno_exception("VIDIOC_DQBUF");
return 0;
}
}
/* fall through */ for (size_t i = 0; i < _buffers.size(); ++i)
{
if (buf.m.userptr == (unsigned long)_buffers[i].start && buf.length == _buffers[i].length)
{
break;
}
}
default: rc = process_image((void *)buf.m.userptr, buf.bytesused);
throw_errno_exception("VIDIOC_DQBUF");
if (-1 == xioctl(VIDIOC_QBUF, &buf))
{
throw_errno_exception("VIDIOC_QBUF");
return 0; return 0;
} }
} }
for (size_t i = 0; i < _buffers.size(); ++i)
{
if (buf.m.userptr == (unsigned long)_buffers[i].start && buf.length == _buffers[i].length)
{
break;
}
}
rc = process_image((void *)buf.m.userptr, buf.bytesused);
if (-1 == xioctl(VIDIOC_QBUF, &buf))
{
throw_errno_exception("VIDIOC_QBUF");
return 0;
}
break; break;
} }
} }
@ -1052,16 +1096,6 @@ int V4L2Grabber::xioctl(int request, void *arg)
return r; return r;
} }
void V4L2Grabber::throw_exception(const QString & error)
{
Error(_log, "Throws error: %s", QSTRING_CSTR(error));
}
void V4L2Grabber::throw_errno_exception(const QString & error)
{
Error(_log, "Throws error nr: %s", QSTRING_CSTR(QString(error + " error code " + QString::number(errno) + ", " + strerror(errno))));
}
void V4L2Grabber::setSignalDetectionEnable(bool enable) void V4L2Grabber::setSignalDetectionEnable(bool enable)
{ {
if (_signalDetectionEnabled != enable) if (_signalDetectionEnabled != enable)
@ -1071,11 +1105,6 @@ void V4L2Grabber::setSignalDetectionEnable(bool enable)
} }
} }
bool V4L2Grabber::getSignalDetectionEnabled()
{
return _signalDetectionEnabled;
}
void V4L2Grabber::setPixelDecimation(int pixelDecimation) void V4L2Grabber::setPixelDecimation(int pixelDecimation)
{ {
if (_pixelDecimation != pixelDecimation) if (_pixelDecimation != pixelDecimation)
@ -1094,17 +1123,16 @@ void V4L2Grabber::setDeviceVideoStandard(QString device, VideoStandard videoStan
QChar input = device.at(device.size() - 1); QChar input = device.at(device.size() - 1);
_input = input.isNumber() ? input.digitValue() : -1; _input = input.isNumber() ? input.digitValue() : -1;
bool started = _initialized;
uninit(); uninit();
_deviceName = device; _deviceName = device;
_videoStandard = videoStandard; _videoStandard = videoStandard;
// // start if init is a success if(started) start();
// if(init())
// start();
} }
} }
void V4L2Grabber::componentStateChanged(const hyperion::Components component, bool enable) void V4L2Grabber::componentStateChanged(const Components component, bool enable)
{ {
if (component == COMP_V4L) if (component == COMP_V4L)
{ {