static void
list_cameras (dc1394_t *dc1394_cxt, dc1394camera_list_t *cam_list)
{
dc1394error_t err;
int i;
printf ("bus_id\tguid \tunit\tmodel (vendor)\n");
for (i = 0; i < cam_list->num; ++i)
{
dc1394camera_t *camera = NULL;
camera = dc1394_camera_new_unit (dc1394_cxt, cam_list->ids[i].guid, cam_list->ids[i].unit);
if (camera != NULL)
{
uint32_t port = -1;
err = dc1394_camera_get_linux_port (camera, &port);
if (err == DC1394_SUCCESS)
{
printf ("%6d", port);
}
else
{
printf (" n/a");
}
printf ("\t0x%016" PRIx64 "\t%4" PRIu16 "\t%s (%s)\n",
camera->guid, camera->unit, camera->model, camera->vendor);
dc1394_camera_free (camera);
camera = NULL;
}
}
}
CameraInfo* FWCamera::getCameraInfos(int deviceNumber)
{
#ifdef AVG_ENABLE_1394_2
dc1394_t* pDC1394 = dc1394_new();
if (pDC1394 == 0) {
AVG_ASSERT(false);
return NULL;
}
dc1394camera_list_t * pCameraList;
int err=dc1394_camera_enumerate(pDC1394, &pCameraList);
if (err != DC1394_SUCCESS) {
AVG_ASSERT(false);
return NULL;
}
if (pCameraList->num != 0) {
dc1394camera_id_t id = pCameraList->ids[deviceNumber];
dc1394camera_t * pCamera = dc1394_camera_new_unit(pDC1394, id.guid,
id.unit);
if (pCamera) {
stringstream deviceID;
deviceID << hex << id.guid;//pCamera->guid;
CameraInfo* camInfo = new CameraInfo("Firewire", deviceID.str());
getCameraControls(pCamera, camInfo);
getCameraImageFormats(pCamera, camInfo);
dc1394_camera_free(pCamera);
dc1394_camera_free_list(pCameraList);
dc1394_free(pDC1394);
return camInfo;
}
}
#endif
return NULL;
}
vector<CameraInfo> CameraIIDC::getCameraList(){
dc1394_t *context = dc1394_new();
dc1394camera_list_t *camera_list;
dc1394error_t err;
err = dc1394_camera_enumerate(context, &camera_list);
DC1394_WRN(err,"libdc1394: Failed to enumerate cameras!");
vector<CameraInfo> ret;
for (unsigned int i=0; i<camera_list->num; i++) {
CameraInfo info;
dc1394camera_t *cam;
cam = dc1394_camera_new(context, camera_list->ids[i].guid);
//info.vendor = std::string(cam->vendor ? cam->vendor : "");
info.vendor = "IIDC";
info.model = string(cam->model ? cam->model : "");
info.busID = (unsigned int)cam->guid;
dc1394_camera_free(cam);
ret.push_back(info);
}
dc1394_camera_free_list(camera_list);
dc1394_free(context);
return ret;
}
ofxLibdc::~ofxLibdc() {
if(camera != NULL) {
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
}
stopLibdcContext();
}
Libdc1394SequenceGrabber::~Libdc1394SequenceGrabber()
{
msg(osg::INFO) << "~LibdcSequenceGrabber" << std::endl;
if (_camera) dc1394_camera_free(_camera);
}
void CvCaptureCAM_DC1394_v2_CPP::close()
{
if (dcCam)
{
// check for fileno valid before using
int fileno=dc1394_capture_get_fileno(dcCam);
if (fileno>=0 && FD_ISSET(fileno, &dc1394.camFds))
FD_CLR(fileno, &dc1394.camFds);
dc1394_video_set_transmission(dcCam, DC1394_OFF);
dc1394_capture_stop(dcCam);
dc1394_camera_free(dcCam);
dcCam = 0;
started = false;
}
for (int i = 0; i < NIMG; i++)
{
cvReleaseImage(&img[i]);
cvReleaseImage(&maps[i][0]);
cvReleaseImage(&maps[i][1]);
}
if (frameC)
{
if (frameC->image)
free(frameC->image);
free(frameC);
frameC = 0;
}
}
int capture_final(capture_t *cap)
{
int i;
for (i = 0; i < cap->num_active; ++i) {
dc1394_video_set_transmission(cap->cameras[i], DC1394_OFF);
dc1394_capture_stop(cap->cameras[i]);
dc1394_camera_free(cap->cameras[i]);
}
cap->num_active = 0;
free(cap->cameras); cap->cameras = NULL;
if (cap->camera_list != NULL) {
dc1394_camera_free_list(cap->camera_list);
cap->camera_list = NULL;
}
cap->num_cameras = 0;
if (cap->dc1394_cxt != NULL) {
dc1394_free(cap->dc1394_cxt);
cap->dc1394_cxt = NULL;
}
return CAPTURE_SUCCESS;
}
/*-----------------------------------------------------------------------
* Releases the cameras and exits
*-----------------------------------------------------------------------*/
void cleanup_and_exit(dc1394camera_t *camera)
{
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
exit(1);
}
static void pdp_dc1394_free(t_pdp_dc1394 *x)
{
dc1394_video_set_transmission(x->camera, DC1394_OFF);
dc1394_capture_stop(x->camera);
dc1394_camera_free(x->camera);
dc1394_free (x->d);
}
VideoIIDC1394::~VideoIIDC1394(void)
{
#if defined(DUNE_WITH_DC1394)
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
#endif
}
/********************************
** Client is asking us to terminate connection to the device
*********************************/
bool Cindi_iidc::Disconnect() {
if (dcam) {
dc1394_capture_stop(dcam);
dc1394_camera_free(dcam);
}
IDMessage(getDeviceName(), "indi-iidc disconnected successfully!");
return true;
}
void
cleanup_cam( PGR_Cam *pgcp )
{
if( IS_CAPTURING(pgcp) ) dc1394_capture_stop( pgcp->pc_cam_p );
if( IS_TRANSMITTING(pgcp) )
dc1394_video_set_transmission( pgcp->pc_cam_p, DC1394_OFF );
/* dc1394_free_camera */
dc1394_camera_free( pgcp->pc_cam_p );
}
FirewireVideo::~FirewireVideo()
{
Stop();
// Close camera
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
dc1394_free (d);
}
FWCamera::~FWCamera()
{
#ifdef AVG_ENABLE_1394_2
dc1394_video_set_transmission(m_pCamera, DC1394_OFF);
dc1394_capture_stop(m_pCamera);
dc1394_camera_free(m_pCamera);
dc1394_free(m_pDC1394);
#endif
AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO, "Firewire camera closed.");
}
/**************************************************************************************
** Client is asking us to terminate connection to the device
***************************************************************************************/
bool FFMVCCD::Disconnect()
{
if (dcam) {
dc1394_capture_stop(dcam);
dc1394_camera_free(dcam);
}
IDMessage(getDeviceName(), "Point Grey FireFly MV disconnected successfully!");
return true;
}
void Camera::stop() {
eventLoopTimer->stop();
stopClockPulse();
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
dc1394_free (camDict);
emit stopped();
}
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;
}
CameraIIDC::~CameraIIDC(){
// Stop camera transmission
if(capturing)
stopCapture();
else
dc1394_capture_stop(cam);
// Gracefulle destruct the camera
dc1394_camera_free(cam);
dc1394_free(context);
}
static int dc1394_v2_close(AVFormatContext * context)
{
struct dc1394_data *dc1394 = context->priv_data;
dc1394_video_set_transmission(dc1394->camera, DC1394_OFF);
dc1394_capture_stop(dc1394->camera);
dc1394_camera_free(dc1394->camera);
dc1394_free(dc1394->d);
return 0;
}
//--------------------------------------------------------------------
of1394VideoGrabber::~of1394VideoGrabber()
{
if(!failedToInit) // if the init failed, then trying to do this stuff is a very bad idea
{
stopThread();
ofSleepMillis(200);
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
dc1394_free (d);
}
}
//--------------------------------------------------------------------
void ofxVideoGrabberPtgrey::close(){
if (camera != NULL) {
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
}
if (pixels != NULL){
delete[] pixels;
pixels = NULL;
}
tex.clear();
}
void
DisplayStatsAndExit(int sig)
{
int i;
fprintf(stderr,"\nFramerate statistics:\n");
fprintf(stderr,"bin centers:\t[");
for (i=0;i<bin_n;i++) {
if (i==0)
fprintf(stderr,"<");
fprintf(stderr,"%3.1f",(float)bin_min+(float)(bin_max-bin_min)/(float)bin_n*((float)i+.5));
if (i==bin_n-1)
fprintf(stderr,">");
if (i<bin_n)
fprintf(stderr,"\t");
}
fprintf(stderr,"]\n");
fprintf(stderr,"histogram:\t[");
for (i=0;i<bin_n;i++) {
if (bins[i]!=0)
fprintf(stderr,"%d",bins[i]);
else
fprintf(stderr," ");
if (i<bin_n)
fprintf(stderr,"\t");
}
fprintf(stderr,"]\n");
fprintf(stderr,"percentage:\t[");
for (i=0;i<bin_n;i++) {
if (bins[i]!=0)
fprintf(stderr,"%3.1f",(float)bins[i]/nframes*100);
else
fprintf(stderr," ");
if (i<bin_n)
fprintf(stderr,"\t");
}
fprintf(stderr,"]\n");
free(bins);
SDL_Quit();
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free (camera);
dc1394_free(d);
exit(0);
}
DC1394Camera::~DC1394Camera()
{
// Stop any background image processing
cleanup();
LOGGER.infoStream() << m_guid << ": Turning off camera ";
dc1394_video_set_transmission(m_camera, DC1394_OFF);
dc1394_capture_stop(m_camera);
// not sure why we would want to turn off the camera
// especially since we never turn it on anywhere
// dc1394_camera_set_power(m_camera, DC1394_OFF);
dc1394_camera_free(m_camera);
shutdownLibDC1394();
}
int list_cameras (dc1394_t * d, dc1394camera_list_t * list)
{
uint32_t i;
dc1394bool_t sff_available;
dc1394camera_t * camera;
for (i = 0; i < list->num; i++) {
sff_available = DC1394_FALSE;
camera = dc1394_camera_new (d, list->ids[i].guid);
dc1394_basler_sff_is_available (camera, &sff_available);
printf ("%02d:0x%"PRIx64":%s:%s:%s\n", i, camera->guid,
camera->vendor, camera->model, sff_available ? "SFF" : "NO SFF");
dc1394_camera_free (camera);
}
return 0;
}
int main(int argc, char *argv[])
{
dc1394camera_t * camera;
dc1394error_t err;
dc1394video_frame_t * frame;
dc1394_t * d;
dc1394camera_list_t * list;
d = dc1394_new (); /* Initialize libdc1394 */
if (!d)
return 1;
err=dc1394_camera_enumerate (d, &list); /* Find cameras */
DC1394_ERR_RTN(err,"Failed to enumerate cameras");
if (list->num == 0) { /* Verify that we have at least one camera */
dc1394_log_error("No cameras found");
return 1;
}
camera = dc1394_camera_new (d, list->ids[0].guid); /* Work with first camera */
if (!camera) {
dc1394_log_error("Failed to initialize camera with guid %llx", list->ids[0].guid);
return 1;
}
dc1394_camera_free_list (list);
err=dc1394_capture_setup(camera, 4, DC1394_CAPTURE_FLAGS_DEFAULT); /* Setup capture */
err=dc1394_video_set_transmission(camera, DC1394_ON); /* Start transmission */
err=dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_WAIT, &frame);/* Capture */
DC1394_ERR_RTN(err,"Problem getting an image");
err=dc1394_capture_enqueue(camera, frame); /* Release the buffer */
err=dc1394_video_set_transmission(camera, DC1394_OFF); /* Stop transmission */
err=dc1394_capture_stop(camera); /* Stop capture */
printf("Hello World\n"); /* Hey, this is a HELLO WORLD program!! */
dc1394_camera_free (camera); /* cleanup and exit */
dc1394_free (d);
return 0;
}
void Libdc1394Grabber::cleanupCamera()
{
closeCamera = true;
ofxThread::stopThread();
ofLog(OF_LOG_VERBOSE,"Stopped capture thread.");
//this sleep seems necessary, at least on OSX, to avoid an occasional hang on exit
ofSleepMillis(150);
dc1394switch_t is_iso_on = DC1394_OFF;
if(camera) {
if (dc1394_video_get_transmission(camera, &is_iso_on)!=DC1394_SUCCESS) {
is_iso_on = DC1394_ON; // try to shut ISO anyway
}
if (is_iso_on > DC1394_OFF) {
if (dc1394_video_set_transmission(camera, DC1394_OFF)!=DC1394_SUCCESS) {
ofLog(OF_LOG_ERROR, "Could not stop ISO transmission!");
}
}
}
ofLog(OF_LOG_VERBOSE,"Stopped ISO transmission.");
/* cleanup and exit */
if(cameraList)
dc1394_camera_free_list (cameraList);
if(camera) {
dc1394_capture_stop(camera);
dc1394_camera_free (camera);
camera = NULL;
}
ofLog(OF_LOG_VERBOSE,"Stopped camera.");
if(dc1394) {
dc1394_free (dc1394);
dc1394 = NULL;
}
if(pixels) {
delete [] pixels;
pixels = NULL;
}
printf("Closed!\n");
}
/*****************************************************************************
* Close:
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys = p_demux->p_sys;
/* Stop data transmission */
if( dc1394_video_set_transmission( p_sys->camera,
DC1394_OFF ) != DC1394_SUCCESS )
msg_Err( p_demux, "Unable to stop camera iso transmission" );
/* Close camera */
dc1394_capture_stop( p_sys->camera );
CloseAudioDev( p_demux );
dc1394_camera_free(p_sys->camera);
dc1394_free(p_sys->p_dccontext);
free( p_sys->video_device );
free( p_sys->audio_device );
free( p_sys );
}
void FWCamera::resetBus()
{
#ifdef AVG_ENABLE_1394_2
dc1394_t* pDC1394 = dc1394_new();
if (pDC1394 == 0) {
return;
}
dc1394camera_list_t * pCameraList;
int err=dc1394_camera_enumerate(pDC1394, &pCameraList);
if (err == DC1394_SUCCESS) {
if (pCameraList->num != 0) {
dc1394camera_t * pCam = dc1394_camera_new(pDC1394, pCameraList->ids[0].guid);
if (pCam) {
dc1394_reset_bus(pCam);
dc1394_camera_free(pCam);
}
}
dc1394_camera_free_list(pCameraList);
}
dc1394_free(pDC1394);
#endif
}
Camera::~Camera()
{
// Boost Thread
grab_thread->join();
// VideoCapture Interface
cvReleaseImage(&cv_image_);
// Stop transmission
err = dc1394_video_set_transmission(camera, DC1394_OFF);
// Stop capture
err = dc1394_capture_stop(camera);
// Power OFF
dc1394_camera_set_power(camera, DC1394_OFF);
// Cleanup camera
dc1394_camera_free(camera);
// Close dc1394
dc1394_free(d);
}
int main(int argc, char *argv[])
{
fitsfile *fptr;
long fpixel=1, nelements, naxes[3];
dc1394camera_t *camera;
int grab_n_frames;
struct timeval start_time, end_time;
time_t start_sec, end_sec;
suseconds_t start_usec, end_usec;
float elapsed_time, fps;
int i, status;
unsigned int min_bytes, max_bytes, max_height, max_width;
unsigned int actual_bytes;
uint64_t total_bytes = 0;
unsigned int width, height;
dc1394video_frame_t *frame=NULL;
dc1394_t * d;
dc1394camera_list_t * list;
dc1394error_t err;
char *filename;
grab_n_frames = atoi(argv[1]);
filename = argv[2];
width = 320;
height = 240;
naxes[0] = width;
naxes[1] = height;
naxes[2] = grab_n_frames;
nelements = naxes[0]*naxes[1]*naxes[2];
stderr = freopen("grab_cube.log", "w", stderr);
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;
}
camera = dc1394_camera_new (d, list->ids[0].guid);
if (!camera) {
dc1394_log_error("Failed to initialize camera with guid %"PRIx64,
list->ids[0].guid);
return 1;
}
dc1394_camera_free_list (list);
printf("Using camera with GUID %"PRIx64"\n", camera->guid);
/*-----------------------------------------------------------------------
* setup capture for format 7
*-----------------------------------------------------------------------*/
// err=dc1394_video_set_operation_mode(camera, DC1394_OPERATION_MODE_1394B);
// DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot operate at 1394B");
// libdc1394 doesn't work well with firewire800 yet so set to legacy 400 mode
dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_400);
// configure camera for format7
err = dc1394_video_set_mode(camera, DC1394_VIDEO_MODE_FORMAT7_1);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot choose format7_0");
printf ("I: video mode is format7_0\n");
err = dc1394_format7_get_max_image_size (camera, DC1394_VIDEO_MODE_FORMAT7_1,
&max_width, &max_height);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot get max image size for format7_0");
printf ("I: max image size is: height = %d, width = %d\n", max_height, max_width);
printf ("I: current image size is: height = %d, width = %d\n", height, width);
err = dc1394_format7_set_roi (camera,
DC1394_VIDEO_MODE_FORMAT7_1,
DC1394_COLOR_CODING_MONO16, // not sure why RAW8/16 don't work
DC1394_USE_MAX_AVAIL,
0, 0, // left, top
width, height); // width, height
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set roi");
printf ("I: roi is (0, 0) - (%d, %d)\n", width, height);
// set the frame rate to absolute value in frames/sec
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_FRAME_RATE, DC1394_FEATURE_MODE_MANUAL);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set framerate to manual");
err = dc1394_feature_set_absolute_control(camera, DC1394_FEATURE_FRAME_RATE, DC1394_TRUE);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set framerate to absolute mode");
err = dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_FRAME_RATE, 330.0);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set framerate");
printf("I: framerate is %f fps\n", 330.0);
// set the shutter speed to absolute value in seconds
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set shutter to manual");
err = dc1394_feature_set_absolute_control(camera, DC1394_FEATURE_SHUTTER, DC1394_TRUE);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set shutter to absolute mode");
err = dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_SHUTTER, 3.0e-3);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set shutter");
printf("I: exptime is %f s\n", 3.0e-3);
// set gain manually. use relative value here in range 48 to 730.
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_MANUAL);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set gain to manual");
err = dc1394_feature_set_value(camera, DC1394_FEATURE_GAIN, 400);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set gain");
printf ("I: gain is %d\n", 400);
// set brightness manually. use relative value in range 0 to 1023.
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_FEATURE_MODE_MANUAL);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set brightness to manual");
err = dc1394_feature_set_value(camera, DC1394_FEATURE_BRIGHTNESS, 100);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set brightness");
printf ("I: brightness is %d\n", 100);
err = dc1394_format7_get_total_bytes (camera, DC1394_VIDEO_MODE_FORMAT7_1, &total_bytes);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot get total bytes");
printf ("I: total bytes is %"PRIu64" before SFF enabled\n", total_bytes);
err=dc1394_capture_setup(camera, 16, DC1394_CAPTURE_FLAGS_DEFAULT);
DC1394_ERR_CLN_RTN(err, dc1394_camera_free(camera), "Error capturing");
/*-----------------------------------------------------------------------
* print allowed and used packet size
*-----------------------------------------------------------------------*/
err=dc1394_format7_get_packet_parameters(camera, DC1394_VIDEO_MODE_FORMAT7_1, &min_bytes, &max_bytes);
DC1394_ERR_RTN(err,"Packet para inq error");
printf( "camera reports allowed packet size from %d - %d bytes\n", min_bytes, max_bytes);
err=dc1394_format7_get_packet_size(camera, DC1394_VIDEO_MODE_FORMAT7_1, &actual_bytes);
DC1394_ERR_RTN(err,"dc1394_format7_get_packet_size error");
printf( "camera reports actual packet size = %d bytes\n", actual_bytes);
err=dc1394_format7_get_total_bytes(camera, DC1394_VIDEO_MODE_FORMAT7_1, &total_bytes);
DC1394_ERR_RTN(err,"dc1394_query_format7_total_bytes error");
printf( "camera reports total bytes per frame = %"PRId64" bytes\n",
total_bytes);
/*-----------------------------------------------------------------------
* have the camera start sending us data
*-----------------------------------------------------------------------*/
err=dc1394_video_set_transmission(camera,DC1394_ON);
if (err!=DC1394_SUCCESS) {
dc1394_log_error("unable to start camera iso transmission");
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
exit(1);
}
// set up FITS image and capture
fits_create_file(&fptr, filename, &status);
dc1394_get_image_size_from_video_mode(camera, DC1394_VIDEO_MODE_FORMAT7_1, &width, &height);
fits_create_img(fptr, USHORT_IMG, 3, naxes, &status);
/*-----------------------------------------------------------------------
* capture frames and measure the time for this operation
*-----------------------------------------------------------------------*/
gettimeofday(&start_time, NULL);
printf("Start capture:\n");
for( i = 0; i < grab_n_frames; ++i) {
/*-----------------------------------------------------------------------
* capture one frame
*-----------------------------------------------------------------------*/
err=dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_WAIT, &frame);
if (err!=DC1394_SUCCESS) {
dc1394_log_error("unable to capture");
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
exit(1);
}
// attempt to preallocate image array and write to memory before dumping to disk.
// turns out to be slow due to large size of images. cfitsio buffering is far
// more efficient.
//memcpy(im_buffer+2*i*naxes[0]*naxes[1],
//frame->image-1,
//naxes[0]*naxes[1]*sizeof(short));
// just writing each frame to the FITS file goes pretty fast
fits_write_img(fptr,
TUSHORT,
fpixel+i*naxes[0]*naxes[1],
naxes[0]*naxes[1],
frame->image-1,
&status);
// release buffer
dc1394_capture_enqueue(camera,frame);
}
gettimeofday(&end_time, NULL);
printf("End capture.\n");
/*-----------------------------------------------------------------------
* stop data transmission
*-----------------------------------------------------------------------*/
start_sec = start_time.tv_sec;
start_usec = start_time.tv_usec;
end_sec = end_time.tv_sec;
end_usec = end_time.tv_usec;
elapsed_time = (float)((end_sec + 1.0e-6*end_usec) - (start_sec + 1.0e-6*start_usec));
fps = grab_n_frames/elapsed_time;
printf("Elapsed time = %g seconds.\n", elapsed_time);
printf("Framerate = %g fps.\n", fps);
err=dc1394_video_set_transmission(camera,DC1394_OFF);
DC1394_ERR_RTN(err,"couldn't stop the camera?");
/*-----------------------------------------------------------------------
* save FITS image to disk
*-----------------------------------------------------------------------*/
//fits_write_img(fptr, TUSHORT, fpixel, naxes[0]*naxes[1]*naxes[2], im_buffer, &status);
fits_close_file(fptr, &status);
fits_report_error(stderr, status);
//free(im_buffer);
printf("wrote: %s\n", filename);
printf("Image is %d bits/pixel.\n", frame->data_depth);
/*-----------------------------------------------------------------------
* close camera, cleanup
*-----------------------------------------------------------------------*/
dc1394_capture_stop(camera);
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_camera_free(camera);
dc1394_free (d);
return 0;
}
