void expose_handoff (Surface *s, TimeSpan time, void* data)
{
char *filename = g_strdup_printf ("capture_%.4d.png", image_no);
printf ("Capturing %.3fs to %s\n", TimeSpan_ToSecondsFloat (time), filename);
g_idle_add (increase_timer, NULL);
capture_image (filename);
g_free (filename);
}
int main(int argc, char* argv[]) {
parse_parameter(argc, argv);
// prepare some info outside the loop
int fd;
CvFont font;
cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX, 0.7, 0.7, 0, 2); // 0 shear, 3 px wide
int set_quality[3] = {CV_IMWRITE_JPEG_QUALITY, quality, 0};
char capture_title[55];
IplImage* frame;
CvMat cvmat;
// startup
char dev[20];
sprintf(dev,"/dev/video%i",device);
fd = open(dev, O_RDWR);
if (fd == -1) {
perror("Opening video device");
return 1;
}
if(setup_cam(fd)) {
return 1;
}
if(init_mmap(fd)) {
return 1;
}
// define buffer and activate streaming on the cam
struct v4l2_buffer buf = {0};
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = 0;
if(-1 == xioctl(fd, VIDIOC_STREAMON, &buf.type)) {
perror("Start Capture");
return 1;
}
// loop fps measurement
uint32_t start_time = time(0);
uint32_t image_count = 0;
//for(int i=0; i<100; i++){
/// run forever
while(1) {
if(capture_image(fd,&font,set_quality,frame,&cvmat,capture_title,&buf,&start_time,&image_count)) {
return 1;
}
}
// todo, close gracefully
printf("closing fd\n");
close(fd);
return 0;
}
int main() {
int fd;
fd = open("/dev/video0", O_RDWR);
if (fd == -1) {
perror("Opening video device");
return 1;
}
if (print_caps(fd))
return 1;
if (init_mmap(fd))
return 1;
int i;
if (capture_image(fd))
return 1;
close(fd);
return 0;
}
int main( int argc, char *argv[] ) {
camcap_init( );
programName = argv[0];
if ( argc == 1 ) {
return enumerate_devices( );
} else if ( argc == 3 ) {
return capture_image( argv[1], argv[2] );
} else {
fprintf( stderr, "Usage:\n" );
fprintf( stderr, " Enumerate cameras: %s\n", programName );
fprintf( stderr, " Capture a raw image: %s <deviceIndex> <filename>\n", programName );
return 1;
}
return 0;
}
int main(int argc, char *argv[])
{
dev_name = "/dev/video0";
int value;
char *outputfile = "snap.yuv";
for (;;) {
int index;
int c;
c = getopt_long(argc, argv,
short_options, long_options, &index);
if (-1 == c)
break;
switch (c) {
case 0: /* getopt_long() flag */
break;
case 'd':
dev_name = optarg;
break;
case 'o':
outputfile = optarg;
break;
case 'e':
value = atoi(optarg);
exposure_time =
value > 0 ? value : MAX_EXPOSURE_TIME;
break;
case 'h':
usage(stdout, argc, argv);
exit(EXIT_SUCCESS);
case 'x':
value = atoi(optarg);
if (value > 0) {
sw = value;
}
break;
case 'y':
value = atoi(optarg);
if (value > 0) {
sh = value;
}
break;
case 'w':
value = atoi(optarg);
if ((value >= 2800) && (value <= 6500)) {
white_balance_mode = value;
}
break;
default:
usage(stderr, argc, argv);
exit(EXIT_FAILURE);
}
}
int fd;
fd = open(dev_name, O_RDWR);
if (fd == -1) {
perror("Opening video device");
return 1;
}
if (print_caps(fd))
return 1;
if (init_mmap(fd))
return 1;
// show default values in exposure time
printf("NOTE: v4l2-ctl -L to query parameters\n");
// set white balance
if (white_balance_mode > -1) {
memset(&queryctrl, 0, sizeof(queryctrl));
queryctrl.id = V4L2_CID_AUTO_WHITE_BALANCE;
if (-1 == xioctl(fd, VIDIOC_QUERYCTRL, &queryctrl)) {
if (errno != EINVAL) {
perror("VIDIOC_QUERYCTRL");
exit(EXIT_FAILURE);
} else {
printf
("V4L2_CID_AUTO_WHITE_BALANCE is not supported\n");
}
} else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
printf("V4L2_CID is not supported\n");
} else {
// set manual flags to modify the white balance
memset(&queryctrl, 0, sizeof(queryctrl));
queryctrl.id = V4L2_CID_AUTO_WHITE_BALANCE;
queryctrl.flags &= !(V4L2_CTRL_FLAG_GRABBED); // On exposure absolute
if (-1 == xioctl(fd, VIDIOC_QUERYCTRL, &queryctrl)) {
if (errno != EINVAL) {
perror("VIDIOC_QUERYCTRL");
exit(EXIT_FAILURE);
} else {
printf
("V4L2_CID_AUTO_WHITE_BALANCE is not supported\n");
}
}
// set class camera control
struct v4l2_ext_controls query = { 0 };
struct v4l2_ext_control ctrl[1];
query.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
ctrl[0].id = V4L2_CID_AUTO_WHITE_BALANCE;
ctrl[0].value = 0;
query.count = 1;
query.controls = ctrl;
if (-1 ==
ioctl(fd, VIDIOC_S_EXT_CTRLS, &query,
"VIDIOC_S_EXT_CTRLS")) {
perror("VIDIOC_G_CTRL get camera class");
exit(EXIT_FAILURE);
} else {
printf("Set V4L2_CTRL_CLASS_CAMERA OK\n");
}
//change the exposure time
memset(&control, 0, sizeof(control));
control.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
control.value = white_balance_mode;
if (-1 == xioctl(fd, VIDIOC_S_CTRL, &control)) {
perror("VIDIOC_S_CTRL set white balance temperature");
exit(EXIT_FAILURE);
}
printf("Set white balance temperature OK\n");
}
}
// set exposure_time
if (exposure_time > -1) {
memset(&queryctrl, 0, sizeof(queryctrl));
queryctrl.id = V4L2_CID_EXPOSURE_ABSOLUTE;
if (-1 == xioctl(fd, VIDIOC_QUERYCTRL, &queryctrl)) {
if (errno != EINVAL) {
perror("VIDIOC_QUERYCTRL");
exit(EXIT_FAILURE);
} else {
printf
("V4L2_CID_EXPOSURE_ABSOLUTE is not supported\n");
}
} else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
printf("V4L2_CID is not supported\n");
} else {
// set manual flags to modify the exposure time
memset(&queryctrl, 0, sizeof(queryctrl));
queryctrl.id = V4L2_CID_EXPOSURE_ABSOLUTE;
queryctrl.flags &= !(V4L2_CTRL_FLAG_GRABBED); // On exposure absolute
if (-1 == xioctl(fd, VIDIOC_QUERYCTRL, &queryctrl)) {
if (errno != EINVAL) {
perror("VIDIOC_QUERYCTRL");
exit(EXIT_FAILURE);
} else {
printf
("V4L2_CID_EXPOSURE_ABSOLUTE is not supported\n");
}
}
// set class camera control
struct v4l2_ext_controls query = { 0 };
struct v4l2_ext_control ctrl[1];
query.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
ctrl[0].id = V4L2_CID_EXPOSURE_AUTO;
ctrl[0].value = V4L2_EXPOSURE_MANUAL;
query.count = 1;
query.controls = ctrl;
if (-1 ==
ioctl(fd, VIDIOC_S_EXT_CTRLS, &query,
"VIDIOC_S_EXT_CTRLS")) {
perror("VIDIOC_G_CTRL get camera class");
exit(EXIT_FAILURE);
} else {
printf("Set V4L2_CTRL_CLASS_CAMERA OK\n");
}
//change the exposure time
memset(&control, 0, sizeof(control));
control.id = V4L2_CID_EXPOSURE_ABSOLUTE;
control.value = exposure_time; //queryctrl.default_value;//10000;//exposure_time;
if (-1 == xioctl(fd, VIDIOC_S_CTRL, &control)) {
perror("VIDIOC_S_CTRL set exposure time");
exit(EXIT_FAILURE);
}
printf("Set Exposicion time OK\n");
}
} else {
// set manual flags to set exposure auto
memset(&queryctrl, 0, sizeof(queryctrl));
queryctrl.id = V4L2_CID_EXPOSURE_ABSOLUTE;
queryctrl.flags |= V4L2_CTRL_FLAG_GRABBED;
if (-1 == xioctl(fd, VIDIOC_QUERYCTRL, &queryctrl)) {
if (errno != EINVAL) {
perror("VIDIOC_QUERYCTRL");
exit(EXIT_FAILURE);
} else {
printf
("V4L2_CID_EXPOSURE_ABSOLUTE is not supported\n");
}
}
struct v4l2_ext_controls query = { 0 };
struct v4l2_ext_control ctrl[1];
query.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
ctrl[0].id = V4L2_CID_EXPOSURE_AUTO;
ctrl[0].value = V4L2_EXPOSURE_APERTURE_PRIORITY;
query.count = 1;
query.controls = ctrl;
if (-1 ==
ioctl(fd, VIDIOC_S_EXT_CTRLS, &query,
"VIDIOC_S_EXT_CTRLS")) {
perror("VIDIOC_G_CTRL get camera class");
exit(EXIT_FAILURE);
} else {
printf("Set V4L2_CTRL_CLASS_CAMERA OK\n");
}
}
if (capture_image(fd, outputfile))
return 1;
close(fd);
return 0;
}
/**
* Record sensor data and capture images.
* Activity is recorded to DATA.LOG to be picked up by the Skywire task.
*/
void
camera_task(void * pvParameters) {
int low_pow = 0;
/* Initialize the peripherals and state for this task. */
if (!camera_task_setup()) {
trace_printf("camera_task: setup failed\n");
vTaskDelete(NULL);
return;
} else {
trace_printf("camera_task: started\n");
}
/* Initialize timing for capture sub-tasks. */
TickType_t lastReading, lastCapture;
lastReading = lastCapture = xTaskGetTickCount();
/* Initialize the sample buffer. */
samples.Count = 0;
for (;;) {
TickType_t currentTicks = xTaskGetTickCount();
if ((currentTicks - lastReading) >= SAMPLE_RATE_MS) {
capture_sample(&lastReading);
}
//point at which image is captured from camera
if (arduCamInstalled) {
if ((currentTicks - lastCapture) >= IMAGE_RATE_MS) {
//if camera is currently in low power mode, exit low power mode before taking image
if (low_pow == 1){
if(arducam_low_power_remove() != DEVICES_OK){
trace_printf("Error removing low power mode \n");
}
else{
low_pow = 0;
}
}
//only try taking image if low power has been properly disabled
if (low_pow == 0){
capture_image(&lastCapture);
}
//after image has been taken, put camera down into low-power mode
if (low_pow == 0){
if(arducam_low_power_set() != DEVICES_OK){
trace_printf("Error setting low power mode \n");
}
else{
trace_printf("Low power mode set \n");
low_pow = 1;
}
}
}
vTaskDelay(100);
}
}
}
static int capture_loop(dc1394camera_t *camera, const char *basename, float delay, bool testonly)
{
uint16_t average;
uint32_t num_saturated, num_half_saturated;
float shutter = SHUTTER_GOOD;
float gain = GAIN_GOOD;
CHECK(dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_400));
CHECK(dc1394_video_set_mode(camera, DC1394_VIDEO_MODE_1280x960_MONO16));
CHECK(dc1394_video_set_framerate(camera, DC1394_FRAMERATE_3_75));
CHECK(dc1394_capture_setup(camera, 16, DC1394_CAPTURE_FLAGS_DEFAULT));
CHECK(dc1394_feature_set_power(camera, DC1394_FEATURE_EXPOSURE, DC1394_OFF));
CHECK(dc1394_feature_set_power(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_ON));
CHECK(dc1394_feature_set_mode(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_FEATURE_MODE_MANUAL));
CHECK(dc1394_feature_set_value(camera, DC1394_FEATURE_BRIGHTNESS, 0));
CHECK(dc1394_feature_set_power(camera, DC1394_FEATURE_GAIN, DC1394_ON));
CHECK(dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_MANUAL));
CHECK(dc1394_feature_set_value(camera, DC1394_FEATURE_GAIN, 500));
CHECK(dc1394_feature_set_absolute_control(camera, DC1394_FEATURE_GAIN, DC1394_ON));
CHECK(dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_GAIN, GAIN_GOOD));
CHECK(dc1394_feature_set_power(camera, DC1394_FEATURE_SHUTTER, DC1394_ON));
CHECK(dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL));
CHECK(dc1394_feature_set_value(camera, DC1394_FEATURE_SHUTTER, 500));
CHECK(dc1394_feature_set_absolute_control(camera, DC1394_FEATURE_SHUTTER, DC1394_ON));
CHECK(dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_SHUTTER, SHUTTER_GOOD));
CHECK(dc1394_video_set_transmission(camera, DC1394_ON));
while (true) {
alarm(10+(unsigned)delay);
if (capture_image(camera, basename, shutter, gain, &average,
&num_saturated, &num_half_saturated, testonly) == -1) {
return -1;
}
if (num_saturated > SATURATED_HIGH) {
/* too much saturation */
if (gain > GAIN_MIN) {
gain = new_gain(average, average*0.5, gain);
} else if (shutter > SHUTTER_MIN) {
shutter = new_shutter(average, average*0.5, shutter, SHUTTER_MAX);
}
} else if (average < AVERAGE_LOW &&
num_saturated == 0 &&
num_half_saturated < SATURATED_HIGH) {
/* too dark */
if (shutter < SHUTTER_GOOD) {
float shutter2 = new_shutter(average, AVERAGE_TARGET, shutter, SHUTTER_GOOD);
average = (shutter2/shutter)*average;
shutter = shutter2;
}
if (average < AVERAGE_LOW) {
if (gain < GAIN_MAX) {
gain = new_gain(average, AVERAGE_TARGET, gain);
} else if (shutter < SHUTTER_MAX) {
shutter = new_shutter(average, AVERAGE_TARGET, shutter, SHUTTER_MAX);
}
}
} else if (average > AVERAGE_HIGH) {
/* too light */
if (shutter > SHUTTER_GOOD) {
float shutter2 = new_shutter(average, AVERAGE_TARGET, shutter, SHUTTER_GOOD);
average = (shutter2/shutter)*average;
shutter = shutter2;
}
if (average > AVERAGE_HIGH) {
if (gain > GAIN_MIN) {
gain = new_gain(average, AVERAGE_TARGET, gain);
} else if (shutter > SHUTTER_MIN) {
shutter = new_shutter(average, AVERAGE_TARGET, shutter, SHUTTER_MAX);
}
}
}
fflush(stdout);
usleep(delay*1.0e6);
}
return 0;
}
