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.
420 lines
9.4 KiB
420 lines
9.4 KiB
|
|
#include "video.h"
|
|
#include "videoframe.h"
|
|
|
|
int convert_debug_fd = -1;
|
|
struct timeval convert_debug_tv;
|
|
|
|
int dumpframe_open(uint32_t pixelformat, int srcw, int srch) {
|
|
time_t t = time(NULL);
|
|
struct tm *tmptr;
|
|
char fname[LEN_FILENAME];
|
|
char fullfname[LEN_FULLFILENAME];
|
|
|
|
printf ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
|
|
if (config.vdev_dumppath.length() == 0) return -1;
|
|
|
|
//
|
|
// check to create file, if not possible try creating the directory and create the file again
|
|
tmptr = localtime(&t);
|
|
strftime(fname, LEN_FILENAME, "%Y%m%d-%H%M%S", tmptr);
|
|
snprintf (fullfname, LEN_FULLFILENAME, "%s/%s.videodump", config.vdev_dumppath.c_str(), fname);
|
|
|
|
if ((convert_debug_fd = creat (fullfname, 0666)) == -1) {
|
|
printf ("%s:%d could not create file '%s'. Error:%s\n", __FILE__, __LINE__, fullfname, strerror(errno));
|
|
printf ("%s:%d try to create folder\n", __FILE__, __LINE__);
|
|
|
|
// create folder
|
|
// FIXME: how to do thin on windows
|
|
#ifdef BUILD_WINDOWS
|
|
if ((mkdir (config.debugpath)) == -1) {
|
|
#else
|
|
if ((mkdir (config.vdev_dumppath.c_str(), 0777)) == -1) {
|
|
#endif
|
|
printf ("%s:%d could not create debug folder.\n", __FILE__, __LINE__);
|
|
return -1;
|
|
}
|
|
if ((convert_debug_fd = creat (fullfname, 0666)) == -1) {
|
|
printf ("%s:%d could again not create file '%s'. Error:%s\n", __FILE__, __LINE__, fullfname, strerror(errno));
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// file is open for writing, write header information
|
|
uint32_t wwidth = htonl(srcw);
|
|
uint32_t wheight = htonl(srch);
|
|
uint32_t wpixfmt = htonl(pixelformat);
|
|
write (convert_debug_fd, &wwidth, 4);
|
|
write (convert_debug_fd, &wheight, 4);
|
|
write (convert_debug_fd, &wpixfmt, 4);
|
|
|
|
//
|
|
// save start time, this is needed to calculate the time between the frames
|
|
gettimeofday (&convert_debug_tv, NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* if fd is not open open file and set up header
|
|
*/
|
|
void dumpframe(unsigned char *ptrsrc, int srcsize, uint32_t pixelformat, int srcw, int srch) {
|
|
struct timeval tv;
|
|
uint32_t wts, ts;
|
|
uint32_t wsize;
|
|
|
|
if (ptrsrc == NULL) return;
|
|
if (config.vdev_dumppath.length() == 0) return;
|
|
if (convert_debug_fd == -1)
|
|
if (dumpframe_open(pixelformat, srcw, srch) == -1) return;
|
|
|
|
//
|
|
// construct and write header
|
|
wsize = htonl(srcsize);
|
|
gettimeofday (&tv, NULL);
|
|
ts = 1000 * (tv.tv_sec - convert_debug_tv.tv_sec) +
|
|
(tv.tv_usec - convert_debug_tv.tv_usec) / 1000;
|
|
wts = htonl(ts);
|
|
|
|
write (convert_debug_fd, &wsize, 4);
|
|
write (convert_debug_fd, &wts, 4);
|
|
|
|
//
|
|
// write frame
|
|
write (convert_debug_fd, ptrsrc, srcsize);
|
|
};
|
|
|
|
|
|
/*
|
|
* close file and reset all data
|
|
*/
|
|
void dumpframe_close() {
|
|
if (convert_debug_fd != -1) {
|
|
close (convert_debug_fd);
|
|
convert_debug_fd = -1;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
VideoDevice_Dump::VideoDevice_Dump() {
|
|
debug ("");
|
|
filesize = 0;
|
|
filepos = 0;
|
|
fd = -1;
|
|
w = 0;
|
|
h = 0;
|
|
pixformat = 0;
|
|
inframe = NULL;
|
|
inframe_size = 0;
|
|
inframe_maxsize = 0;
|
|
inframe_nexttime = 0;
|
|
fixedframesize = 0;
|
|
};
|
|
|
|
|
|
VideoDevice_Dump::~VideoDevice_Dump() {
|
|
debug ("");
|
|
Stop();
|
|
Close();
|
|
};
|
|
|
|
|
|
//
|
|
// Open Device
|
|
// prepare the buffer, InitMMAP and read all controls
|
|
//
|
|
int VideoDevice_Dump::Open() {
|
|
debug ("OPEN");
|
|
if (config.vdev_device == "") return 0;
|
|
|
|
VideoDevCtrl vctl;
|
|
uint32_t inbuf[3];
|
|
int i;
|
|
struct stat s;
|
|
|
|
std::string fname = config.vdev_dumpfile;
|
|
|
|
printf ("%s:%d %s file %s\n", __FILE__, __LINE__, __FUNCTION__, fname.c_str());
|
|
|
|
if (fd >= 0) close (fd);
|
|
fd = -1;
|
|
|
|
|
|
//
|
|
// read filesize
|
|
if (stat (fname.c_str(), &s) != 0) {
|
|
printf ("%s:%d %s could not read stat of file '%s'. Error:%s\n", __FILE__, __LINE__, __FUNCTION__,
|
|
fname.c_str(), strerror(errno));
|
|
Close();
|
|
return 0;
|
|
}
|
|
filesize = s.st_size;
|
|
|
|
#ifdef BUILD_WINDOWS
|
|
if ((fd = open(fname.c_str(), O_RDONLY | O_BINARY)) == -1)
|
|
#else
|
|
if ((fd = open(fname.c_str(), O_RDONLY)) == -1)
|
|
#endif
|
|
{
|
|
printf ("%s:%d could not open file '%s' error:%s\n", __FILE__, __LINE__, fname.c_str(), strerror(errno));
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// read header
|
|
if (read (fd, inbuf, 12) != 12) {
|
|
printf ("%s:%d could not read all header data.\n", __FILE__, __LINE__);
|
|
close (fd);
|
|
fd = -1;
|
|
return 0;
|
|
}
|
|
i = 0;
|
|
filepos = 12;
|
|
conf_width = w = ntohl(inbuf[i++]);
|
|
conf_height = h = ntohl(inbuf[i++]);
|
|
conf_videofmt = ntohl(inbuf[i++]);
|
|
|
|
vidctrls.clear();
|
|
vctl.name = "FilePosition";
|
|
vctl.id = 1;
|
|
vctl.min = 0;
|
|
vctl.max = 255;
|
|
vctl.value = 0;
|
|
vidctrls.push_back(vctl);
|
|
|
|
return 1;
|
|
};
|
|
|
|
|
|
//
|
|
// Close Device
|
|
// Free videobuffer
|
|
//
|
|
int VideoDevice_Dump::Close() {
|
|
printf ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
|
|
|
|
if (fd >= 0) {
|
|
close(fd);
|
|
fd = -1;
|
|
filesize = 0;
|
|
filepos = 0;
|
|
}
|
|
|
|
return 1;
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// send the start capture signal to the cam
|
|
//
|
|
int VideoDevice_Dump::Start() {
|
|
printf ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
|
|
|
|
Close();
|
|
if (Open() != 1) return 0;
|
|
gettimeofday(&starttv, NULL);
|
|
|
|
return 1;
|
|
};
|
|
|
|
|
|
int VideoDevice_Dump::Stop() {
|
|
printf ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
|
|
|
|
if (fd >= 0) {
|
|
close(fd);
|
|
fd = -1;
|
|
}
|
|
|
|
if (inframe != NULL) {
|
|
free (inframe);
|
|
inframe_size = 0;
|
|
inframe = NULL;
|
|
}
|
|
return 1;
|
|
};
|
|
|
|
//
|
|
// try to grab one frame and convert it into RGB32.
|
|
// If something goes wrong return an error code.
|
|
// Return code VDEV_STATUS_AGAIN is not an error. There was no video image ready to read.
|
|
//
|
|
#define SIZE_FRAMEHEADER 8
|
|
#define SIZE_DUMPHEADER 12
|
|
int VideoDevice_Dump::GetFrame(VideoFrame *destframe) {
|
|
struct timeval curtv;
|
|
unsigned int diff = 0;
|
|
std::list<VideoDevCtrl>::iterator ctrl;
|
|
|
|
if (fd == -1) return 0;
|
|
|
|
//
|
|
// is it time?
|
|
do {
|
|
gettimeofday(&curtv, NULL);
|
|
diff = 1000 * (curtv.tv_sec - starttv.tv_sec) +
|
|
(curtv.tv_usec - starttv.tv_usec) / 1000;
|
|
|
|
if (diff < inframe_nexttime)
|
|
usleep ((inframe_nexttime-diff)*1000);
|
|
} while (diff < inframe_nexttime);
|
|
|
|
ReadFrame();
|
|
Convert(&cdata, destframe, inframe, inframe_size,
|
|
conf_videofmt, w, h);
|
|
|
|
ctrl = vidctrls.begin();
|
|
if (ctrl->value == 0) {
|
|
// fixed framesize -> calculate frames
|
|
switch (pixformat) {
|
|
case(V4L2_PIX_FMT_RGB24):
|
|
case(V4L2_PIX_FMT_BGR24):
|
|
fixedframesize = 3 * w * h;
|
|
break;
|
|
case(V4L2_PIX_FMT_RGB32):
|
|
case(V4L2_PIX_FMT_BGR32):
|
|
fixedframesize = 4 * w * h;
|
|
break;
|
|
case(V4L2_PIX_FMT_SGRBG8):
|
|
fixedframesize = 1 * w * h;
|
|
break;
|
|
case(V4L2_PIX_FMT_SGRBG16):
|
|
fixedframesize = 2 * w * h;
|
|
break;
|
|
default:
|
|
ctrl->max = 0;
|
|
ctrl->value = -1;
|
|
fixedframesize = 0;
|
|
break;
|
|
}
|
|
if (fixedframesize > 0)
|
|
ctrl->max = (filesize-SIZE_DUMPHEADER) / (fixedframesize + SIZE_FRAMEHEADER);
|
|
}
|
|
|
|
if (ctrl->value != -1) ctrl->value++;
|
|
|
|
ReadFrame();
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
//
|
|
// Read Frame
|
|
//
|
|
int VideoDevice_Dump::ReadFrame() {
|
|
uint32_t inbuf[2];
|
|
|
|
if (fd < 0) return 0;
|
|
|
|
//
|
|
// check position, if end of file restart from beginning
|
|
if (filepos == filesize) {
|
|
printf ("%s:%d end of file start with first frame\n", __FILE__, __LINE__);
|
|
std::list<VideoDevCtrl>::iterator ctrl;
|
|
ctrl = vidctrls.begin();
|
|
ctrl->value = 0;
|
|
if (lseek(fd, 12, SEEK_SET) != 12) {
|
|
printf ("%s:%d %s lseek returned: %s\n", __FILE__, __LINE__, __FUNCTION__, strerror(errno));
|
|
Close();
|
|
}
|
|
else { // reset filepos and starttime
|
|
filepos = 12;
|
|
gettimeofday(&starttv, NULL);
|
|
}
|
|
}
|
|
|
|
//
|
|
// read frame
|
|
if (read (fd, inbuf, 4*2) != 4*2) {
|
|
printf ("%s:%d could not read frame header: %s\n", __FILE__, __LINE__, strerror(errno));
|
|
Close();
|
|
}
|
|
filepos += (4*2);
|
|
inframe_size = ntohl(inbuf[0]);
|
|
inframe_nexttime = ntohl(inbuf[1]);
|
|
|
|
// read header
|
|
if (inframe == NULL) {
|
|
inframe = (unsigned char*) malloc (inframe_size);
|
|
inframe_maxsize = inframe_size;
|
|
}
|
|
else if (inframe_maxsize < inframe_size) {
|
|
inframe = (unsigned char*) realloc (inframe, inframe_size);
|
|
inframe_maxsize = inframe_size;
|
|
}
|
|
|
|
// allocate memory and read frame
|
|
if (inframe == NULL) {
|
|
Close();
|
|
printf ("%s:%d could not allocate enough memory\n", __FILE__, __LINE__);
|
|
return 0;
|
|
}
|
|
if (read (fd, inframe, inframe_size) != inframe_size) {
|
|
printf ("%s:%d could not read frame: %s\n", __FILE__, __LINE__, strerror(errno));
|
|
Close();
|
|
}
|
|
filepos += inframe_size;
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// set video control identified by id
|
|
//
|
|
int VideoDevice_Dump::SetDevCtrl(unsigned int id, int value) {
|
|
std::list<VideoDevCtrl>::iterator ctrl;
|
|
int framerest;
|
|
off_t newfilepos = 0;
|
|
printf ("%s:%d VideoDev_Dumpfile::SetDevCtrl Set Offset to %d id:%d fixedframesize:%d\n", __FILE__, __LINE__, value, id, fixedframesize);
|
|
struct timeval curtv;
|
|
|
|
if (id == 1) {
|
|
ctrl = vidctrls.begin();
|
|
if (value != ctrl->value && value < ctrl->max) {
|
|
filepos = SIZE_DUMPHEADER + ((off_t)value * (SIZE_FRAMEHEADER + (off_t)fixedframesize));
|
|
printf ("%s:%d filepos:%ld\n", __FILE__, __LINE__, filepos);
|
|
|
|
if ((newfilepos = lseek (fd, filepos, SEEK_SET)) < 0) {
|
|
printf ("%s:%d ******* lseek error:%s\n", __FILE__, __LINE__, strerror(errno));
|
|
}
|
|
else {
|
|
framerest = (newfilepos - SIZE_DUMPHEADER)%(SIZE_FRAMEHEADER + fixedframesize);
|
|
ctrl->value = (newfilepos - SIZE_DUMPHEADER)/(SIZE_FRAMEHEADER + fixedframesize);
|
|
if (ctrl->value != value || framerest != 0) {
|
|
printf ("%s:%d could not set file to correct position. ctrl->value:%d value:%d Framerest:%d\n", __FILE__, __LINE__, ctrl->value, value, framerest);
|
|
}
|
|
else {
|
|
//
|
|
// read first frame
|
|
ReadFrame();
|
|
gettimeofday(&curtv, NULL);
|
|
starttv.tv_sec = curtv.tv_sec - (inframe_nexttime/1000);
|
|
}
|
|
}
|
|
}
|
|
|
|
// else printf ("%s:%d could not set video position (ctrl->value:%d value:%d max:%d)\n",
|
|
// __FILE__, __LINE__, ctrl->value, value, ctrl->max);
|
|
}
|
|
|
|
return 1;
|
|
};
|
|
|
|
|
|
//
|
|
// get video control identified by id
|
|
//
|
|
int VideoDevice_Dump::GetDevCtrl(unsigned int id, int *value) {
|
|
return 1;
|
|
};
|
|
|