void icvInitCapture_DC1394(){
int p;
_V_MW_ fprintf(stderr,"icvInitCapture_DC1394\n");
raw1394handle_t raw_handle = raw1394_new_handle();
if( raw_handle == 0 ) {
numPorts = 0;
return;
}
numPorts = raw1394_get_port_info(raw_handle, ports, MAX_PORTS);
raw1394_destroy_handle(raw_handle);
for (p = 0; p < numPorts; p++) {
handles[p] = dc1394_create_handle(p);
if (handles[p]==NULL) { numPorts=-1; return; /*ERROR_CLEANUP_EXIT*/ }
/* get the camera nodes and describe them as we find them */
camera_nodes = dc1394_get_camera_nodes(handles[p], &camCount[p], 0);
for (int i=0;i<camCount[p];i++) {
cameras[numCameras].cam.node = camera_nodes[i];
cameras[numCameras].portnum = p;
dc1394_stop_iso_transmission(handles[p], camera_nodes[i]);
numCameras++;
}
}
};
//---------------------------------------------------------------
void
Device1394::initDevice(int port)
{
MIRO_DBG(VIDEO, LL_DEBUG, "Device1394::initDevice()");
handle_ = dc1394_create_handle(port);
if (!handle_) {
throw Miro::Exception("Device1394::initDevice: unable to create handle");
}
int num_nodes = raw1394_get_nodecount(handle_);
int camera_count = 0;
nodeid_t * camera_nodes = dc1394_get_camera_nodes(handle_, &camera_count, 1);
MIRO_DBG_OSTR(VIDEO, LL_DEBUG,
"Device1394::initDevice: cameracount = " << camera_count);
if (camera_count < 1)
throw Miro::Exception("Device1394::initDevice: no camera found");
p_camera_->node = camera_nodes[0];
MIRO_DBG_OSTR(VIDEO, LL_DEBUG,
"Device1394::initDevice: node = " <<
p_camera_->node << "/" << num_nodes);
if (p_camera_->node == num_nodes - 1)
throw Miro::Exception("Device1394::initDevice: camera is highest numbered node.");
dc1394_stop_iso_transmission(handle_, p_camera_->node);
if (dc1394_get_camera_feature_set(handle_, p_camera_->node, &features_) != DC1394_SUCCESS)
throw Miro::Exception("Device1394::initDevice: unable to get camera features");
if (Miro::Log::level() >= Miro::Log::LL_NOTICE)
dc1394_print_feature_set(&features_);
}
static int dc1394_v1_read_header(AVFormatContext *c, AVFormatParameters * ap)
{
dc1394_data* dc1394 = c->priv_data;
AVStream* vst;
nodeid_t* camera_nodes;
int res;
struct dc1394_frame_format *fmt = NULL;
struct dc1394_frame_rate *fps = NULL;
if (dc1394_read_common(c,ap,&fmt,&fps) != 0)
return -1;
/* Now let us prep the hardware. */
dc1394->handle = dc1394_create_handle(0); /* FIXME: gotta have ap->port */
if (!dc1394->handle) {
av_log(c, AV_LOG_ERROR, "Can't acquire dc1394 handle on port %d\n", 0 /* ap->port */);
goto out;
}
camera_nodes = dc1394_get_camera_nodes(dc1394->handle, &res, 1);
if (!camera_nodes || camera_nodes[ap->channel] == DC1394_NO_CAMERA) {
av_log(c, AV_LOG_ERROR, "There's no IIDC camera on the channel %d\n", ap->channel);
goto out_handle;
}
res = dc1394_dma_setup_capture(dc1394->handle, camera_nodes[ap->channel],
0,
FORMAT_VGA_NONCOMPRESSED,
fmt->frame_size_id,
SPEED_400,
fps->frame_rate_id, 8, 1,
c->filename,
&dc1394->camera);
dc1394_free_camera_nodes(camera_nodes);
if (res != DC1394_SUCCESS) {
av_log(c, AV_LOG_ERROR, "Can't prepare camera for the DMA capture\n");
goto out_handle;
}
res = dc1394_start_iso_transmission(dc1394->handle, dc1394->camera.node);
if (res != DC1394_SUCCESS) {
av_log(c, AV_LOG_ERROR, "Can't start isochronous transmission\n");
goto out_handle_dma;
}
return 0;
out_handle_dma:
dc1394_dma_unlisten(dc1394->handle, &dc1394->camera);
dc1394_dma_release_camera(dc1394->handle, &dc1394->camera);
out_handle:
dc1394_destroy_handle(dc1394->handle);
out:
return -1;
}
static int dc1394_setup( struct dc1394_input *conf )
{
raw1394handle_t raw_handle;
nodeid_t *camera_nodes = NULL;
int numPorts;
int actual_count = 0, c, i;
struct raw1394_portinfo ports[16];
raw_handle = raw1394_new_handle();
if( ! raw_handle )
{
spook_log( SL_ERR,
"dc1394: unable to acquire a raw1394 handle" );
return -1;
}
numPorts = raw1394_get_port_info( raw_handle, ports, 16 );
raw1394_destroy_handle( raw_handle );
for( i = 0; i < numPorts; ++i )
{
int camCount = 0;
raw_handle = raw1394_new_handle();
raw1394_set_port( raw_handle, i );
camera_nodes = dc1394_get_camera_nodes( raw_handle,
&camCount, 1 );
raw1394_destroy_handle( raw_handle );
spook_log( SL_INFO, "dc1394: found %d cams on port %d",
camCount, i );
for( c = 0; c < camCount; ++c )
{
if( cam_setup( conf, actual_count, i,
camera_nodes[c], c ) < 0 )
return -1;
if( ++actual_count == conf->cam_count ) return 0;
}
// this doesn't work, fix later (just a li'l memory leak...)
//dc1394_free_camera_nodes( camera_nodes );
}
if( actual_count == 0 )
{
spook_log( SL_ERR, "dc1394: did not find any IIDC cameras" );
return -1;
}
if( actual_count < conf->cam_count )
spook_log( SL_WARN,
"dc1394: only found %d cameras, some outputs will be inactive",
actual_count );
return 0;
}
bool linuxfwCamera::findCamera() {
// get the number of ports
raw1394handle_t phandle = raw1394_new_handle();
if (phandle==NULL) {
printf( "no firewire ports found\n");
return false;
}
struct raw1394_portinfo pinf;
int ports = raw1394_get_port_info(phandle, &pinf, 0);
dc1394_destroy_handle(phandle);
//printf("firewire ports: %d\n",ports);
if (ports<1) {
printf("no firewire ports found\n");
return false;
}
// open ohci and asign handle to it
for (int i=0;i<ports;i++) {
//printf("trying port %d\n",i);
handle = dc1394_create_handle(i);
// get the camera nodes and describe them as we find them
numNodes = raw1394_get_nodecount(handle);
camera_nodes = dc1394_get_camera_nodes(handle,&numCameras,0);
//fflush(stdout);
//printf("found %d cameras\n",numCameras);
if (numCameras<1) {
dc1394_destroy_handle(handle);
continue;
} else {
cameraID = 0;
return true;
}
}
fprintf( stderr, "no firewire camera found\n");
return false;
}
static int dc1394_read_header(AVFormatContext *c, AVFormatParameters * ap)
{
dc1394_data* dc1394 = c->priv_data;
AVStream* vst;
nodeid_t* camera_nodes;
int res;
struct dc1394_frame_format *fmt;
struct dc1394_frame_rate *fps;
for (fmt = dc1394_frame_formats; fmt->width; fmt++)
if (fmt->pix_fmt == ap->pix_fmt && fmt->width == ap->width && fmt->height == ap->height)
break;
for (fps = dc1394_frame_rates; fps->frame_rate; fps++)
if (fps->frame_rate == av_rescale(1000, ap->time_base.den, ap->time_base.num))
break;
/* create a video stream */
vst = av_new_stream(c, 0);
if (!vst)
return -1;
av_set_pts_info(vst, 64, 1, 1000);
vst->codec->codec_type = CODEC_TYPE_VIDEO;
vst->codec->codec_id = CODEC_ID_RAWVIDEO;
vst->codec->time_base.den = fps->frame_rate;
vst->codec->time_base.num = 1000;
vst->codec->width = fmt->width;
vst->codec->height = fmt->height;
vst->codec->pix_fmt = fmt->pix_fmt;
/* packet init */
av_init_packet(&dc1394->packet);
dc1394->packet.size = avpicture_get_size(fmt->pix_fmt, fmt->width, fmt->height);
dc1394->packet.stream_index = vst->index;
dc1394->packet.flags |= PKT_FLAG_KEY;
dc1394->current_frame = 0;
dc1394->fps = fps->frame_rate;
vst->codec->bit_rate = av_rescale(dc1394->packet.size * 8, fps->frame_rate, 1000);
/* Now lets prep the hardware */
dc1394->handle = dc1394_create_handle(0); /* FIXME: gotta have ap->port */
if (!dc1394->handle) {
av_log(c, AV_LOG_ERROR, "Can't acquire dc1394 handle on port %d\n", 0 /* ap->port */);
goto out;
}
camera_nodes = dc1394_get_camera_nodes(dc1394->handle, &res, 1);
if (!camera_nodes || camera_nodes[ap->channel] == DC1394_NO_CAMERA) {
av_log(c, AV_LOG_ERROR, "There's no IIDC camera on the channel %d\n", ap->channel);
goto out_handle;
}
res = dc1394_dma_setup_capture(dc1394->handle, camera_nodes[ap->channel],
0,
FORMAT_VGA_NONCOMPRESSED,
fmt->frame_size_id,
SPEED_400,
fps->frame_rate_id, 8, 1,
c->filename,
&dc1394->camera);
dc1394_free_camera_nodes(camera_nodes);
if (res != DC1394_SUCCESS) {
av_log(c, AV_LOG_ERROR, "Can't prepare camera for the DMA capture\n");
goto out_handle;
}
res = dc1394_start_iso_transmission(dc1394->handle, dc1394->camera.node);
if (res != DC1394_SUCCESS) {
av_log(c, AV_LOG_ERROR, "Can't start isochronous transmission\n");
goto out_handle_dma;
}
return 0;
out_handle_dma:
dc1394_dma_unlisten(dc1394->handle, &dc1394->camera);
dc1394_dma_release_camera(dc1394->handle, &dc1394->camera);
out_handle:
dc1394_destroy_handle(dc1394->handle);
out:
return -1;
}
int CameraDcam::findCameraByGuid(void)
{
/*-----------------------------------------------------------------------
* get the camera nodes and describe them as we find them
* Number of available ports is known globally.
*-----------------------------------------------------------------------*/
//as the root node is not determined statically we may reset the bus in order to make a camera become
//NOT a root node.
//Uses generally the first camera found on bus.
int portNum,resetNum, numNodes, foundCamerasOnBus;
int resetBus = 1;
nodeid_t * camera_nodes = NULL;
for (resetNum=0; resetNum < MAX_RESETS && resetBus == 1; resetNum++)
{
resetBus = 0;
foundCamerasOnBus = 0;
for (portNum=0; portNum < firewireNumPorts; portNum++)
{
porthandle[portNum] = dc1394_create_handle(portNum);//handle for portNum
if (porthandle[portNum]==NULL)
{
GDOS_WARNING("error: Unable to aquire handle for port %i.\n", portNum);
}
//each port can have multiple cameras attached.
numNodes = 0;
camera_nodes = dc1394_get_camera_nodes(porthandle[portNum], &numNodes, 0); //last parameter defines if output is given.
//if any camera is found on this port...
if (numNodes > 0)
{
GDOS_DBG_INFO("found %i cameras to port %i.\n",numNodes, portNum);
//try to put them all at their position.
int k;
for (k = 0; k < numNodes; k++)
{
//try to get camera guid
dc1394_camerainfo info;
if (dc1394_get_camera_info(porthandle[portNum], camera_nodes[k], &info) == DC1394_SUCCESS)
{
//test if camera node is root, if so reset bus...
if (camera_nodes[k] == raw1394_get_nodecount(porthandle[portNum])-1)
{
//reset and retry if root
GDOS_WARNING("error: camera found as root node - resetting.\n");
raw1394_reset_bus(porthandle[portNum]);
int node_pos = 0;
for (node_pos=0; node_pos < 10; node_pos++)
resetBus = 1;
foundCamerasOnBus = foundCamerasOnBus - k; //no -1 as the array stqarts with 0
}
GDOS_DBG_INFO("found camera with guid:%x \n", info.euid_64);
//put camera in the global variable
if ((cameraGuid == 0) || (cameraGuid == (int) info.euid_64))
{
GDOS_DBG_INFO("using camera node:%i with guid:%x \n",camera_nodes[k], info.euid_64);
camera_node = camera_nodes[k];
dc1394CameraPortNo = portNum;
}
foundCamerasOnBus = foundCamerasOnBus + 1;
}//if camera_info
}//for numCameras
}//if numCamera > 0
else {
GDOS_ERROR("No cameras found! (%d nodes on the bus)\n"
" - could be you need to try a different 1394 device (modify code to fix)\n",
numNodes );
}
}//for firewireNumPorts
}//for MAXRESETS
GDOS_DBG_INFO("bus init complete found %i cameras.\n",foundCamerasOnBus);
if (resetNum == MAX_RESETS-1)
return FW_ERROR;
return DC1394_SUCCESS;
}
int
main(int argc, char *argv[])
{
XGCValues xgcv;
long background = 0x010203;
unsigned int channel;
unsigned int speed;
int i, p, cn;
raw1394handle_t raw_handle;
struct raw1394_portinfo ports[MAX_PORTS];
get_options(argc, argv);
/* process options */
switch (fps) {
case 1:
fps = FRAMERATE_1_875;
break;
case 3:
fps = FRAMERATE_3_75;
break;
case 15:
fps = FRAMERATE_15;
break;
case 30:
fps = FRAMERATE_30;
break;
case 60:
fps = FRAMERATE_60;
break;
default:
fps = FRAMERATE_7_5;
break;
}
switch (res) {
case 1:
res = MODE_640x480_YUV411;
device_width = 640;
device_height = 480;
format = XV_YUY2;
break;
case 2:
res = MODE_640x480_RGB;
device_width = 640;
device_height = 480;
format = XV_YUY2;
break;
default:
res = MODE_320x240_YUV422;
device_width = 320;
device_height = 240;
format = XV_UYVY;
break;
}
/* get the number of ports (cards) */
raw_handle = raw1394_new_handle();
if (raw_handle == NULL) {
perror("Unable to aquire a raw1394 handle\n");
perror("did you load the drivers?\n");
exit(-1);
}
numPorts = raw1394_get_port_info(raw_handle, ports, numPorts);
raw1394_destroy_handle(raw_handle);
if (verbose) printf("number of ports = %d\n", numPorts);
/* get dc1394 handle to each port */
for (p = 0; p < numPorts; p++) {
int camCount;
handles[p] = dc1394_create_handle(p);
if (handles[p] == NULL) {
perror("Unable to aquire a raw1394 handle\n");
perror("did you load the drivers?\n");
cleanup();
exit(-1);
}
/* get the camera nodes and describe them as we find them */
camera_nodes = dc1394_get_camera_nodes(handles[p], &camCount, verbose);
/* setup cameras for capture */
for (i = 0; i < camCount; i++) {
cameras[numCameras].node = camera_nodes[i];
if (dc1394_get_camera_feature_set
(handles[p], cameras[numCameras].node,
&features) != DC1394_SUCCESS) {
printf("unable to get feature set\n");
} else if (verbose) {
dc1394_print_feature_set(&features);
}
if (dc1394_get_iso_channel_and_speed
(handles[p], cameras[numCameras].node, &channel,
&speed) != DC1394_SUCCESS) {
printf("unable to get the iso channel number\n");
cleanup();
exit(-1);
}
if (dc1394_dma_setup_capture
(handles[p], cameras[numCameras].node, i + 1 /*channel */ ,
FORMAT_VGA_NONCOMPRESSED, res, SPEED_400, fps, NUM_BUFFERS,
DROP_FRAMES, device_name,
&cameras[numCameras]) != DC1394_SUCCESS) {
fprintf(stderr,
"unable to setup camera - check line %d of %s to make sure\n",
__LINE__, __FILE__);
perror("that the video mode, framerate and format are supported\n");
printf("by your camera(s)\n");
cleanup();
exit(-1);
}
/*have the camera start sending us data */
if (dc1394_start_iso_transmission
(handles[p], cameras[numCameras].node) != DC1394_SUCCESS) {
perror("unable to start camera iso transmission\n");
cleanup();
exit(-1);
}
numCameras++;
}
}
fflush(stdout);
if (numCameras < 1) {
perror("no cameras found :(\n");
cleanup();
exit(-1);
}
//set_manual_exposure_gain(0, 440, 30);
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:
fprintf(stderr, "Unknown format set (internal error)\n");
exit(255);
}
/* create OpenCV image wrappers */
for (cn = 0; cn < MAX_CAMERAS; cn++) {
if (cn < numCameras) {
iplImages[cn] =
cvCreateImage(cvSize(device_width, device_height),
IPL_DEPTH_8U, 3);
readOnlyImg =
cvCreateImageHeader(cvSize(device_width, device_height),
IPL_DEPTH_8U, 3);
} else {
iplImages[cn] = NULL;
}
}
/* initialize handvu */
hvInitialize(device_width, device_height);
hvLoadConductor(string(conductor_fname));
hvStartRecognition();
hvSetOverlayLevel(3);
if (async_processing) {
hvAsyncSetup(num_async_bufs, displayCallback);
hvAsyncGetImageBuffer(&m_async_image, &m_async_bufID);
if (sync_display) async_display_image = cvCloneImage(iplImages[0]);
}
/* make the window */
display = XOpenDisplay(getenv("DISPLAY"));
if (display == NULL) {
fprintf(stderr, "Could not open display \"%s\"\n", getenv("DISPLAY"));
cleanup();
exit(-1);
}
QueryXv();
if (adaptor < 0) {
cleanup();
exit(-1);
}
width = device_width;
height = device_height * numCameras;
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);
/* local main event loop */
while (1) {
if (async_processing) {
// asynchronous processing in HandVu
capture_frame();
process_frame();
if (sync_display) display_frame();
handle_events();
} else {
// synchronous processing in HandVu
capture_frame();
process_frame();
display_frame();
handle_events();
}
/* XPending */
} /* while not interrupted */
exit(0);
}
/*****************************************************************************
* ScanCameras
*****************************************************************************/
static void ScanCameras( dc1394_sys *sys, demux_t *p_demux )
{
struct raw1394_portinfo portinfo[MAX_IEEE1394_HOSTS];
raw1394handle_t tempFd;
dc1394_camerainfo info;
dc_camera *node_list = NULL;
nodeid_t *nodes = NULL;
int num_ports = 0;
int num_cameras = 0;
int nodecount;
int i, n;
memset( &portinfo, 0, sizeof(portinfo) );
msg_Dbg( p_demux, "Scanning for ieee1394 ports ..." );
tempFd = raw1394_new_handle();
if( !tempFd )
return VLC_EGENERIC;
raw1394_get_port_info( tempFd, portinfo, MAX_IEEE1394_HOSTS);
raw1394_destroy_handle( tempFd );
for( i=0; i < MAX_IEEE1394_HOSTS; i++ )
{
/* check if port exists and has at least one node*/
if( !portinfo[i].nodes )
continue;
nodes = NULL;
nodecount = 0;
tempFd = dc1394_create_handle( i );
/* skip this port if we can't obtain a valid handle */
if( !tempFd )
continue;
msg_Dbg( p_demux, "Found ieee1394 port %d (%s) ... "
"checking for camera nodes",
i, portinfo[i].name );
num_ports++;
nodes = dc1394_get_camera_nodes( tempFd, &nodecount, 0 );
if( nodecount )
{
msg_Dbg( p_demux, "Found %d dc1394 cameras on port %d (%s)",
nodecount, i, portinfo[i].name );
if( node_list )
node_list = realloc( node_list, sizeof(dc_camera) * (num_cameras+nodecount) );
else
node_list = malloc( sizeof(dc_camera) * nodecount);
for( n = 0; n < nodecount; n++ )
{
int result = 0;
result = dc1394_get_camera_info( tempFd, nodes[n], &info );
if( result == DC1394_SUCCESS )
{
node_list[num_cameras+n].uid = info.euid_64;
}
node_list[num_cameras+n].node = nodes[n];
node_list[num_cameras+n].port = i;
}
num_cameras += nodecount;
}
else
msg_Dbg( p_demux, "no cameras found on port %d (%s)",
i, portinfo[i].name );
if( tempFd )
dc1394_destroy_handle( tempFd );
}
sys->num_ports = num_ports;
sys->num_cameras = num_cameras;
sys->camera_nodes = node_list;
}
int dc1394Init(int cam, int width, int height, int max_frames, int trigger_mode, int shutter, int gain, int trig_on, int iso_speed, int frame_rate)
{
int numNodes;
nodeid_t * camera_nodes;
int numCameras;
if (first) {
bzero(Cams, sizeof(Cams));
first = 0;
}
printf("now is the time\n");
if ((cam < 0) || (cam >= MAX_CAMERAS)) {
fprintf(stderr, "Camera out of range, cam = %d must be between 0 and %d\n", cam, MAX_CAMERAS);
return 0;
}
/* clean up any active daq */
if (Cams[cam].thread_id != 0) {
void *status;
pthread_cancel(Cams[cam].thread_id);
pthread_join(Cams[cam].thread_id, &status);
Cams[cam].thread_id = 0;
}
/* now find the camera choke if not there or not correct */
Cams[cam].handle = dc1394_create_handle(0);
if (Cams[cam].handle==NULL)
{
fprintf( stderr, "Unable to aquire a raw1394 handle\n\n"
"Please check \n"
" - if the kernel modules `ieee1394',`raw1394' and `ohci1394' are loaded \n"
" - if you have read/write access to /dev/raw1394\n\n");
return(0);
}
/*-----------------------------------------------------------------------
* get the camera nodes and describe them as we find them
*-----------------------------------------------------------------------*/
numNodes = raw1394_get_nodecount(Cams[cam].handle);
camera_nodes = dc1394_get_camera_nodes(Cams[cam].handle,&numCameras,1);
if (numCameras<1)
{
fprintf( stderr, "no cameras found :(\n");
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
return(0);
}
/*-----------------------------------------------------------------------
* to prevent the iso-transfer bug from raw1394 system, check if
* camera is highest node. For details see
* http://linux1394.sourceforge.net/faq.html#DCbusmgmt
* and
* http://sourceforge.net/tracker/index.php?func=detail&aid=435107&group_id=8157&atid=108157
*-----------------------------------------------------------------------*/
if( camera_nodes[0] == numNodes-1)
{
fprintf( stderr, "\n"
"Sorry, your camera is the highest numbered node\n"
"of the bus, and has therefore become the root node.\n"
"The root node is responsible for maintaining \n"
"the timing of isochronous transactions on the IEEE \n"
"1394 bus. However, if the root node is not cycle master \n"
"capable (it doesn't have to be), then isochronous \n"
"transactions will not work. The host controller card is \n"
"cycle master capable, however, most cameras are not.\n"
"\n"
"The quick solution is to add the parameter \n"
"attempt_root=1 when loading the OHCI driver as a \n"
"module. So please do (as root):\n"
"\n"
" rmmod ohci1394\n"
" insmod ohci1394 attempt_root=1\n"
"\n"
"for more information see the FAQ at \n"
"http://linux1394.sourceforge.net/faq.html#DCbusmgmt\n"
"\n");
dc1394_destroy_handle(Cams[cam].handle);
dc1394_free_camera_nodes(camera_nodes);
return(0);
}
/*-----------------------------------------------------------------------
* setup capture
*-----------------------------------------------------------------------*/
if (dc1394_dma_setup_capture(Cams[cam].handle,camera_nodes[0],
0, /* channel */
FORMAT_VGA_NONCOMPRESSED,
MODE_640x480_MONO,
SPEED_400,
FRAMERATE_30,
3, /* frames */
1,
"/dev/video1394/0",
&Cams[cam].camera)!=DC1394_SUCCESS)
{
fprintf( stderr,"unable to setup camera-\n"
"check line %d of %s to make sure\n"
"that the video mode,framerate and format are\n"
"supported by your camera\n",
__LINE__,__FILE__);
dc1394_dma_release_camera(Cams[cam].handle,&Cams[cam].camera);
Cams[cam].dma_active = 0;
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
dc1394_free_camera_nodes(camera_nodes);
return(0);
}
dc1394_free_camera_nodes(camera_nodes);
/* set trigger mode */
if( dc1394_set_trigger_mode(Cams[cam].handle, Cams[cam].camera.node, trigger_mode)
!= DC1394_SUCCESS)
{
fprintf( stderr, "unable to set camera trigger mode\n");
/*
dc1394_dma_release_camera(Cams[cam].handle,&Cams[cam].camera);
Cams[cam].dma_active = 0;
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
return(0);
*/
}
/* eventually the same for the shutter and gain */
if (dc1394_set_trigger_on_off(Cams[cam].handle, Cams[cam].camera.node,
trig_on) != DC1394_SUCCESS)
{
fprintf(stderr, "unable to set trigger on to %d\n", trig_on);
}
/*-----------------------------------------------------------------------
* have the camera start sending us data
*-----------------------------------------------------------------------*/
if (dc1394_start_iso_transmission(Cams[cam].handle,Cams[cam].camera.node) !=DC1394_SUCCESS)
{
fprintf( stderr, "unable to start camera iso transmission\n");
dc1394_dma_release_camera(Cams[cam].handle,&Cams[cam].camera);
Cams[cam].dma_active = 0;
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
return(0);
}
Cams[cam].running = 1;
/* make room for the answers and write down all of the knobs for later use */
if ( (width != Cams[cam].width) ||
(height != Cams[cam].height) ||
(max_frames != Cams[cam].max_frames) ){
if (Cams[cam].frames != NULL)
free(Cams[cam].frames);
Cams[cam].frames = (unsigned char *)malloc(width*height*max_frames);
if (Cams[cam].frames == NULL) {
fprintf(stderr, "Could not allocate memory for %d frames (%d x %d)\n", max_frames, width, height);
dc1394_dma_release_camera(Cams[cam].handle,&Cams[cam].camera);
Cams[cam].dma_active = 0;
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
Cams[cam].max_frames = 0;
return(0);
}
Cams[cam].times = (double *)malloc(max_frames * sizeof(double));
if (Cams[cam].times == NULL) {
fprintf(stderr, "Could not allocate memory for %d times\n", max_frames);
dc1394_dma_release_camera(Cams[cam].handle,&Cams[cam].camera);
free( Cams[cam].frames );
Cams[cam].dma_active = 0;
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
Cams[cam].max_frames = 0;
return(0);
}
Cams[cam].width = width;
Cams[cam].height = height;
Cams[cam].max_frames = max_frames;
}
Cams[cam].next_frame = 0;
Cams[cam].trigger_mode = trigger_mode;
Cams[cam].shutter = shutter;
Cams[cam].gain = gain;
if (pthread_create(&Cams[cam].thread_id, NULL, AcquireFrames, (void *)cam) != 0) {
fprintf(stderr, "Could not create thread to handle camera daq\n");
dc1394_stop_iso_transmission(Cams[cam].handle,Cams[cam].camera.node);
Cams[cam].running = 0;
dc1394_dma_release_camera(Cams[cam].handle,&Cams[cam].camera);
Cams[cam].dma_active = 0;
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
return(0);
}
return(1);
}
