bool
VideoCapture::frameCapture(void)
{
#if defined(DUNE_SYS_HAS_LIBV4L2_H)
fd_set fds;
timeval tv;
int rv = 0;
do
{
FD_ZERO(&fds);
FD_SET(m_fd, &fds);
tv.tv_sec = 1;
tv.tv_usec = 0;
rv = select(m_fd + 1, &fds, NULL, NULL, &tv);
}
while ((rv == -1 && (errno = EINTR)));
doIoctl(m_fd, VIDIOC_QBUF, m_bfr);
std::memset(m_bfr, 0, sizeof(v4l2_buffer));
m_bfr->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
m_bfr->memory = V4L2_MEMORY_MMAP;
doIoctl(m_fd, VIDIOC_DQBUF, m_bfr);
return true;
#else
return false;
#endif
}
void
VideoCapture::start(void)
{
#if defined(DUNE_SYS_HAS_LIBV4L2_H)
v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
doIoctl(m_fd, VIDIOC_STREAMON, &type);
// Read one frame to allow for captureFrame() to enqueue/deque
// buffers in one run.
std::memset(m_bfr, 0, sizeof(v4l2_buffer));
m_bfr->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
m_bfr->memory = V4L2_MEMORY_MMAP;
doIoctl(m_fd, VIDIOC_DQBUF, m_bfr);
#endif
}
void
VideoCapture::setStandard(VideoCapture::Standard standard)
{
(void)standard;
#if defined(DUNE_SYS_HAS_LIBV4L2_H)
v4l2_std_id id = 0;
switch (standard)
{
case STANDARD_PAL:
id = V4L2_STD_PAL;
break;
case STANDARD_NTSC:
id = V4L2_STD_NTSC;
break;
}
if (id & (1ULL << 63))
{
struct v4l2_standard vs;
vs.index = id & 0xffff;
if (testIoctl(m_fd, VIDIOC_ENUMSTD, &vs) >= 0)
id = vs.id;
}
doIoctl(m_fd, VIDIOC_S_STD, &id);
#endif
}
//const int TMrfTal_RB::doReadout(TMrfData& data, const u_int32_t& wordcount, u_int8_t* const startaddress)
int TMrfTal_RBUDP::doReadout(const u_int32_t& wordcount, u_int8_t* const startaddress) const
{
if (deviceIsOpen()) {
udpRequest req;
req.dataFlag = udpDataFlag::bulkRead;
req.registerAddress = rb_address::ident;
req.memoryAddress = (char*)startaddress;
req.wordcount = wordcount;
// deal with the UDP request
doIoctl(req.dataFlag, &req);
if ( !lastActionSuccessful() ) {
rb_errcode |= rb_error::doreadout_failed;
return -1;
}
// If the DAQ buffer is empty, 0xeeeeeeee is returned. Check for that...
if ( *(u_int32_t*)(req.memoryAddress) == 0xeeeeeeee && req.wordcount == 1 )
req.wordcount = 0;
return req.wordcount;
} else {
rb_errcode |= rb_error::device_not_open;
return -2;
}
}
//const int TMrfTal_RB::doReadout(TMrfData& data, const u_int32_t& wordcount, u_int8_t* const startaddress)
int TMrfTal_RBBase::doReadout(const u_int32_t& wordcount, u_int8_t* const startaddress) const
{
if (deviceIsOpen()) {
sis1100_vme_block_req req;
req.size=4;
req.fifo=1;
req.num=wordcount;
req.am=-1;
req.addr=rb_address::ident;
req.data = startaddress;
req.error=0;
doIoctl(SIS3100_VME_BLOCK_READ, &req);
if (!(lastActionSuccessful())) {
rb_errcode |= rb_error::doreadout_failed;
return -1;
}
switch (req.error) {
case sis_magic::nomoredata: /* normal case, more data requested than available */
rb_errcode = 0;
break;
case sis_magic::success: /* not enough data requested */
rb_errcode |= rb_error::more_data_available;
break;
default:
rb_errcode |= rb_error::doreadout_failed;
std::cerr << "Block Read FAIL: " << std::hex << req.error << std::dec << std::endl;
return -1;
}
return req.num;
} else {
rb_errcode |= rb_error::device_not_open;
return -2;
}
}
void
VideoCapture::stop(void)
{
#if defined(DUNE_SYS_HAS_LIBV4L2_H)
v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
doIoctl(m_fd, VIDIOC_STREAMOFF, &type);
#endif
}
int TMrfTal_RBBase::initReadout() const
{
if (deviceIsOpen()) {
int len[2]={1, 1};
doIoctl(SIS1100_MINDMALEN, len);
if (lastActionSuccessful()) {
rb_errcode = 0;
return 0;
} else {
rb_errcode |= rb_error::initreadout_failed;
return -1;
}
} else {
rb_errcode |= rb_error::device_not_open;
return -2;
}
}
static jbyteArray NetworkInterface_getHardwareAddressImpl(JNIEnv* env, jclass, jstring name) {
ifreq ifr;
if (!doIoctl(env, name, SIOCGIFHWADDR, ifr)) {
return NULL;
}
jbyte bytes[IFHWADDRLEN];
bool isEmpty = true;
for (int i = 0; i < IFHWADDRLEN; ++i) {
bytes[i] = ifr.ifr_hwaddr.sa_data[i];
if (bytes[i] != 0) {
isEmpty = false;
}
}
if (isEmpty) {
return NULL;
}
jbyteArray result = env->NewByteArray(IFHWADDRLEN);
env->SetByteArrayRegion(result, 0, IFHWADDRLEN, bytes);
return result;
}
VideoCapture::VideoCapture(const std::string& dev, uint32_t w, uint32_t h)
{
// Video 4 Linux library implementation.
#if defined(DUNE_SYS_HAS_LIBV4L2_H)
m_fd = v4l2_open(dev.c_str(), O_RDWR | O_NONBLOCK, 0);
if (m_fd < 0)
throw Error(errno, String::str("failed to open device '%s'", dev.c_str()));
// Initialize V4L2 format.
m_fmt = new v4l2_format;
std::memset(m_fmt, 0, sizeof(v4l2_format));
m_fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
m_fmt->fmt.pix.width = w;
m_fmt->fmt.pix.height = h;
m_fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24;
m_fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
doIoctl(m_fd, VIDIOC_S_FMT, m_fmt);
if (m_fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_RGB24)
throw std::runtime_error("pixel format RGB24 is not supported by device");
// Initialize V4L2 request buffers.
m_bfr_req = new v4l2_requestbuffers;
std::memset(m_bfr_req, 0, sizeof(v4l2_requestbuffers));
m_bfr_req->count = 2;
m_bfr_req->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
m_bfr_req->memory = V4L2_MEMORY_MMAP;
doIoctl(m_fd, VIDIOC_REQBUFS, m_bfr_req);
m_bfr = new v4l2_buffer;
m_bfrs = (Buffer*)calloc(m_bfr_req->count, sizeof(Buffer));
for (unsigned i = 0; i < m_bfr_req->count; ++i)
{
std::memset(m_bfr, 0, sizeof(v4l2_buffer));
m_bfr->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
m_bfr->memory = V4L2_MEMORY_MMAP;
m_bfr->index = i;
doIoctl(m_fd, VIDIOC_QUERYBUF, m_bfr);
m_bfrs[i].length = m_bfr->length;
m_bfrs[i].start = v4l2_mmap(0, m_bfr->length,
PROT_READ | PROT_WRITE, MAP_SHARED,
m_fd, m_bfr->m.offset);
if (MAP_FAILED == m_bfrs[i].start)
{
perror("mmap");
exit(EXIT_FAILURE);
}
std::memset(m_bfr, 0, sizeof(v4l2_buffer));
m_bfr->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
m_bfr->memory = V4L2_MEMORY_MMAP;
m_bfr->index = i;
doIoctl(m_fd, VIDIOC_QBUF, m_bfr);
}
#else
(void)dev;
(void)h;
(void)w;
throw std::runtime_error("VideoCapture is not yet implemented in this system.");
#endif
}
int main()
{
doMalloc();
doIoctl();
return 0;
}
static jint NetworkInterface_getMTUImpl(JNIEnv* env, jclass, jstring name) {
ifreq ifr;
doIoctl(env, name, SIOCGIFMTU, ifr); // May throw.
return ifr.ifr_mtu;
}
static jboolean hasFlag(JNIEnv* env, jstring name, int flag) {
ifreq ifr;
doIoctl(env, name, SIOCGIFFLAGS, ifr); // May throw.
return (ifr.ifr_flags & flag) != 0;
}
