int _listFeatures(){
if(camera==NULL) {
dc1394_log_error("Camera is not initialised");
return -1;
}
dc1394featureset_t features;
/*-----------------------------------------------------------------------
* report camera's features
*-----------------------------------------------------------------------*/
err=dc1394_feature_get_all(camera,&features);
if (err!=DC1394_SUCCESS) {
dc1394_log_warning("Could not get feature set");
}
else {
dc1394_feature_print_all(&features, stdout);
}
dc1394_avt_adv_feature_info_t adv_feature;
dc1394_avt_get_advanced_feature_inquiry(camera, &adv_feature);
if (err!=DC1394_SUCCESS) {
dc1394_log_warning("Could not get adv feature set");
}
else {
dc1394_avt_print_advanced_feature(&adv_feature);
}
}
static dc1394error_t
free_resources(platform_camera_t * cam)
{
DWORD ret = t1394IsochTearDownStream(cam->device->device_path);
if (ret) {
dc1394_log_warning("t1394IsochTearDownStream: Error %ld\n", ret);
return DC1394_FAILURE;
}
return DC1394_SUCCESS;
}
int main(int argc, char *argv[]) {
unsigned int i;
dc1394_t * d;
dc1394camera_list_t * list;
dc1394error_t err;
dc1394featureset_t features;
d = dc1394_new();
if(!d)
return 1;
err = dc1394_camera_enumerate(d, &list);
DC1394_ERR_RTN(err,"Failed to enumerate cameras");
if(list->num == 0) {
dc1394_log_error("No cameras found");
return 1;
}
for(i = 0; i < list->num; i++) {
dc1394camera_t *camera = dc1394_camera_new(d, list->ids[i].guid);
if(camera) {
unsigned int j;
dc1394video_modes_t modes;
// Print hardware informations.
dc1394_camera_print_info(camera, stdout);
// Print supported camera features.
err = dc1394_feature_get_all(camera,&features);
if(err != DC1394_SUCCESS) {
dc1394_log_warning("Could not get feature set");
} else {
dc1394_feature_print_all(&features, stdout);
}
// Print a list of supported modes.
printf("------ Supported Video Modes ------\n");
err = dc1394_video_get_supported_modes(camera, &modes);
DC1394_ERR_RTN(err,"Could not get list of modes");
for(j = 0; j < modes.num; j++) {
print_video_mode_info(camera, modes.modes[j]);
}
dc1394_camera_free(camera);
}
}
dc1394_camera_free_list (list);
dc1394_free (d);
return 0;
}
dc1394error_t
dc1394_juju_capture_stop(platform_camera_t *craw)
{
dc1394camera_t * camera = craw->camera;
struct fw_cdev_stop_iso stop;
int i;
if (craw->capture_is_set == 0)
return DC1394_CAPTURE_IS_NOT_SET;
stop.handle = craw->iso_handle;
if (ioctl(craw->iso_fd, FW_CDEV_IOC_STOP_ISO, &stop) < 0)
return DC1394_IOCTL_FAILURE;
munmap(craw->buffer, craw->buffer_size);
close(craw->iso_fd);
for (i = 0; i<craw->num_frames; i++)
release_frame(craw, i);
free (craw->frames);
craw->frames = NULL;
craw->capture_is_set = 0;
if (craw->capture_iso_resource) {
if (juju_iso_deallocate (craw, craw->capture_iso_resource) < 0)
dc1394_log_warning ("juju: Failed to deallocate iso resources");
craw->capture_iso_resource = NULL;
}
// stop ISO if it was started automatically
if (craw->iso_auto_started>0) {
dc1394error_t err=dc1394_video_set_transmission(camera, DC1394_OFF);
DC1394_ERR_RTN(err,"Could not stop ISO!");
craw->iso_auto_started=0;
}
return DC1394_SUCCESS;
}
int main(int argc,char *argv[])
{
XEvent xev;
XGCValues xgcv;
long background=0x010203;
int i, j;
dc1394_t * d;
dc1394camera_list_t * list;
get_options(argc,argv);
/* process options */
switch(fps) {
case 1: fps = DC1394_FRAMERATE_1_875; break;
case 3: fps = DC1394_FRAMERATE_3_75; break;
case 15: fps = DC1394_FRAMERATE_15; break;
case 30: fps = DC1394_FRAMERATE_30; break;
case 60: fps = DC1394_FRAMERATE_60; break;
default: fps = DC1394_FRAMERATE_7_5; break;
}
switch(res) {
case 1:
res = DC1394_VIDEO_MODE_640x480_YUV411;
device_width=640;
device_height=480;
format=XV_YUY2;
break;
case 2:
res = DC1394_VIDEO_MODE_640x480_RGB8;
device_width=640;
device_height=480;
format=XV_YUY2;
break;
case 3:
res = DC1394_VIDEO_MODE_800x600_YUV422;
device_width=800;
device_height=600;
format=XV_UYVY;
break;
default:
res = DC1394_VIDEO_MODE_320x240_YUV422;
device_width=320;
device_height=240;
format=XV_UYVY;
break;
}
dc1394error_t err;
d = dc1394_new ();
if (!d)
return 1;
err=dc1394_camera_enumerate (d, &list);
DC1394_ERR_RTN(err,"Failed to enumerate cameras");
if (list->num == 0) {
dc1394_log_error("No cameras found");
return 1;
}
j = 0;
for (i = 0; i < list->num; i++) {
if (j >= MAX_CAMERAS)
break;
cameras[j] = dc1394_camera_new (d, list->ids[i].guid);
if (!cameras[j]) {
dc1394_log_warning("Failed to initialize camera with guid %llx", list->ids[i].guid);
continue;
}
j++;
}
numCameras = j;
dc1394_camera_free_list (list);
if (numCameras == 0) {
dc1394_log_error("No cameras found");
exit (1);
}
/* setup cameras for capture */
for (i = 0; i < numCameras; i++) {
//err=dc1394_video_set_iso_speed(cameras[i], DC1394_ISO_SPEED_400);
//dc1394_video_set_operation_mode(my_camera_ptr[i], DC1394_OPERATION_MODE_1394B);
err= dc1394_video_set_operation_mode(cameras[i], DC1394_OPERATION_MODE_1394B);
err=dc1394_video_set_iso_speed(cameras[i], DC1394_ISO_SPEED_800);
DC1394_ERR_CLN_RTN(err,cleanup(),"Could not set ISO speed");
err=dc1394_video_set_mode(cameras[i], res);
DC1394_ERR_CLN_RTN(err,cleanup(),"Could not set video mode");
err=dc1394_video_set_framerate(cameras[i], fps);
DC1394_ERR_CLN_RTN(err,cleanup(),"Could not set framerate");
err=dc1394_capture_setup(cameras[i],NUM_BUFFERS, DC1394_CAPTURE_FLAGS_DEFAULT);
DC1394_ERR_CLN_RTN(err,cleanup(),"Could not setup camera-\nmake sure that the video mode and framerate are\nsupported by your camera");
err=dc1394_video_set_transmission(cameras[i], DC1394_ON);
DC1394_ERR_CLN_RTN(err,cleanup(),"Could not start camera iso transmission");
// Camera settings
err = dc1394_feature_set_value(cameras[i],DC1394_FEATURE_SHUTTER,1400);
err = dc1394_feature_set_value(cameras[i],DC1394_FEATURE_BRIGHTNESS,800);
err = dc1394_feature_set_value(cameras[i],DC1394_FEATURE_EXPOSURE,150);
err = dc1394_feature_whitebalance_set_value(cameras[i],500,400);
}
fflush(stdout);
if (numCameras < 1) {
perror("no cameras found :(\n");
cleanup();
exit(-1);
}
switch(format){
case XV_YV12:
set_frame_length(device_width*device_height*3/2, numCameras);
break;
case XV_YUY2:
case XV_UYVY:
set_frame_length(device_width*device_height*2, numCameras);
break;
default:
dc1394_log_error("Unknown format set (internal error)");
exit(255);
}
/* make the window */
display=XOpenDisplay(getenv("DISPLAY"));
if(display==NULL) {
dc1394_log_error("Could not open display \"%s\"",getenv("DISPLAY"));
cleanup();
exit(-1);
}
QueryXv();
if ( adaptor < 0 ) {
cleanup();
exit(-1);
}
width=device_width;
height=device_height * numCameras;
//width=device_width * numCameras;
//height=device_height;
window=XCreateSimpleWindow(display,DefaultRootWindow(display),0,0,width,height,0,
WhitePixel(display,DefaultScreen(display)),
background);
XSelectInput(display,window,StructureNotifyMask|KeyPressMask);
XMapWindow(display,window);
connection=ConnectionNumber(display);
gc=XCreateGC(display,window,0,&xgcv);
/* main event loop */
while(1){
for (i = 0; i < numCameras; i++) {
if (dc1394_capture_dequeue(cameras[i], DC1394_CAPTURE_POLICY_WAIT, &frames[i])!=DC1394_SUCCESS)
dc1394_log_error("Failed to capture from camera %d", i);
}
display_frames();
XFlush(display);
while(XPending(display)>0){
XNextEvent(display,&xev);
switch(xev.type){
case ConfigureNotify:
width=xev.xconfigure.width;
height=xev.xconfigure.height;
display_frames();
break;
case KeyPress:
switch(XKeycodeToKeysym(display,xev.xkey.keycode,0)){
case XK_q:
case XK_Q:
cleanup();
exit(0);
break;
case XK_comma:
case XK_less:
//width=width/2;
//height=height/2;
width--;
XResizeWindow(display,window,width,height);
display_frames();
break;
case XK_period:
case XK_greater:
//width=2*width;
//height=2*height;
width++;
XResizeWindow(display,window,width,height);
display_frames();
break;
case XK_0:
freeze = !freeze;
break;
case XK_1:
fps = DC1394_FRAMERATE_1_875;
for (i = 0; i < numCameras; i++)
dc1394_video_set_framerate(cameras[i], fps);
break;
case XK_2:
fps = DC1394_FRAMERATE_3_75;
for (i = 0; i < numCameras; i++)
dc1394_video_set_framerate(cameras[i], fps);
break;
case XK_4:
fps = DC1394_FRAMERATE_15;
for (i = 0; i < numCameras; i++)
dc1394_video_set_framerate(cameras[i], fps);
break;
case XK_5:
fps = DC1394_FRAMERATE_30;
for (i = 0; i < numCameras; i++)
dc1394_video_set_framerate(cameras[i], fps);
break;
case XK_3:
fps = DC1394_FRAMERATE_7_5;
for (i = 0; i < numCameras; i++)
dc1394_video_set_framerate(cameras[i], fps);
break;
}
break;
}
} /* XPending */
for (i = 0; i < numCameras; i++) {
if (frames[i])
dc1394_capture_enqueue (cameras[i], frames[i]);
}
} /* while not interrupted */
exit(0);
}
void *pdp_dc1394_new(t_symbol *vdef)
{
t_pdp_dc1394 *x = (t_pdp_dc1394 *)pd_new(pdp_dc1394_class);
x->x_outlet0 = outlet_new(&x->x_obj, &s_anything);
x->d = dc1394_new ();
x->err=dc1394_camera_enumerate (x->d, &x->list);
//DC1394_ERR_RTN(x->err,"Failed to enumerate cameras");
//post("Failed to enumerate cameras");
if (x->list->num == 0) {
dc1394_log_error("No cameras found");
return 1;
}
x->camera = dc1394_camera_new (x->d, x->list->ids[0].guid);
if (!x->camera) {
//dc1394_log_error("Failed to initialize camera with guid %"PRIx64, list->ids[0].guid);
return 1;
}
dc1394_camera_free_list (x->list);
//printf("Using camera with GUID %"PRIx64"\n", camera->guid);
/*-----------------------------------------------------------------------
* get the best video mode and highest framerate. This can be skipped
* if you already know which mode/framerate you want...
*-----------------------------------------------------------------------*/
// get video modes:
x->err=dc1394_video_get_supported_modes(x->camera,&x->video_modes);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Can't get video modes");
// select highest res mode:
for (x->i=x->video_modes.num-1;x->i>=0;x->i--) {
if (!dc1394_is_video_mode_scalable(x->video_modes.modes[x->i])) {
dc1394_get_color_coding_from_video_mode(x->camera,x->video_modes.modes[x->i], &x->coding);
if (x->coding==DC1394_COLOR_CODING_MONO8) {
x->video_mode=x->video_modes.modes[x->i];
fprintf(stderr,"video_mode %d: %d\n",x->i,x->video_modes.modes[x->i]);
break;
}
}
}
if (x->i < 0) {
dc1394_log_error("Could not get a valid MONO8 mode");
cleanup_and_exit(x->camera);
}
x->err=dc1394_get_color_coding_from_video_mode(x->camera, x->video_mode,&x->coding);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not get color coding");
fprintf(stderr,"color_coding : %d\n",x->coding);
// get highest framerate
x->err=dc1394_video_get_supported_framerates(x->camera,x->video_mode,&x->framerates);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not get framrates");
x->framerate=x->framerates.framerates[x->framerates.num-1];
fprintf(stderr,"framerate : %d\n",x->framerate);
/*-----------------------------------------------------------------------
* setup capture
*-----------------------------------------------------------------------*/
x->err=dc1394_video_set_iso_speed(x->camera, DC1394_ISO_SPEED_400);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not set iso speed");
x->err=dc1394_video_set_mode(x->camera, x->video_mode);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not set video mode");
x->err=dc1394_video_set_framerate(x->camera, x->framerate);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not set framerate");
x->err=dc1394_capture_setup(x->camera,4, DC1394_CAPTURE_FLAGS_DEFAULT);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not setup camera-\nmake sure that the video mode and framerate are\nsupported by your camera");
/*-----------------------------------------------------------------------
* report camera's features
*-----------------------------------------------------------------------*/
x->err=dc1394_feature_get_all(x->camera,&x->features);
if (x->err!=DC1394_SUCCESS) {
dc1394_log_warning("Could not get feature set");
}
else {
dc1394_feature_print_all(&x->features, stdout);
}
/*-----------------------------------------------------------------------
* have the camera start sending us data
*-----------------------------------------------------------------------*/
x->err=dc1394_video_set_transmission(x->camera, DC1394_ON);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not start camera iso transmission");
x->x_initialized = true;
return (void *)x;
}
bool ieee1394capture::init(RoboCompCamera::TCamParams ¶ms_, RoboCompJointMotor::JointMotorPrx head_ , RoboCompDifferentialRobot::DifferentialRobotPrx base_ )
{
params = params_;
head = head_;
base = base_;
int32_t i;
fps = (dc1394framerate_t)params.FPS;//15;
res = (dc1394video_mode_t)0;
switch (fps) {
case 1: fps = DC1394_FRAMERATE_1_875; break;
case 3: fps = DC1394_FRAMERATE_3_75; break;
case 15: fps = DC1394_FRAMERATE_15; break;
case 30: fps = DC1394_FRAMERATE_30; break;
case 60: fps = DC1394_FRAMERATE_60; break;
default: fps = DC1394_FRAMERATE_7_5; break;
}
switch (res) {
case 1:
res = DC1394_VIDEO_MODE_640x480_YUV411;
device_width = 640;
device_height = 480;
break;
case 2:
res = DC1394_VIDEO_MODE_640x480_RGB8;
device_width = 640;
device_height = 480;
break;
default:
res = DC1394_VIDEO_MODE_320x240_YUV422;
device_width = 320;
device_height = 240;
break;
}
/// Get handle
qDebug() << "ieee1394capture::init() -> Initializating first Firewire Card in the system...";
if (!(d = dc1394_new()))
{
qDebug() << "ieee1394capture::init() -> Fatal error: Unable to aquire a handle to the Ieee1394 device";
qDebug() << "Please check if the kernel modules `ieee1394',`raw1394' and `ohci1394' are loaded or if you have read/write access to /dev/raw1394 and to /dev/video1394-0 " ;
return false;
}
CREATED_BUS = true;
/// Create camera interfaces
numCameras = 0;
err = dc1394_camera_enumerate(d, &list);
DC1394_ERR_RTN(err, "Failed to enumerate cameras");
if (list->num == 0)
{
dc1394_log_error("No cameras found");
return 1;
}
numCameras = 0;
for (uint32_t di = 0; di < list->num; di++)
{
if (numCameras >= MAX_CAMERAS)
break;
cameras[numCameras] = dc1394_camera_new(d, list->ids[di].guid);
if (!cameras[numCameras])
{
dc1394_log_warning("Failed to initialize camera with guid %llx", list->ids[di].guid);
continue;
}
printf("Camera #%d\n", numCameras);
numCameras++;
}
dc1394_camera_free_list(list);
if ( numCameras < 1 )
{
qDebug() << "ieee1394capture::init() -> Fatal error: No cameras found in the bus! Called from ";
cleanup();
return false;
}
/// Check if one camera has become the root node
/* for ( int n=0; n < numCameras; n++ )
{
if ( cameraNodeList[n] == numNodes )
{
qDebug() << "ieee1394capture::init() -> Fatal error: Sorry, your camera is the highest numbered node of the bus, and has therefore become the root node." ;
cleanup();
return false;
}
}*/
CREATED_CAMS = true;
/// Setup cameras for capture
qDebug() << "ieee1394capture::init() -> Searching cameras with requested parameters:";
printf("%s\n",params.mode.c_str());
if (params.mode == "MODE_320x240_YUV422")
{
res = DC1394_VIDEO_MODE_320x240_YUV422;
params.width = 320;
params.height = 240;
}
else if (params.mode == "MODE_640x480_YUV422" )
{
res = DC1394_VIDEO_MODE_640x480_YUV422;
params.width = 640;
params.height = 480;
}
else if (params.mode == "MODE_640x480_RGB" )
{
res = DC1394_VIDEO_MODE_640x480_RGB8;
params.width = 640;
params.height = 480;
}
else if (params.mode == "MODE_640x480_YUV411")
{
res = DC1394_VIDEO_MODE_640x480_YUV411;
params.width = 640;
params.height = 480;
}
else if (params.mode == "MODE_640x480_MONO")
{
res = DC1394_VIDEO_MODE_640x480_MONO8;
params.width = 640;
params.height = 480;
}
else if (params.mode == "MODE_640x480_MONO16")
{
res = DC1394_VIDEO_MODE_640x480_MONO16;
params.width = 640;
params.height = 480;
}
else if (params.mode == "MODE_516x338_YUV422")
{
res = DC1394_VIDEO_MODE_FORMAT7_1;
params.width = 516;
params.height = 338;
}
else qFatal("ieee1394capture::init() -> Image Mode %s not available. Aborting...", params.mode.c_str());
params.size = params.width*params.height;
if (params.FPS!=15 and params.FPS!=30)
{
qWarning("ieee1394capture::init() -> Framerate %d not available. Aborting...", params.FPS );
cleanup();
return false;
}
dc1394format7modeset_t info;
for (i = 0; i < numCameras; i++)
{
if (params.mode == "MODE_516x338_YUV422")
{
err = dc1394_format7_get_modeset(cameras[i], &info);
for( int j=0;j<DC1394_VIDEO_MODE_FORMAT7_NUM;j++)
{
qDebug() << info.mode[j].present;
qDebug() << info.mode[j].size_x;
qDebug() << info.mode[j].size_y;
qDebug() << info.mode[j].max_size_x;
qDebug() << info.mode[j].max_size_y;
qDebug() << info.mode[j].pos_x;
qDebug() << info.mode[j].pos_y;
qDebug() << info.mode[j].unit_size_x;
qDebug() << info.mode[j].unit_size_y;
qDebug() << info.mode[j].unit_pos_x;
qDebug() << info.mode[j].unit_pos_y;
qDebug() << info.mode[j].pixnum;
qDebug() << info.mode[j].packet_size; /* in bytes */
qDebug() << info.mode[j].unit_packet_size;
qDebug() << info.mode[j].max_packet_size;
}
}
release_iso_and_bw(i);
err = dc1394_video_set_mode(cameras[i], res);
DC1394_ERR_CLN_RTN(err, cleanup(), "Could not set video mode");
err = dc1394_video_set_iso_speed(cameras[i], DC1394_ISO_SPEED_400);
DC1394_ERR_CLN_RTN(err, cleanup(), "Could not set ISO speed");
//For format 7 modes only
if (params.mode == "MODE_516x338_YUV422")
{
// uint32_t packet_size;
// err=dc1394_format7_set_image_size(cameras[i], res, 514, 384);
// DC1394_ERR_RTN(err,"Could not set image size");
// err=dc1394_format7_get_recommended_packet_size(cameras[i], res, &packet_size);
// DC1394_ERR_RTN(err,"Could not get format 7 recommended packet size");
// err=dc1394_format7_set_roi(cameras[i], res, DC1394_COLOR_CODING_YUV422, packet_size, 0,0, 514, 384);
// DC1394_ERR_RTN(err,"Could not set ROI");
qDebug() << "ya";
}
err = dc1394_video_set_framerate(cameras[i], fps);
DC1394_ERR_CLN_RTN(err, cleanup(), "Could not set framerate");
err = dc1394_capture_setup(cameras[i], NUM_BUFFERS, DC1394_CAPTURE_FLAGS_DEFAULT);
DC1394_ERR_CLN_RTN(err, cleanup(), "Could not setup camera-\nmake sure that the video mode and framerate are\nsupported by your camera");
err = dc1394_video_set_transmission(cameras[i], DC1394_ON);
DC1394_ERR_CLN_RTN(err, cleanup(), "Could not start camera iso transmission");
}
fflush(stdout);
qDebug() << " ieee1394capture::init() -> Iso transmission started.";
///Buffers de imagen
qDebug() << "BUFFERS DE IMAGEN ------------------------------------------";
for ( int i=0; i < numCameras; i++ )
{
AimgBuffer[i] = ( Ipp8u * ) ippsMalloc_8u ( params.size * 9 );
BimgBuffer[i] = ( Ipp8u * ) ippsMalloc_8u ( params.size * 9 );
img8u_lum[i] = AimgBuffer[i];
img8u_YUV[i] = AimgBuffer[i]+params.size;
localYRGBImgBufferPtr[i] = BimgBuffer[i];
qDebug() << "Reservando" << params.size * 9 <<" para localYRGBImgBufferPtr["<<i<<"]";
printf("(de %p a %p)\n", localYRGBImgBufferPtr[i], localYRGBImgBufferPtr[i]+(params.size*9-1));
}
planos[0]=BimgBuffer[0]+params.size*3;
planos[1]=BimgBuffer[0]+ ( params.size*4 );
planos[2]=BimgBuffer[0]+ ( params.size*5 );
//img8u_aux = BimgBuffer[0]+(params.size*6);
imgSize_ipp.width=params.width;
imgSize_ipp.height=params.height;
return true;
}
int main(int argc, char *argv[])
{
// assumes your camera can output 640x480 with 8-bit monochrome
video_mode = DC1394_VIDEO_MODE_640x480_MONO8;
d = dc1394_new();
if (!d)
return 1;
err=dc1394_camera_enumerate (d, &list);
DC1394_ERR_RTN(err,"Failed to enumerate cameras");
if (list->num == 0) {
dc1394_log_error("No cameras found");
return 1;
}
// use two counters so tht cameras array does not contain gaps in the case of errors
j = 0;
for (i = 0; i < list->num; i++) {
if (j >= MAX_CAMERAS)
break;
cameras[j] = dc1394_camera_new (d, list->ids[i].guid);
if (!cameras[j]) {
dc1394_log_warning("Failed to initialize camera with guid %llx", list->ids[i].guid);
continue;
}
j++;
}
numCameras = j;
dc1394_camera_free_list (list);
if (numCameras == 0) {
dc1394_log_error("No cameras found");
exit (1);
}
// setup cameras for capture
for (i = 0; i < numCameras; i++) {
err=dc1394_video_set_iso_speed(cameras[i], DC1394_ISO_SPEED_800);
DC1394_ERR_CLN_RTN(err,cleanup(),"Could not set ISO speed");
err=dc1394_video_set_mode(cameras[i], video_mode);
DC1394_ERR_CLN_RTN(err,cleanup(),"Could not set video mode");
err=dc1394_capture_setup(cameras[i],NUM_BUFFERS, DC1394_CAPTURE_FLAGS_DEFAULT);
DC1394_ERR_CLN_RTN(err,cleanup(),"Could not setup camera-\nmake sure that the video mode and framerate are\nsupported by your camera");
err=dc1394_get_image_size_from_video_mode(cameras[i], video_mode, &video_mode_width, &video_mode_height);
DC1394_ERR_CLN_RTN(err,cleanup(),"Could not query video mode width and height");
err=dc1394_video_set_one_shot(cameras[i], DC1394_ON);
DC1394_ERR_CLN_RTN(err,cleanup(),"Could not use one shot mode");
}
fflush(stdout);
if (numCameras < 1) {
perror("no cameras found :(\n");
cleanup();
exit(-1);
}
for (i = 0; i < numCameras; i++) {
if (dc1394_capture_dequeue(cameras[i], DC1394_CAPTURE_POLICY_WAIT, &frames[i])!=DC1394_SUCCESS)
dc1394_log_error("Failed to capture from camera %d", i);
// save image as '[GUID].pgm'
char filename[256];
sprintf(filename, "%" PRIu64 "%s",list->ids[i].guid,IMAGE_FILE_EXTENSION);
imagefile=fopen(filename, "w");
if( imagefile == NULL) {
dc1394_log_error("Can't create %s", filename);
}
// adding the pgm file header
fprintf(imagefile,"P5\n%u %u 255\n", video_mode_width, video_mode_height);
// writing to the file
fwrite((const char *)frames[i]->image, 1, \
video_mode_width * video_mode_height, imagefile);
fclose(imagefile);
}
// exit cleanly
cleanup();
return(0);
}
dc1394error_t
dc1394_juju_capture_setup(platform_camera_t *craw, uint32_t num_dma_buffers,
uint32_t flags)
{
struct fw_cdev_create_iso_context create;
struct fw_cdev_start_iso start_iso;
dc1394error_t err;
dc1394video_frame_t proto;
int i, j, retval;
dc1394camera_t * camera = craw->camera;
if (flags & DC1394_CAPTURE_FLAGS_DEFAULT)
flags = DC1394_CAPTURE_FLAGS_CHANNEL_ALLOC |
DC1394_CAPTURE_FLAGS_BANDWIDTH_ALLOC;
craw->flags = flags;
// if capture is already set, abort
if (craw->capture_is_set>0)
return DC1394_CAPTURE_IS_RUNNING;
// if auto iso is requested, stop ISO (if necessary)
if (flags & DC1394_CAPTURE_FLAGS_AUTO_ISO) {
dc1394switch_t is_iso_on;
dc1394_video_get_transmission(camera, &is_iso_on);
if (is_iso_on == DC1394_ON) {
err=dc1394_video_set_transmission(camera, DC1394_OFF);
DC1394_ERR_RTN(err,"Could not stop ISO!");
}
}
if (capture_basic_setup(camera, &proto) != DC1394_SUCCESS) {
dc1394_log_error("basic setup failed");
return DC1394_FAILURE;
}
if (flags & (DC1394_CAPTURE_FLAGS_CHANNEL_ALLOC |
DC1394_CAPTURE_FLAGS_BANDWIDTH_ALLOC)) {
uint64_t channels_allowed = 0;
unsigned int bandwidth_units = 0;
int channel;
if (flags & DC1394_CAPTURE_FLAGS_CHANNEL_ALLOC)
channels_allowed = 0xffff;
if (flags & DC1394_CAPTURE_FLAGS_BANDWIDTH_ALLOC)
dc1394_video_get_bandwidth_usage (camera, &bandwidth_units);
err = juju_iso_allocate (craw, channels_allowed,
bandwidth_units, &craw->capture_iso_resource);
if (err == DC1394_SUCCESS) {
channel = craw->capture_iso_resource->channel;
} else if (err == DC1394_FUNCTION_NOT_SUPPORTED) {
channel = craw->node_id & 0x3f;
dc1394_log_warning ("iso allocation not available in this kernel, "
"using channel %d...", channel);
} else {
dc1394_log_error ("juju: Failed to allocate iso resources");
return err;
}
if (dc1394_video_set_iso_channel (camera, channel) != DC1394_SUCCESS)
return DC1394_NO_ISO_CHANNEL;
}
if (dc1394_video_get_iso_channel (camera, &craw->iso_channel)
!= DC1394_SUCCESS)
return DC1394_FAILURE;
dc1394_log_debug ("juju: Receiving from iso channel %d", craw->iso_channel);
craw->iso_fd = open(craw->filename, O_RDWR);
if (craw->iso_fd < 0) {
dc1394_log_error("error opening file: %s", strerror (errno));
return DC1394_FAILURE;
}
create.type = FW_CDEV_ISO_CONTEXT_RECEIVE;
create.header_size = craw->header_size;
create.channel = craw->iso_channel;
create.speed = SCODE_400;
err = DC1394_IOCTL_FAILURE;
if (ioctl(craw->iso_fd, FW_CDEV_IOC_CREATE_ISO_CONTEXT, &create) < 0) {
dc1394_log_error("failed to create iso context");
goto error_fd;
}
craw->iso_handle = create.handle;
craw->num_frames = num_dma_buffers;
craw->current = -1;
craw->buffer_size = proto.total_bytes * num_dma_buffers;
craw->buffer =
mmap(NULL, craw->buffer_size, PROT_READ | PROT_WRITE , MAP_SHARED, craw->iso_fd, 0);
err = DC1394_IOCTL_FAILURE;
if (craw->buffer == MAP_FAILED)
goto error_fd;
err = DC1394_MEMORY_ALLOCATION_FAILURE;
craw->frames = malloc (num_dma_buffers * sizeof *craw->frames);
if (craw->frames == NULL)
goto error_mmap;
for (i = 0; i < num_dma_buffers; i++) {
err = init_frame(craw, i, &proto);
if (err != DC1394_SUCCESS) {
dc1394_log_error("error initing frames");
break;
}
}
if (err != DC1394_SUCCESS) {
for (j = 0; j < i; j++)
release_frame(craw, j);
goto error_mmap;
}
for (i = 0; i < num_dma_buffers; i++) {
err = queue_frame(craw, i);
if (err != DC1394_SUCCESS) {
dc1394_log_error("error queuing");
goto error_frames;
}
}
// starting from here we use the ISO channel so we set the flag in
// the camera struct:
craw->capture_is_set = 1;
start_iso.cycle = -1;
start_iso.tags = FW_CDEV_ISO_CONTEXT_MATCH_ALL_TAGS;
start_iso.sync = 1;
start_iso.handle = craw->iso_handle;
retval = ioctl(craw->iso_fd, FW_CDEV_IOC_START_ISO, &start_iso);
err = DC1394_IOCTL_FAILURE;
if (retval < 0) {
dc1394_log_error("error starting iso");
goto error_frames;
}
// if auto iso is requested, start ISO
if (flags & DC1394_CAPTURE_FLAGS_AUTO_ISO) {
err=dc1394_video_set_transmission(camera, DC1394_ON);
DC1394_ERR_RTN(err,"Could not start ISO!");
craw->iso_auto_started=1;
}
return DC1394_SUCCESS;
error_frames:
for (i = 0; i < num_dma_buffers; i++)
release_frame(craw, i);
error_mmap:
munmap(craw->buffer, craw->buffer_size);
error_fd:
close(craw->iso_fd);
return err;
}
//--------------------------------------------------------------------
bool ofxVideoGrabberPtgrey::initGrabber(int w, int h, bool setUseTexture){
width = w;
height = h;
bUseTexture = setUseTexture;
// In format_7 the framerate is set by setting the packet_size
// this is used in dc1394_format7_set_roi()
// The following formula is from the libdc1394 faq
// http://damien.douxchamps.net/ieee1394/libdc1394/v2.x/faq/#How_can_I_work_out_the_packet_size_for_a_wanted_frame_rate
float bus_period = 0.000125; // for firewire 400
int frame_rate = 60;
int depth = 3;
int num_packets = (int)(1.0/(bus_period*frame_rate) + 0.5);
//packet_size = (width*height*depth + (num_packets*8) - 1)/(num_packets*8);
packet_size = DC1394_USE_MAX_AVAIL;
//first choose a device to use
if( bChooseDevice ) {
bool bFound = false;
for (uint32_t index = 0; index < deviceList->num; index++) {
if (deviceList->ids[index].unit == deviceID) {
bFound = true;
deviceID = deviceList->ids[index].guid;
}
}
if (!bFound) {
printf("initGrabber warning: Device ID for unit %x not found, using first device\n", deviceID);
deviceID = deviceList->ids[0].guid;
}
} else if(deviceList->num > 0) {
deviceID = deviceList->ids[0].guid;
} else {
ofLog(OF_LOG_ERROR, "in initGrabber, No cameras found");
}
camera = dc1394_camera_new(driver, deviceID);
if (!camera) {
ofLog(OF_LOG_ERROR, "Failed to initialize camera with guid %x", deviceID);
return 1;
}
/*-----------------------------------------------------------------------
* setup capture
*-----------------------------------------------------------------------*/
err = dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_400);
if( err != DC1394_SUCCESS ) { ofLog(OF_LOG_ERROR, "failed to set iso speed"); }
err = dc1394_video_set_mode( camera, video_mode );
if( err != DC1394_SUCCESS ) { ofLog(OF_LOG_ERROR, "failed to set format 7 video mode"); }
err = dc1394_format7_set_color_coding(camera, video_mode, color_coding);
if( err != DC1394_SUCCESS ) { ofLog(OF_LOG_ERROR, "failed to set format 7 color coding"); }
err = dc1394_format7_set_packet_size(camera, video_mode, packet_size);
if( err != DC1394_SUCCESS ) { ofLog(OF_LOG_ERROR, "failed to set format 7 packet_size"); }
err = dc1394_format7_set_roi(camera, video_mode, color_coding, packet_size, 0,0, width,height);
if( err != DC1394_SUCCESS ) {
ofLog(OF_LOG_ERROR, "failed to set format 7");
}
//err = dc1394_video_set_framerate(camera, framerate);
//DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not set framerate");
err = dc1394_capture_setup(camera,2, DC1394_CAPTURE_FLAGS_DEFAULT);
if( err != DC1394_SUCCESS ) { ofLog(OF_LOG_ERROR, "failed to setup dma capturing"); }
/*-----------------------------------------------------------------------
* set camera's features
*-----------------------------------------------------------------------*/
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_FEATURE_MODE_MANUAL);
err = dc1394_feature_set_value(camera, DC1394_FEATURE_BRIGHTNESS, 200); //1-255
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_EXPOSURE, DC1394_FEATURE_MODE_MANUAL);
err = dc1394_feature_set_value(camera, DC1394_FEATURE_EXPOSURE, 62); //7-62
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL);
err = dc1394_feature_set_value(camera, DC1394_FEATURE_SHUTTER, 60); //1-263, 64 being the max for 60fps
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_MANUAL);
err = dc1394_feature_set_value(camera, DC1394_FEATURE_GAIN, 50); //16-64
//err = dc1394_feature_set_mode(camera, DC1394_FEATURE_PAN, DC1394_FEATURE_MODE_MANUAL);
//err = dc1394_feature_set_value(camera, DC1394_FEATURE_PAN, 56);
/*-----------------------------------------------------------------------
* report camera's features
*-----------------------------------------------------------------------*/
err=dc1394_feature_get_all(camera,&features);
if (err!=DC1394_SUCCESS) {
dc1394_log_warning("Could not get feature set");
}
else {
dc1394_feature_print_all(&features, stdout);
}
/*-----------------------------------------------------------------------
* have the camera start sending us data
*-----------------------------------------------------------------------*/
err=dc1394_video_set_transmission(camera, DC1394_ON);
//DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not start camera iso transmission");
//create pixel buffer
pixels = new unsigned char[width * height * 3];
//create texture
if (bUseTexture) {
tex.allocate(width,height,GL_LUMINANCE);
memset(pixels, 0, width*height);
tex.loadData(pixels, width, height, GL_LUMINANCE);
}
}
dc1394error_t
dc1394_windows_capture_stop(platform_camera_t *craw)
{
DWORD dwBytesRet = 0;
DWORD ret;
if (craw->device_acquisition == INVALID_HANDLE_VALUE) {
dc1394_log_error("StopImageAcquisition: Called with invalid device handle\n");
return DC1394_FAILURE;
}
// Tear down the stream
ret = free_resources(craw);
if (ret) {
dc1394_log_error("free_resources: Error %ld\n", ret);
}
// put pCurrentBuffer on the list for the sake of cleanup
if (craw->pCurrentBuffer != NULL) {
craw->pCurrentBuffer->pNextBuffer = craw->pLastBuffer;
craw->pLastBuffer = craw->pCurrentBuffer;
}
while (craw->pLastBuffer) {
if (craw->pLastBuffer != craw->pCurrentBuffer) {
// check the IO status, just in case
for (unsigned int ii = 0; ii < craw->pLastBuffer->nSubBuffers; ++ii) {
if (!GetOverlappedResult(craw->device_acquisition, &craw->pLastBuffer->subBuffers[ii].overLapped, &dwBytesRet, TRUE)) {
dc1394_log_warning("dc1394_windows_capture_stop: Warning Buffer %d.%d has not been detached, error = %d\n", craw->pLastBuffer->index,ii,GetLastError());
}
}
}
// check the IO status, just in case
for(unsigned int ii = 0; ii<craw->pLastBuffer->nSubBuffers; ++ii) {
// close event: NOTE: must pre-populate correctly above
if(craw->pLastBuffer->subBuffers[ii].overLapped.hEvent != NULL) {
CloseHandle(craw->pLastBuffer->subBuffers[ii].overLapped.hEvent);
craw->pLastBuffer->subBuffers[ii].overLapped.hEvent = NULL;
}
}
// free data buffer
if (craw->pLastBuffer->pDataBuf)
GlobalFree(craw->pLastBuffer->pDataBuf);
// advance to next buffer
PACQUISITION_BUFFER pAcqBuffer = craw->pLastBuffer;
craw->pLastBuffer = craw->pLastBuffer->pNextBuffer;
// free buffer struct
GlobalFree(pAcqBuffer);
}
// clean up our junk
if (craw->device_acquisition != INVALID_HANDLE_VALUE) {
CloseHandle(craw->device_acquisition);
craw->device_acquisition = INVALID_HANDLE_VALUE;
}
craw->pFirstBuffer = craw->pLastBuffer = craw->pCurrentBuffer = NULL;
free (&craw->capture.frames);
craw->capture_is_set = 0;
return DC1394_SUCCESS;
}
dc1394error_t
dc1394_windows_capture_setup(platform_camera_t * craw, uint32_t num_dma_buffers,
uint32_t flags)
{
dc1394camera_t * camera = craw->camera;
dc1394error_t err;
if (flags & DC1394_CAPTURE_FLAGS_DEFAULT) {
flags = DC1394_CAPTURE_FLAGS_CHANNEL_ALLOC |
DC1394_CAPTURE_FLAGS_BANDWIDTH_ALLOC;
}
// if capture is already set, abort
if (craw->capture_is_set > 0) {
return DC1394_CAPTURE_IS_RUNNING;
}
craw->capture.flags = flags;
craw->allocated_channel = -1;
// if auto iso is requested, stop ISO (if necessary)
if (flags & DC1394_CAPTURE_FLAGS_AUTO_ISO) {
dc1394switch_t is_iso_on;
dc1394_video_get_transmission(camera, &is_iso_on);
if (is_iso_on == DC1394_ON) {
err=dc1394_video_set_transmission(camera, DC1394_OFF);
DC1394_ERR_RTN(err,"Could not stop ISO!");
}
}
craw->capture.frames =
malloc (num_dma_buffers * sizeof (dc1394video_frame_t));
if (!craw->capture.frames) {
goto fail;
}
err = capture_basic_setup(camera, craw->capture.frames);
if (err != DC1394_SUCCESS) {
goto fail;
}
err = windows_capture_setup (craw, num_dma_buffers, flags);
if (err != DC1394_SUCCESS) {
goto fail;
}
// if auto iso is requested, start ISO
if (flags & DC1394_CAPTURE_FLAGS_AUTO_ISO) {
err=dc1394_video_set_transmission(camera, DC1394_ON);
DC1394_ERR_RTN(err,"Could not start ISO!");
craw->iso_auto_started = 1;
}
craw->capture.num_dma_buffers = num_dma_buffers;
return DC1394_SUCCESS;
fail:
// free resources if they were allocated
if (craw->allocated_channel >= 0) {
if (dc1394_iso_release_channel (camera, craw->allocated_channel)
!= DC1394_SUCCESS)
dc1394_log_warning("Warning: Could not free ISO channel");
}
if (craw->allocated_bandwidth) {
if (dc1394_iso_release_bandwidth (camera, craw->allocated_bandwidth)
!= DC1394_SUCCESS)
dc1394_log_warning("Warning: Could not free bandwidth");
}
craw->allocated_channel = -1;
craw->allocated_bandwidth = 0;
free (craw->capture.frames);
craw->capture.frames = NULL;
dc1394_log_error ("Error: Failed to setup DMA capture");
return DC1394_FAILURE;
}
int main(int argc, char *argv[])
{
// first check for the correct number of arguments
if (argc != numArguments) {
printf("Wrong number of arguments, exiting\n");
exit(0);
}
time_t theTime = time(NULL);
struct tm *aTime = localtime(&theTime);
int day = aTime->tm_mday;
int month = aTime->tm_mon + 1;
int year = aTime->tm_year + 1900;
int hour = aTime->tm_hour;
int min = aTime->tm_min;
int sec = aTime->tm_sec;
char directory[128];
sprintf(directory, "/opt/data_collection/%d_%d_%d_%d_%d_%d", year, month, day, hour, min, sec);
char cmd[128];
sprintf(cmd, "mkdir %s", directory);
system(cmd);
double lapse=0;
double fps;
double ntime=0, ptime=0, tmp;
int index;
dc1394video_frame_t *frame;
dc1394error_t err;
int cam_id=0;
char fileName[128];
// init 1394
d = dc1394_new();
if (!d) return 1;
// find cameras
dc1394camera_list_t * list;
err=dc1394_camera_enumerate (d, &list);
DC1394_ERR_RTN(err,"Failed to enumerate cameras");
if (list->num == 0) {
fprintf(stderr,"No cameras found\n");
return 1;
}
else {
if (list->num<cam_id+1) {
fprintf(stderr,"Not enough cameras found for id\n");
return 1;
}
}
// use selected camera
camera = dc1394_camera_new (d, list->ids[cam_id].guid);
if (!camera) {
dc1394_log_error("Failed to initialize camera with guid %llx", list->ids[cam_id].guid);
return 1;
}
dc1394_camera_free_list (list);
// setup video format
dc1394video_mode_t video_mode;
if (color == 0) {
printf("video mode is MONO\n");
video_mode = DC1394_VIDEO_MODE_640x480_MONO8;
} else {
printf("video mode is RGB8\n");
video_mode = DC1394_VIDEO_MODE_640x480_RGB8;
}
dc1394framerate_t framerate = DC1394_FRAMERATE_7_5;
//dc1394_video_set_transmission(video_mode, DC1394_OFF); // just in case
dc1394_video_set_mode(camera, video_mode);
dc1394_video_set_framerate(camera, framerate);
dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_400);
// setup catpure
err=dc1394_capture_setup(camera, 10, DC1394_CAPTURE_FLAGS_DEFAULT);
if (err!=DC1394_SUCCESS) {
fprintf(stderr,"Could not set capture!\n");
return 0;
}
// start image transmission
dc1394_video_set_transmission(camera, DC1394_ON);
// first, see what we are controlling manually vs. auto
autoExposure = atoi(argv[1]);
autoGain = atoi(argv[3]);
autoShutter = atoi(argv[5]);
autoBrightness = atoi(argv[7]);
// set what we want to control to manual...
if (autoExposure == 1) {
dc1394_feature_set_mode(camera, DC1394_FEATURE_EXPOSURE, DC1394_FEATURE_MODE_AUTO);
} else {
dc1394_feature_set_mode(camera, DC1394_FEATURE_EXPOSURE, DC1394_FEATURE_MODE_MANUAL);
}
if (autoGain == 1) {
dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_AUTO);
} else {
dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_MANUAL);
}
if (autoShutter == 1) {
dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_AUTO);
} else {
dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL);
}
if (autoBrightness == 1) {
dc1394_feature_set_mode(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_FEATURE_MODE_AUTO);
} else {
dc1394_feature_set_mode(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_FEATURE_MODE_MANUAL);
}
// print out the current features
dc1394featureset_t features;
err=dc1394_feature_get_all(camera, &features);
if (err!=DC1394_SUCCESS) {
dc1394_log_warning("Could not get the feature set");
}
else {
dc1394_feature_print_all(&features, stdout);
}
// set the exposure level
if (argc == numArguments) {
exposure = atoi(argv[2]);
}
err=dc1394_feature_set_value(camera, DC1394_FEATURE_EXPOSURE, exposure);
if (err!=DC1394_SUCCESS) {
printf("Could NOT set the exposure!\n");
} else {
printf("exposure set to %d\n", exposure);
}
// set the gain
if (argc == numArguments) {
gain = atoi(argv[4]);
}
err=dc1394_feature_set_value(camera, DC1394_FEATURE_GAIN, gain);
if (err!=DC1394_SUCCESS) {
printf("Could NOT set the gain!\n");
} else {
printf("gain set to %d\n", gain);
}
// set the shutter
if (argc == numArguments) {
shutter = atoi(argv[6]);
}
err=dc1394_feature_set_value(camera, DC1394_FEATURE_SHUTTER, shutter);
if (err!=DC1394_SUCCESS) {
printf("Could NOT set the shutter!\n");
} else {
printf("shutter set to %d\n", shutter);
}
// set the brightness
if (argc == numArguments) {
brightness = atoi(argv[8]);
}
err=dc1394_feature_set_value(camera, DC1394_FEATURE_BRIGHTNESS, brightness);
if (err!=DC1394_SUCCESS) {
printf("Could NOT set the brightness!\n");
} else {
printf("shutter set to %d\n", brightness);
}
// print out the current features
//dc1394featureset_t features;
err=dc1394_feature_get_all(camera, &features);
if (err!=DC1394_SUCCESS) {
dc1394_log_warning("Could not get the feature set");
}
else {
dc1394_feature_print_all(&features, stdout);
}
// go ahead and log our settings to a text file in the directory we created
FILE *file;
char fileNameSettings[256];
sprintf(fileNameSettings, "%s/settings.txt", directory);
file = fopen(fileNameSettings, "a+");
fprintf(file,"exposure=%d,%d\n", autoExposure, exposure);
fprintf(file,"gain=%d,%d\n", autoGain, gain);
fprintf(file,"shutter=%d,%d\n",autoShutter, shutter);
fprintf(file,"brightness=%d,%d\n",autoBrightness, brightness);
fclose(file);
// start the main loop
int quit = 0;
while (!quit) {
// capture image
err=dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_WAIT, &frame);/* Capture */
DC1394_ERR_RTN(err,"Problem getting an image");
// return buffer
dc1394_capture_enqueue(camera, frame);
int t=0;
if (color == 1) {
t=3;
} else {
t=1;
}
IplImage *tmp = cvCreateImage(cvSize(640,480),8,t);
memcpy(tmp->imageData, frame->image, 640*480*t);
cvShowImage("image", tmp);
char c = cvWaitKey(10);
// save the image
sprintf(fileName, "%s/frame%06d.bmp", directory, count);
count++;
cvSaveImage(fileName, tmp, 0);
cvReleaseImage(&tmp);
} // end loop
return 0;
}
dc1394error_t
platform_capture_stop(platform_camera_t *craw)
{
dc1394camera_t * camera = craw->camera;
int err;
if (craw->capture_is_set>0) {
// unlisten
if (ioctl(craw->capture.dma_fd, VIDEO1394_IOC_UNLISTEN_CHANNEL,
&(craw->iso_channel)) < 0)
return DC1394_IOCTL_FAILURE;
// release
if (craw->capture.dma_ring_buffer) {
munmap((void*)craw->capture.dma_ring_buffer,craw->capture.dma_buffer_size);
}
while (close(craw->capture.dma_fd) != 0) {
dc1394_log_debug("waiting for dma_fd to close");
sleep (1);
}
craw->capture.dma_fd = -1;
free (craw->capture.frames);
craw->capture.frames = NULL;
// this dma_device file is allocated by the strdup() function and can be freed here without problems.
free(craw->capture.dma_device_file);
craw->capture.dma_device_file=NULL;
// capture is not set anymore
craw->capture_is_set=0;
// free ressources if they were allocated
if (craw->allocated_channel >= 0) {
if (dc1394_iso_release_channel (camera, craw->allocated_channel)
!= DC1394_SUCCESS)
dc1394_log_warning("Warning: Could not free ISO channel");
}
if (craw->allocated_bandwidth) {
if (dc1394_iso_release_bandwidth (camera, craw->allocated_bandwidth)
!= DC1394_SUCCESS)
dc1394_log_warning("Warning: Could not free bandwidth");
}
craw->allocated_channel = -1;
craw->allocated_bandwidth = 0;
// stop ISO if it was started automatically
if (craw->iso_auto_started>0) {
err=dc1394_video_set_transmission(camera, DC1394_OFF);
DC1394_ERR_RTN(err,"Could not stop ISO!");
craw->iso_auto_started=0;
}
// free the additional capture handle
raw1394_destroy_handle(craw->capture.handle);
}
else {
return DC1394_CAPTURE_IS_NOT_SET;
}
return DC1394_SUCCESS;
}
/*****************************************************
capture_linux_setup
This sets up the dma for the given camera.
capture_basic_setup must be called before
******************************************************/
static dc1394error_t
capture_linux_setup(platform_camera_t * craw, uint32_t num_dma_buffers)
{
struct video1394_mmap vmmap;
struct video1394_wait vwait;
uint32_t i;
dc1394video_frame_t * f;
memset(&vmmap, 0, sizeof(vmmap));
memset(&vwait, 0, sizeof(vwait));
if (open_dma_device(craw) != DC1394_SUCCESS) {
dc1394_log_warning("Could not open video1394 device file in /dev");
return DC1394_INVALID_VIDEO1394_DEVICE;
}
vmmap.sync_tag= 1;
vmmap.nb_buffers= num_dma_buffers;
vmmap.flags= VIDEO1394_SYNC_FRAMES;
vmmap.buf_size= craw->capture.frames[0].total_bytes; //number of bytes needed
vmmap.channel= craw->iso_channel;
/* tell the video1394 system that we want to listen to the given channel */
if (ioctl(craw->capture.dma_fd, VIDEO1394_IOC_LISTEN_CHANNEL, &vmmap) < 0) {
dc1394_log_error("VIDEO1394_IOC_LISTEN_CHANNEL ioctl failed: %s", strerror(errno));
close (craw->capture.dma_fd);
return DC1394_IOCTL_FAILURE;
}
// starting from here we use the ISO channel so we set the flag in the camera struct:
craw->capture_is_set=1;
craw->capture.dma_frame_size= vmmap.buf_size;
craw->capture.num_dma_buffers= vmmap.nb_buffers;
craw->capture.dma_last_buffer= -1;
vwait.channel= craw->iso_channel;
/* QUEUE the buffers */
for (i= 0; i < vmmap.nb_buffers; i++) {
vwait.buffer= i;
if (ioctl(craw->capture.dma_fd,VIDEO1394_IOC_LISTEN_QUEUE_BUFFER,&vwait) < 0) {
dc1394_log_error("VIDEO1394_IOC_LISTEN_QUEUE_BUFFER ioctl failed");
ioctl(craw->capture.dma_fd, VIDEO1394_IOC_UNLISTEN_CHANNEL, &(vwait.channel));
craw->capture_is_set=0;
close (craw->capture.dma_fd);
return DC1394_IOCTL_FAILURE;
}
}
craw->capture.dma_ring_buffer= mmap(0, vmmap.nb_buffers * vmmap.buf_size,
PROT_READ|PROT_WRITE,MAP_SHARED, craw->capture.dma_fd, 0);
/* make sure the ring buffer was allocated */
if (craw->capture.dma_ring_buffer == (uint8_t*)(-1)) {
dc1394_log_error("mmap failed!");
ioctl(craw->capture.dma_fd, VIDEO1394_IOC_UNLISTEN_CHANNEL, &vmmap.channel);
craw->capture_is_set=0;
close (craw->capture.dma_fd);
// This should be display if the user has low memory
if (vmmap.nb_buffers * vmmap.buf_size > sysconf (_SC_PAGESIZE) * sysconf (_SC_AVPHYS_PAGES)) {
dc1394_log_error("Unable to allocate DMA buffer.\nThe requested size (0x%ux or %ud MiB) is bigger than the available memory (0x%lux or %lud MiB).\nPlease free some memory before allocating the buffers",
vmmap.nb_buffers * vmmap.buf_size,
vmmap.nb_buffers * vmmap.buf_size/1048576,
sysconf (_SC_PAGESIZE) * sysconf (_SC_AVPHYS_PAGES),
sysconf (_SC_PAGESIZE) * sysconf (_SC_AVPHYS_PAGES)/1048576);
} else {
// if it's not low memory, then it's the vmalloc limit.
// VMALLOC_RESERVED not sufficient (default is 128MiB in recent kernels)
dc1394_log_error("Unable to allocate DMA buffer. The requested size (0x%x) may be larger than the usual default VMALLOC_RESERVED limit of 128MiB. To verify this, look for the following line in dmesg:\n'allocation failed: out of vmalloc space'\nIf you see this, reboot with the kernel boot parameter:\n'vmalloc=k'\nwhere k (in bytes) is larger than your requested DMA ring buffer size.\nNote that other processes share the vmalloc space so you may need a\nlarge amount of vmalloc memory.", vmmap.nb_buffers * vmmap.buf_size);
//}
}
return DC1394_IOCTL_FAILURE;
}
craw->capture.dma_buffer_size= vmmap.buf_size * vmmap.nb_buffers;
for (i = 0; i < num_dma_buffers; i++) {
f = craw->capture.frames + i;
if (i > 0)
memcpy (f, craw->capture.frames, sizeof (dc1394video_frame_t));
f->image = (unsigned char *)(craw->capture.dma_ring_buffer +
i * craw->capture.dma_frame_size);
f->id = i;
}
return DC1394_SUCCESS;
}
