You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
751 lines
18 KiB
751 lines
18 KiB
/***************************************************************************************
|
|
*
|
|
* videodev.cc is part of SimpleSkyCam.
|
|
*
|
|
*****************************************************************************************/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/time.h>
|
|
#include <errno.h>
|
|
#include <getopt.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include <list>
|
|
#include <string>
|
|
|
|
#include "gui.h"
|
|
#include "video.h"
|
|
|
|
#define CLEAR(x) memset (&(x), 0, sizeof (x))
|
|
|
|
//
|
|
// C / C++ Wrapper
|
|
gpointer _VideoDevThread (gpointer data) {
|
|
videodev.Thread ();
|
|
return NULL;
|
|
};
|
|
|
|
|
|
|
|
VideoDev::VideoDev() {
|
|
inbuffers = NULL;
|
|
inbuffers_cnt = 0;
|
|
running = 0;
|
|
callback = NULL;
|
|
thread = NULL;
|
|
fd = -1;
|
|
io = IOMODE_MMAP;
|
|
CLEAR(cropcap);
|
|
CLEAR(crop);
|
|
CLEAR(fmt);
|
|
g_mutex_init (&mutex);
|
|
Close(); // will reset almost everything
|
|
};
|
|
|
|
|
|
VideoDev::~VideoDev() {
|
|
Stop();
|
|
}
|
|
|
|
|
|
//
|
|
// return list of devices in form of /dev/videoYY [Name]
|
|
int VideoDev::GetDeviceList(std::list<std::string> *list) {
|
|
std::string device;
|
|
int devnum;
|
|
|
|
if (list == NULL) return 0;
|
|
|
|
list->clear();
|
|
for (devnum = 0; devnum < 255; devnum++) {
|
|
device = "/dev/video"+std::to_string(devnum);
|
|
|
|
if (device.compare (conf_device) != 0) {
|
|
int fd;
|
|
struct v4l2_capability vcap;
|
|
|
|
if((fd = open(device.c_str(), O_RDONLY)) == -1){
|
|
continue;
|
|
}
|
|
|
|
if(ioctl(fd, VIDIOC_QUERYCAP, &vcap) == -1)
|
|
strncpy ((char*)&vcap.card, "unknown", sizeof(vcap.card));
|
|
close(fd);
|
|
device += " [" + (std::string) ((char*)vcap.card) + "]";
|
|
}
|
|
else {
|
|
device += " [" + (std::string) conf_devicename + "]";
|
|
}
|
|
|
|
list->push_back(device);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
//
|
|
// start the video thread (on error, call cb_thread_videodev with NULL data)
|
|
int VideoDev::Start(std::string dev, gboolean (*callback_func)(gpointer data)) {
|
|
if (running != 0 || thread != NULL) return VDEV_STATUS_ERROR;
|
|
|
|
running = 1;
|
|
conf_device = dev;
|
|
callback = callback_func;
|
|
thread = g_thread_new("network thread", _VideoDevThread, NULL);
|
|
|
|
return VDEV_STATUS_ERROR;
|
|
};
|
|
|
|
|
|
int VideoDev::Stop() {
|
|
if (running == 1) {
|
|
running = 0;
|
|
}
|
|
|
|
if (thread) {
|
|
g_thread_join (thread);
|
|
thread = NULL;
|
|
}
|
|
|
|
return VDEV_STATUS_OK;
|
|
};
|
|
|
|
|
|
//
|
|
// try to read a video every 0.05ms (25hz)
|
|
#define CYCLETIME 0.050
|
|
void VideoDev::Thread() {
|
|
struct timeval cycle_timestamp;
|
|
int lastsec = 0;
|
|
float cycle_time, cycle_wait;
|
|
int i;
|
|
fd_set fds;
|
|
struct timeval tv;
|
|
|
|
printf ("%s:%d %s Enter\n", __FILE__, __LINE__, __FUNCTION__);
|
|
cycle_time = get_cycletime(&cycle_timestamp); // just start counting
|
|
|
|
//
|
|
// open and init device buffers device
|
|
if (OpenInit() != VDEV_STATUS_OK) {
|
|
printf ("%s:%d %s something went wrong on Open()\n", __FILE__, __LINE__, __FUNCTION__);
|
|
running = 0;
|
|
}
|
|
|
|
//
|
|
// start capturing
|
|
CaptureStart();
|
|
|
|
//
|
|
// read untill something bad happens..
|
|
while (running > 0) {
|
|
//
|
|
// read data
|
|
g_mutex_lock(&mutex);
|
|
if (vf_rec == -1) vf_rec = 0;
|
|
if (vf_rec != vf_get) {
|
|
g_mutex_unlock(&mutex);
|
|
|
|
FD_ZERO (&fds);
|
|
FD_SET (fd, &fds);
|
|
tv.tv_sec = 2;
|
|
tv.tv_usec = 0;
|
|
i = select (fd + 1, &fds, NULL, NULL, &tv);
|
|
|
|
/* error while select */
|
|
if (i == -1 && EINTR == errno) // system interrupt. something went wrong
|
|
running = 0;
|
|
else if (i == 1) {
|
|
switch (Grab()) {
|
|
case VDEV_STATUS_OK:
|
|
// got valid data
|
|
g_mutex_lock(&mutex);
|
|
if (vf_get == -1) vf_get = vf_rec;
|
|
if ((++vf_rec) >= VIDEOBUFFERS) vf_rec = 0;
|
|
if (callback) gdk_threads_add_idle(callback, (void*)VDEV_CBSTATUS_NEWFRAME);
|
|
g_mutex_unlock(&mutex);
|
|
break;
|
|
|
|
case VDEV_STATUS_AGAIN:
|
|
break;
|
|
|
|
default:
|
|
running = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
g_mutex_unlock(&mutex);
|
|
|
|
//
|
|
// keep 25fps, write every second a message
|
|
cycle_time = get_cycletime(&cycle_timestamp);
|
|
cycle_wait = (CYCLETIME - cycle_time) + cycle_wait;
|
|
if (lastsec != cycle_timestamp.tv_sec) {
|
|
printf ("%s:%d %s cycle_time:%f \r", __FILE__, __LINE__, __FUNCTION__, cycle_time);
|
|
lastsec = cycle_timestamp.tv_sec;
|
|
}
|
|
if (cycle_wait > 0.0 && cycle_wait < 1.0 ) usleep ((int)(cycle_wait * 1000000.0));
|
|
}
|
|
|
|
//
|
|
// stop capturing
|
|
CaptureStop();
|
|
UnInit();
|
|
|
|
if (callback) gdk_threads_add_idle(callback, NULL);
|
|
Close();
|
|
|
|
printf ("%s:%d %s Exit\n", __FILE__, __LINE__, __FUNCTION__);
|
|
};
|
|
|
|
|
|
void VideoDev::PrintCaps(uint32_t caps) {
|
|
printf ("%s:%d %s Caps: %x\n", __FILE__, __LINE__, __FUNCTION__, caps);
|
|
|
|
if (caps & V4L2_CAP_VIDEO_CAPTURE) printf (" V4L2_CAP_VIDEO_CAPTURE\n");
|
|
if (caps & V4L2_CAP_EXT_PIX_FORMAT) printf (" V4L2_CAP_EXT_PIX_FORMAT\n");
|
|
if (caps & V4L2_CAP_META_CAPTURE) printf (" V4L2_CAP_META_CAPTURE\n");
|
|
if (caps & V4L2_CAP_STREAMING) printf (" V4L2_CAP_STREAMING\n");
|
|
if (caps & V4L2_CAP_DEVICE_CAPS) printf (" V4L2_CAP_DEVICE_CAPS\n");
|
|
if (caps & V4L2_CAP_TUNER) printf (" V4L2_CAP_TUNER\n");
|
|
if (caps & V4L2_CAP_MODULATOR) printf (" V4L2_CAP_MODULATOR\n");
|
|
if (caps & V4L2_CAP_READWRITE) printf (" V4L2_CAP_READWRITE\n");
|
|
if (caps & V4L2_CAP_ASYNCIO) printf (" V4L2_CAP_ASYNCIO\n");
|
|
}
|
|
|
|
|
|
void VideoDev::PrintFmt(struct v4l2_format *f) {
|
|
printf ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
|
|
printf (" type : %u\n", f->type);
|
|
printf (" fmt.pix.width : %d\n", f->fmt.pix.width);
|
|
printf (" fmt.pix.height : %d\n", f->fmt.pix.height);
|
|
printf (" fmt.fmt.pix.pixelformat : %c%c%c%c\n", ((char*)&fmt.fmt.pix.pixelformat)[0],
|
|
((char*)&fmt.fmt.pix.pixelformat)[1],
|
|
((char*)&fmt.fmt.pix.pixelformat)[2],
|
|
((char*)&fmt.fmt.pix.pixelformat)[3]);
|
|
printf (" fmt.pix.field : %d\n", f->fmt.pix.field);
|
|
printf (" fmt.pix.bytesperline : %d\n", f->fmt.pix.bytesperline);
|
|
printf (" fmt.pix.sizeimage : %d\n", f->fmt.pix.sizeimage);
|
|
}
|
|
|
|
|
|
|
|
int VideoDev::Grab() {
|
|
unsigned int i;
|
|
struct v4l2_buffer buf;
|
|
|
|
if (vf_rec < 0 || vf_rec >= VIDEOBUFFERS) return VDEV_CBSTATUS_NOTHING;
|
|
|
|
switch (io) {
|
|
case IOMODE_READ:
|
|
if (-1 == read (fd, vf[vf_rec].data, fmt.fmt.pix.sizeimage)) {
|
|
switch (errno) {
|
|
case EAGAIN:
|
|
return VDEV_STATUS_AGAIN;
|
|
case EIO:
|
|
default:
|
|
printf ("v4l2_grab IOM_READ: %s dest:%p size:%d\n", strerror (errno), vf[vf_rec].data, fmt.fmt.pix.sizeimage);
|
|
return VDEV_STATUS_ERROR;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IOMODE_MMAP:
|
|
CLEAR(buf);
|
|
|
|
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
buf.memory = V4L2_MEMORY_MMAP;
|
|
|
|
if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {
|
|
switch (errno) {
|
|
case EAGAIN:
|
|
return VDEV_CBSTATUS_NOTHING;
|
|
|
|
case EIO:
|
|
/* Could ignore EIO, see spec. */
|
|
/* fall through */
|
|
default:
|
|
printf ( "%s:%d error on VIDIOC_DQBUF %s\n", __FILE__, __LINE__, strerror(errno));
|
|
return VDEV_CBSTATUS_ERROR;
|
|
}
|
|
}
|
|
|
|
if (buf.index < inbuffers_cnt) {
|
|
memcpy (vf[vf_rec].data, inbuffers[buf.index].data, buf.bytesused);
|
|
vf[vf_rec].size = buf.bytesused;
|
|
}
|
|
|
|
if (-1 == xioctl(fd, VIDIOC_QBUF, &buf)) {
|
|
printf ( "%s:%d error on VIDIOC_QBUF %s\n", __FILE__, __LINE__, strerror(errno));
|
|
exit (1);
|
|
}
|
|
break;
|
|
|
|
case IOMODE_USERPTR:
|
|
CLEAR(buf);
|
|
|
|
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
buf.memory = V4L2_MEMORY_USERPTR;
|
|
|
|
if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {
|
|
switch (errno) {
|
|
case EAGAIN:
|
|
return VDEV_CBSTATUS_NOTHING;
|
|
|
|
case EIO:
|
|
/* Could ignore EIO, see spec. */
|
|
/* fall through */
|
|
default:
|
|
printf ( "%s:%d error on VIDIOC_DQBUF %s\n", __FILE__, __LINE__, strerror(errno));
|
|
exit (1);
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < inbuffers_cnt; ++i)
|
|
if (buf.m.userptr == (unsigned long)inbuffers[i].data && buf.length == inbuffers[i].size)
|
|
break;
|
|
|
|
if (i < inbuffers_cnt) {
|
|
memcpy (vf[vf_rec].data, inbuffers[buf.index].data, buf.bytesused);
|
|
vf[vf_rec].size = buf.bytesused;
|
|
}
|
|
|
|
if (-1 == xioctl(fd, VIDIOC_QBUF, &buf)) {
|
|
printf ( "%s:%d error on VIDIOC_QBUF %s\n", __FILE__, __LINE__, strerror(errno));
|
|
exit (1);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return VDEV_STATUS_OK;
|
|
}
|
|
|
|
//
|
|
// Open Device
|
|
int VideoDev::OpenInit() {
|
|
int i;
|
|
struct v4l2_capability vcap;
|
|
|
|
printf ("%s:%d %s Device: '%s'\n", __FILE__, __LINE__, __FUNCTION__, conf_device.c_str());
|
|
if (fd != -1) return VDEV_STATUS_ERROR;
|
|
|
|
//
|
|
// open device and get device name and capabilities
|
|
if((fd = open(conf_device.c_str(), O_RDWR | O_NONBLOCK)) == -1){
|
|
return VDEV_STATUS_ERROR;
|
|
}
|
|
|
|
if(ioctl(fd, VIDIOC_QUERYCAP, &vcap) == -1)
|
|
strncpy ((char*)&vcap.card, "unknown", sizeof(vcap.card));
|
|
conf_devicename = (char*) vcap.card;
|
|
|
|
printf ("%s:%d %s Capabilities: %u\n", __FILE__, __LINE__, __FUNCTION__, vcap.capabilities);
|
|
PrintCaps(vcap.capabilities);
|
|
printf ("%s:%d %s Device Capabilities: %u\n", __FILE__, __LINE__, __FUNCTION__, vcap.device_caps);
|
|
PrintCaps(vcap.device_caps);
|
|
|
|
if (!(vcap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
|
|
printf ("%s:%d %s device has no video capture capabilities\n", __FILE__, __LINE__, __FUNCTION__);
|
|
return VDEV_STATUS_ERROR;
|
|
Close();
|
|
}
|
|
|
|
//
|
|
// query controls
|
|
struct v4l2_queryctrl queryctrl;
|
|
struct v4l2_control control;
|
|
uint32_t min;
|
|
|
|
printf (" Controls: \n");
|
|
memset (&queryctrl, 0, sizeof (queryctrl));
|
|
for (i = V4L2_CID_BASE; i < V4L2_CID_LASTP1; i++) {
|
|
queryctrl.id = i;
|
|
if (0 == ioctl (fd, VIDIOC_QUERYCTRL, &queryctrl)) {
|
|
if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED)
|
|
printf (" *");
|
|
|
|
memset (&control, 0, sizeof (control));
|
|
control.id = i;
|
|
ioctl (fd, VIDIOC_G_CTRL, &control);
|
|
printf (" [%d] %s:%d\n", i, queryctrl.name, control.value);
|
|
}
|
|
}
|
|
printf ("\n Private Controls: ");
|
|
for (i = V4L2_CID_PRIVATE_BASE;; i++) {
|
|
queryctrl.id = i;
|
|
if (0 == ioctl (fd, VIDIOC_QUERYCTRL, &queryctrl)) {
|
|
printf (" [%d] %s\n", i, queryctrl.name);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
printf ("\n");
|
|
|
|
//
|
|
// check for cropping.. if we have it setup default
|
|
CLEAR (cropcap);
|
|
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
|
|
if (0 == xioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
|
|
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
crop.c = cropcap.defrect; // reset to default
|
|
|
|
if (-1 == xioctl (fd, VIDIOC_S_CROP, &crop)) {
|
|
printf ("%s:%d %s VIDEOC_S_CROP Errorcode: %s\n", __FILE__, __LINE__, __FUNCTION__, strerror(errno));
|
|
}
|
|
}
|
|
printf (" max image size: %d + %d : %d x %d fmt size:%d\n", cropcap.defrect.left, cropcap.defrect.top, cropcap.defrect.width, cropcap.defrect.height, fmt.fmt.pix.sizeimage);
|
|
|
|
CLEAR (fmt);
|
|
|
|
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
fmt.fmt.pix.width = cropcap.defrect.width;
|
|
fmt.fmt.pix.height = cropcap.defrect.height;
|
|
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB32;
|
|
fmt.fmt.pix.field = V4L2_FIELD_NONE;
|
|
|
|
if (-1 == xioctl (fd, VIDIOC_S_FMT, &fmt)) {
|
|
fprintf (stderr, "VIDIOC_S_FMT : %s", strerror (errno));
|
|
return VDEV_STATUS_ERROR;
|
|
}
|
|
|
|
// Note VIDIOC_S_FMT may change width and height.
|
|
// Buggy driver paranoia. - as written in the v4l2 api documentation
|
|
min = fmt.fmt.pix.width * 2;
|
|
if (fmt.fmt.pix.bytesperline < min)
|
|
fmt.fmt.pix.bytesperline = min;
|
|
min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
|
|
if (fmt.fmt.pix.sizeimage < min)
|
|
fmt.fmt.pix.sizeimage = min;
|
|
PrintFmt (&fmt);
|
|
|
|
// allocate buffers for readin from other threads
|
|
for (i = 0; i < VIDEOBUFFERS; i++) {
|
|
vf[i].maxsize = fmt.fmt.pix.sizeimage;
|
|
vf[i].size = fmt.fmt.pix.sizeimage;
|
|
vf[i].format = fmt.fmt.pix.pixelformat;
|
|
vf[i].h = fmt.fmt.pix.height;
|
|
vf[i].w = fmt.fmt.pix.width;
|
|
vf[i].data = (unsigned char*) malloc (vf[i].size);
|
|
}
|
|
|
|
// init buffers
|
|
switch (io) {
|
|
case IOMODE_MMAP:
|
|
if (InitMMap() == VDEV_STATUS_ERROR)
|
|
Close();
|
|
break;
|
|
case IOMODE_USERPTR:
|
|
if (InitUserPtr() == VDEV_STATUS_ERROR)
|
|
Close();
|
|
break;
|
|
case IOMODE_READ:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return VDEV_STATUS_OK;
|
|
};
|
|
|
|
|
|
//
|
|
// prepare memory mapped buffers
|
|
int VideoDev::InitMMap() {
|
|
struct v4l2_requestbuffers req;
|
|
printf ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
|
|
|
|
CLEAR(req);
|
|
|
|
req.count = 4;
|
|
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
req.memory = V4L2_MEMORY_MMAP;
|
|
|
|
if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {
|
|
if (EINVAL == errno) {
|
|
printf("%s does not support "
|
|
"memory mappingn", conf_device.c_str());
|
|
return VDEV_STATUS_ERROR;
|
|
} else {
|
|
printf ("%s:%d %s Error %s\n", __FILE__, __LINE__, __FUNCTION__, strerror(errno));
|
|
return VDEV_STATUS_ERROR;
|
|
}
|
|
}
|
|
|
|
if (req.count < 2) {
|
|
printf ( "Insufficient buffer memory on %s\n", conf_device.c_str());
|
|
return VDEV_STATUS_ERROR;
|
|
}
|
|
|
|
inbuffers = (VideoInBuffer*) calloc(req.count, sizeof(*inbuffers));
|
|
if (!inbuffers) {
|
|
fprintf(stderr, "Out of memory\\n");
|
|
exit(1);
|
|
}
|
|
|
|
for (inbuffers_cnt = 0; inbuffers_cnt < req.count; ++inbuffers_cnt) {
|
|
struct v4l2_buffer buf;
|
|
|
|
CLEAR(buf);
|
|
|
|
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
buf.memory = V4L2_MEMORY_MMAP;
|
|
buf.index = inbuffers_cnt;
|
|
|
|
if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &buf)) {
|
|
printf ( "%s:%d Insufficient buffer memory on %s\n", __FILE__, __LINE__, conf_device.c_str());
|
|
exit (1);
|
|
}
|
|
|
|
inbuffers[inbuffers_cnt].size = buf.length;
|
|
inbuffers[inbuffers_cnt].data = (unsigned char*)mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.offset);
|
|
|
|
if (MAP_FAILED == inbuffers[inbuffers_cnt].data) {
|
|
printf ( "%s:%d error on mmap %s\n", __FILE__, __LINE__, strerror(errno));
|
|
exit (1);
|
|
}
|
|
}
|
|
|
|
return VDEV_STATUS_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// prepare memory mapped buffers
|
|
int VideoDev::InitUserPtr() {
|
|
struct v4l2_requestbuffers req;
|
|
printf ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
|
|
|
|
CLEAR(req);
|
|
|
|
req.count = 4;
|
|
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
req.memory = V4L2_MEMORY_USERPTR;
|
|
|
|
if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {
|
|
if (EINVAL == errno) {
|
|
printf("%s does not support "
|
|
"memory mappingn", conf_device.c_str());
|
|
return VDEV_STATUS_ERROR;
|
|
} else {
|
|
printf ( "%s:%d error on UserPtr %s\n", __FILE__, __LINE__, strerror(errno));
|
|
exit (1);
|
|
}
|
|
}
|
|
|
|
inbuffers = (VideoInBuffer*)calloc(4, sizeof(*inbuffers));
|
|
|
|
if (!inbuffers) {
|
|
fprintf(stderr, "Out of memory\\n");
|
|
exit(1);
|
|
}
|
|
|
|
for (inbuffers_cnt = 0; inbuffers_cnt < 4; ++inbuffers_cnt) {
|
|
inbuffers[inbuffers_cnt].size = vf[0].maxsize;
|
|
inbuffers[inbuffers_cnt].data = (unsigned char*)malloc(inbuffers[inbuffers_cnt].size);
|
|
|
|
if (!inbuffers[inbuffers_cnt].data) {
|
|
fprintf(stderr, "Out of memory\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
return VDEV_STATUS_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// send the start capture signal to the cam
|
|
int VideoDev::CaptureStart() {
|
|
unsigned int i;
|
|
enum v4l2_buf_type type;
|
|
printf ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
|
|
|
|
switch (io) {
|
|
case IOMODE_READ:
|
|
/* Nothing to do. */
|
|
break;
|
|
|
|
case IOMODE_MMAP:
|
|
for (i = 0; i < inbuffers_cnt; ++i) {
|
|
struct v4l2_buffer buf;
|
|
|
|
CLEAR(buf);
|
|
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
buf.memory = V4L2_MEMORY_MMAP;
|
|
buf.index = i;
|
|
|
|
if (-1 == xioctl(fd, VIDIOC_QBUF, &buf)) {
|
|
printf ( "%s:%d VIDIOC_QBUF %s\n", __FILE__, __LINE__, strerror(errno));
|
|
return VDEV_STATUS_ERROR;
|
|
}
|
|
}
|
|
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
if (-1 == xioctl(fd, VIDIOC_STREAMON, &type)) {
|
|
printf ( "%s:%d VIDIOC_STREAMON %s\n", __FILE__, __LINE__, strerror(errno));
|
|
return VDEV_STATUS_ERROR;
|
|
}
|
|
break;
|
|
|
|
case IOMODE_USERPTR:
|
|
for (i = 0; i < inbuffers_cnt; ++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)inbuffers[i].data;
|
|
buf.length = inbuffers[i].size;
|
|
|
|
if (-1 == xioctl(fd, VIDIOC_QBUF, &buf)) {
|
|
printf ( "%s:%d VIDIOC_QBUF %s\n", __FILE__, __LINE__, strerror(errno));
|
|
return VDEV_STATUS_ERROR;
|
|
}
|
|
}
|
|
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
if (-1 == xioctl(fd, VIDIOC_STREAMON, &type)) {
|
|
printf ( "%s:%d VIDIOC_STREAMON %s\n", __FILE__, __LINE__, strerror(errno));
|
|
return VDEV_STATUS_ERROR;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return VDEV_STATUS_OK;
|
|
};
|
|
|
|
|
|
int VideoDev::CaptureStop() {
|
|
enum v4l2_buf_type type;
|
|
printf ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
|
|
|
|
switch (io) {
|
|
case IOMODE_READ:
|
|
/* Nothing to do. */
|
|
break;
|
|
|
|
case IOMODE_MMAP:
|
|
case IOMODE_USERPTR:
|
|
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &type)) {
|
|
fprintf(stderr, "%s:%d VIDIOC_STREAMOFF Error:%s\n", __FILE__, __LINE__, strerror(errno));
|
|
return VDEV_STATUS_ERROR;
|
|
}
|
|
break;
|
|
}
|
|
return VDEV_STATUS_OK;
|
|
};
|
|
|
|
|
|
int VideoDev::UnInit() {
|
|
unsigned int i;
|
|
printf ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
|
|
|
|
switch (io) {
|
|
case IOMODE_READ:
|
|
break;
|
|
|
|
case IOMODE_MMAP:
|
|
for (i = 0; i < inbuffers_cnt; ++i)
|
|
if (-1 == munmap(inbuffers[i].data, inbuffers[i].size)){
|
|
fprintf(stderr, "Fatal Error @ %s:%d munmap Error:%s\n", __FILE__, __LINE__, strerror(errno));
|
|
exit(1);
|
|
}
|
|
break;
|
|
|
|
case IOMODE_USERPTR:
|
|
for (i = 0; i < inbuffers_cnt; ++i)
|
|
free(inbuffers[i].data);
|
|
break;
|
|
}
|
|
|
|
free(inbuffers);
|
|
inbuffers = NULL;
|
|
inbuffers_cnt = 0;
|
|
return VDEV_STATUS_OK;
|
|
};
|
|
|
|
|
|
//
|
|
// Close Device
|
|
// Free videobuffer
|
|
int VideoDev::Close() {
|
|
printf ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
|
|
|
|
if (fd >= 0) {
|
|
close (fd);
|
|
fd = -1;
|
|
}
|
|
|
|
conf_device = "";
|
|
conf_devicename = "";
|
|
|
|
vf_rec = -1;
|
|
vf_get = -1;
|
|
for (int i = 0; i < VIDEOBUFFERS; i++) {
|
|
vf[i].data = NULL;
|
|
vf[i].w = 0;
|
|
vf[i].h = 0;
|
|
vf[i].size = 0;
|
|
vf[i].format = 0;
|
|
}
|
|
|
|
return VDEV_STATUS_OK;
|
|
};
|
|
|
|
|
|
//
|
|
// get current frame, if no new frame is avaiable return NULL
|
|
VideoFrame *VideoDev::FrameGet() {
|
|
VideoFrame *res = NULL;
|
|
|
|
g_mutex_lock(&mutex);
|
|
if (vf_get != -1)
|
|
res = &vf[vf_get];
|
|
g_mutex_unlock(&mutex);
|
|
|
|
return res;
|
|
};
|
|
|
|
|
|
//
|
|
// release frame, and prepare next frame
|
|
void VideoDev::FrameNext() {
|
|
g_mutex_lock(&mutex);
|
|
vf_get++;
|
|
if (vf_get >= VIDEOBUFFERS) vf_get = 0;
|
|
if (vf_get == vf_rec) vf_get = -1;
|
|
g_mutex_unlock(&mutex);
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// try to send ioctl command as long as EINTR is valid. But abort after 2 seconds.
|
|
int VideoDev::xioctl(int fd, int request, void *arg) {
|
|
int r;
|
|
int errnoioctl;
|
|
struct timeval to1;
|
|
struct timeval to2;
|
|
float to;
|
|
|
|
gettimeofday(&to1, NULL);
|
|
do {
|
|
r = ioctl(fd, request, arg);
|
|
errnoioctl = errno;
|
|
gettimeofday(&to2, NULL);
|
|
to = (float)(to2.tv_sec - to1.tv_sec) + ((to2.tv_usec - to1.tv_usec) / 1000000.0);
|
|
} while (r == -1 && errnoioctl == EINTR && to < 2.0);
|
|
|
|
return r;
|
|
};
|
|
|