/*----------------------------------------------------------------------- * Returns the number of pixels in the image based upon the format *-----------------------------------------------------------------------*/ uint32_t of1394VideoGrabber::get_num_pixels(uint32_t format ) { uint32_t w,h; dc1394_get_image_size_from_video_mode(camera, format,&w,&h); return w*h; }
/** * Download image from FireFly */ void FFMVCCD::grabImage() { dc1394error_t err; dc1394video_frame_t *frame; uint32_t uheight, uwidth; int sub; uint16_t val; struct timeval start, end; // Let's get a pointer to the frame buffer uint8_t * image = PrimaryCCD.getFrameBuffer(); // Get width and height int width = PrimaryCCD.getSubW() / PrimaryCCD.getBinX(); int height = PrimaryCCD.getSubH() / PrimaryCCD.getBinY(); memset(image, 0, PrimaryCCD.getFrameBufferSize()); /*----------------------------------------------------------------------- * stop data transmission *-----------------------------------------------------------------------*/ gettimeofday(&start, NULL); for (sub = 0; sub < sub_count; ++sub) { IDMessage(getDeviceName(), "Getting sub %d of %d", sub, sub_count); err=dc1394_capture_dequeue(dcam, DC1394_CAPTURE_POLICY_WAIT, &frame); if (err != DC1394_SUCCESS) { IDMessage(getDeviceName(), "Could not capture frame"); } dc1394_get_image_size_from_video_mode(dcam,DC1394_VIDEO_MODE_640x480_MONO16, &uwidth, &uheight); if (DC1394_TRUE == dc1394_capture_is_frame_corrupt(dcam, frame)) { IDMessage(getDeviceName(), "Corrupt frame!"); continue; } // Fill buffer with random pattern for (int i=0; i < height ; i++) { for (int j=0; j < width; j++) { /* Detect unsigned overflow */ val = ((uint16_t *) image)[i*width+j] + ntohs(((uint16_t*) (frame->image))[i*width+j]); if (val > ((uint16_t *) image)[i*width+j]) { ((uint16_t *) image)[i*width+j] = val; } else { ((uint16_t *) image)[i*width+j] = 0xFFFF; } } } dc1394_capture_enqueue(dcam, frame); } err=dc1394_video_set_transmission(dcam,DC1394_OFF); IDMessage(getDeviceName(), "Download complete."); gettimeofday(&end, NULL); IDMessage(getDeviceName(), "Download took %d uS", (int) ((end.tv_sec - start.tv_sec) * 1000000 + (end.tv_usec - start.tv_usec))); // Let INDI::CCD know we're done filling the image buffer ExposureComplete(&PrimaryCCD); }
void ofxLibdc::applySettings() { if(camera) dc1394_capture_stop(camera); if(use1394b) { // assumes you want to run your 1394b camera at 800 Mbps dc1394_video_set_operation_mode(camera, DC1394_OPERATION_MODE_1394B); dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_800); } else { dc1394_video_set_operation_mode(camera, DC1394_OPERATION_MODE_LEGACY); dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_400); } dc1394framerate_t framerate; if(useFormat7) { videoMode = (dc1394video_mode_t) ((int) DC1394_VIDEO_MODE_FORMAT7_0 + format7Mode); } else { dc1394video_modes_t video_modes; dc1394_video_get_supported_modes(camera, &video_modes); dc1394color_coding_t coding; dc1394color_coding_t targetCoding = getLibdcType(imageType); for (int i = 0; i < video_modes.num; i++) { if (!dc1394_is_video_mode_scalable(video_modes.modes[i])) { dc1394video_mode_t curMode = video_modes.modes[i]; dc1394_get_color_coding_from_video_mode(camera, curMode, &coding); unsigned int curWidth, curHeight; dc1394_get_image_size_from_video_mode(camera, curMode, &curWidth, &curHeight); if (coding == targetCoding && width == curWidth && height == curHeight) { videoMode = curMode; break; } } if(i == video_modes.num - 1) { ofLog(OF_LOG_ERROR, "Camera does not support target mode."); return; } } // get fastest framerate // todo: make this settable dc1394framerates_t framerates; dc1394_video_get_supported_framerates(camera, videoMode, &framerates); framerate = framerates.framerates[framerates.num - 1]; } if(useFormat7) { quantizePosition(); quantizeSize(); dc1394_format7_set_roi(camera, videoMode, getLibdcType(imageType), DC1394_USE_MAX_AVAIL, left, top, width, height); unsigned int curWidth, curHeight; dc1394_format7_get_image_size(camera, videoMode, &curWidth, &curHeight); } else { dc1394_video_set_framerate(camera, framerate); } // contrary to the libdc1394 format7 demo, this should go after the roi setting dc1394_video_set_mode(camera, videoMode); dc1394_capture_setup(camera, OFXLIBDC_BUFFER_SIZE, DC1394_CAPTURE_FLAGS_DEFAULT); }
void FirewireVideo::init_camera( uint64_t guid, int dma_frames, dc1394speed_t iso_speed, dc1394video_mode_t video_mode, dc1394framerate_t framerate ) { if(video_mode>=DC1394_VIDEO_MODE_FORMAT7_0) throw VideoException("format7 modes need to be initialized through the constructor that allows for specifying the roi"); camera = dc1394_camera_new (d, guid); if (!camera) throw VideoException("Failed to initialize camera"); // Attempt to stop camera if it is already running dc1394switch_t is_iso_on = DC1394_OFF; dc1394_video_get_transmission(camera, &is_iso_on); if (is_iso_on==DC1394_ON) { dc1394_video_set_transmission(camera, DC1394_OFF); } cout << "Using camera with GUID " << camera->guid << endl; //----------------------------------------------------------------------- // setup capture //----------------------------------------------------------------------- if( iso_speed >= DC1394_ISO_SPEED_800) { err=dc1394_video_set_operation_mode(camera, DC1394_OPERATION_MODE_1394B); if( err != DC1394_SUCCESS ) throw VideoException("Could not set DC1394_OPERATION_MODE_1394B"); } err=dc1394_video_set_iso_speed(camera, iso_speed); if( err != DC1394_SUCCESS ) throw VideoException("Could not set iso speed"); err=dc1394_video_set_mode(camera, video_mode); if( err != DC1394_SUCCESS ) throw VideoException("Could not set video mode"); err=dc1394_video_set_framerate(camera, framerate); if( err != DC1394_SUCCESS ) throw VideoException("Could not set framerate"); err=dc1394_capture_setup(camera,dma_frames, DC1394_CAPTURE_FLAGS_DEFAULT); if( err != DC1394_SUCCESS ) throw VideoException("Could not setup camera - check settings"); //----------------------------------------------------------------------- // initialise width and height from mode //----------------------------------------------------------------------- dc1394_get_image_size_from_video_mode(camera, video_mode, &width, &height); Start(); }
void ofxLibdc::setup(int cameraNumber) { // create camera struct dc1394camera_list_t * list; dc1394_camera_enumerate (libdcContext, &list); camera = dc1394_camera_new (libdcContext, list->ids[cameraNumber].guid); if (!camera) { stringstream error; error << "Failed to initialize camera " << cameraNumber << " with guid " << list->ids[0].guid; ofLog(OF_LOG_ERROR, error.str()); return; } else { stringstream msg; msg << "Using camera with GUID " << camera->guid; ofLog(OF_LOG_VERBOSE, msg.str()); } dc1394_camera_free_list(list); // select highest res mode: dc1394video_modes_t video_modes; dc1394_video_get_supported_modes(camera, &video_modes); dc1394video_mode_t video_mode; dc1394color_coding_t coding; for (int i = video_modes.num - 1; i >= 0; i--) { if (!dc1394_is_video_mode_scalable(video_modes.modes[i])) { dc1394_get_color_coding_from_video_mode(camera, video_modes.modes[i], &coding); if (coding == DC1394_COLOR_CODING_MONO8) { video_mode = video_modes.modes[i]; break; } } if(i == 0) { ofLog(OF_LOG_ERROR, "Camera does not support DC1394_COLOR_CODING_MONO8."); return; } } dc1394_get_image_size_from_video_mode(camera, video_mode, &width, &height); // get highest framerate dc1394framerates_t framerates; dc1394_video_get_supported_framerates(camera, video_mode, &framerates); dc1394framerate_t framerate = framerates.framerates[framerates.num - 1]; // apply everything dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_400); dc1394_video_set_mode(camera, video_mode); dc1394_video_set_framerate(camera, framerate); dc1394_capture_setup(camera, 4, DC1394_CAPTURE_FLAGS_DEFAULT); // print out features dc1394featureset_t features; dc1394_feature_get_all(camera, &features); dc1394_feature_print_all(&features, stdout); }
ConventionalVideoMode::ConventionalVideoMode(dc1394camera_t* libdc1394camera, dc1394video_mode_t libdc1394mode) : VideoMode(libdc1394mode) { uint32_t width, height; dc1394error_t err; err = dc1394_get_image_size_from_video_mode(libdc1394camera, libdc1394mode, &width, &height); if (err != DC1394_SUCCESS) throw Error(err, "Cannot get image size from video mode"); SetImageSize(width, height); dc1394color_coding_t libdc1394coding; err = dc1394_get_color_coding_from_video_mode(libdc1394camera, libdc1394mode, &libdc1394coding); if (err != DC1394_SUCCESS) throw Error(err, "Cannot get color coding from video mode"); SetLibDC1394Coding(libdc1394coding); }
static PGR_Cam *setup_my_camera( QSP_ARG_DECL dc1394camera_t * cam_p ) { PGR_Cam *pgcp; // We could have multiple instances of the same model... pgcp = unique_camera_instance(QSP_ARG cam_p); pgcp->pc_cam_p = cam_p; pgcp->pc_feat_lp=NULL; pgcp->pc_in_use_lp=NULL; pgcp->pc_flags = 0; /* assume no B-mode unless we are told otherwise... */ if( set_default_video_mode(pgcp) < 0 ){ WARN("error setting default video mode"); cleanup_cam( pgcp ); return(NULL); } /* used to set B-mode stuff here... */ // What if the camera is a usb cam??? dc1394_video_set_iso_speed( cam_p, DC1394_ISO_SPEED_400 ); if( set_default_framerate(QSP_ARG pgcp) < 0 ){ // This happens for format7... //warn("error setting default framerate"); //cleanup_cam( pgcp ); //return(NULL); } dc1394_get_image_size_from_video_mode( pgcp->pc_cam_p, pgcp->pc_video_mode, &pgcp->pc_nCols, &pgcp->pc_nRows ); get_camera_features(pgcp); /* We need to poll if we have multiple cameras with different frame rates */ pgcp->pc_policy = DC1394_CAPTURE_POLICY_POLL; // or WAIT ... //pgcp->pc_policy = DC1394_CAPTURE_POLICY_WAIT; // or POLL ... // Make a data_obj context for the frames... pgcp->pc_do_icp = create_dobj_context( pgcp->pc_name ); return(pgcp); }
//-------------------------------------------------------------------- int of1394VideoGrabber::initGrabber() { // moved from constructor int i; printf("Making new camera\n"); d = dc1394_new (); err=dc1394_camera_enumerate (d, &list); DC1394_ERR_RTN(err,"Failed to enumerate cameras"); if (list->num == 0) { if(err!=0 && bVerbose)printf("\n No cameras found\n "); return 1; } camera = dc1394_camera_new (d, list->ids[0].guid); if (!camera) { if(err!=0 && bVerbose)printf("\n Failed to initialize camera with guid %PRIx64", list->ids[0].guid); return 1; } dc1394_camera_free_list (list); /*----------------------------------------------------------------------- * setup capture *-----------------------------------------------------------------------*/ dc1394_video_set_mode(camera, DC1394_VIDEO_MODE_FORMAT7_0); uint32_t f, f2; dc1394_format7_get_image_size(camera, DC1394_VIDEO_MODE_FORMAT7_0, &f, &f2); err=dc1394_capture_setup(camera,4, DC1394_CAPTURE_FLAGS_DEFAULT); DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not setup camera-\nmake sure that the video mode and framerate are\nsupported by your camera\n"); /*----------------------------------------------------------------------- * 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\n"); dc1394_get_image_size_from_video_mode(camera, video_mode, &width, &height); if(err != DC1394_SUCCESS){ cout<<"get image size error: "<<err<<endl; } printf("Size from video mode = %i wide %i high\n", width, height); pixels = new unsigned char[width*height*3]; // x3 for RGB pixels2 = new unsigned char[width*height*3]; // x3 for RGB tex.allocate(width,height,GL_LUMINANCE); err = dc1394_capture_dequeue( camera, DC1394_CAPTURE_POLICY_WAIT, &frame ) ; DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not capture a frame\n"); memcpy( pixels, frame->image, width * height*3) ; dc1394_capture_enqueue( camera, frame ) ; ofSleepMillis(10); startThread(true, false); failedToInit = false; dc1394_feature_set_mode(camera, DC1394_FEATURE_EXPOSURE, DC1394_FEATURE_MODE_MANUAL); dc1394_feature_set_mode(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_FEATURE_MODE_MANUAL); dc1394_feature_set_mode(camera, DC1394_FEATURE_GAMMA, DC1394_FEATURE_MODE_AUTO); dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL); dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_AUTO); dc1394_feature_set_mode(camera, DC1394_FEATURE_IRIS, DC1394_FEATURE_MODE_AUTO); dc1394_feature_set_mode(camera, DC1394_FEATURE_WHITE_BALANCE, DC1394_FEATURE_MODE_AUTO); dc1394_feature_set_mode(camera, DC1394_FEATURE_TEMPERATURE, DC1394_FEATURE_MODE_AUTO); dc1394_feature_set_mode(camera, DC1394_FEATURE_WHITE_SHADING, DC1394_FEATURE_MODE_AUTO); dc1394_feature_set_mode(camera, DC1394_FEATURE_SATURATION, DC1394_FEATURE_MODE_AUTO); dc1394_feature_set_mode(camera, DC1394_FEATURE_HUE, DC1394_FEATURE_MODE_AUTO); //Print features dc1394_feature_get_all(camera, &features); dc1394_feature_print_all(&features, stdout); return 0; }
int main(int argc, char *argv[]) { FILE* imagefile; dc1394camera_t *camera; unsigned int width, height; dc1394video_frame_t *frame=NULL; //dc1394featureset_t features; dc1394_t * d; dc1394camera_list_t * list; dc1394error_t err; int counter = 0; 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 %llx", list->ids[0].guid); return 1; } dc1394_camera_free_list (list); printf("Using camera with GUID %" PRIx64 "\n", camera->guid); /*----------------------------------------------------------------------- * setup capture *-----------------------------------------------------------------------*/ err=dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_400); DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not set iso speed"); err=dc1394_video_set_mode(camera, DC1394_VIDEO_MODE_FORMAT7_7); DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not set video mode\n"); err=dc1394_video_set_framerate(camera, DC1394_FRAMERATE_7_5); DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not set framerate\n"); err=dc1394_capture_setup(camera,4, DC1394_CAPTURE_FLAGS_DEFAULT); DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not setup camera-\nmake sure that the video mode and framerate are\nsupported by your camera\n"); /*----------------------------------------------------------------------- * 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\n"); for(;;){ /*----------------------------------------------------------------------- * capture one frame *-----------------------------------------------------------------------*/ err=dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_WAIT, &frame); DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not capture a frame\n"); dc1394_get_image_size_from_video_mode(camera, DC1394_VIDEO_MODE_FORMAT7_7, &width, &height); cv::Mat img = cv::Mat(height, width, CV_8U, frame->image); err = dc1394_capture_enqueue(camera, frame); frame=NULL; cv::imshow("Image", img); printf("Frame %d\n", counter); counter++; cv::waitKey(10); } /*----------------------------------------------------------------------- * stop data transmission *-----------------------------------------------------------------------*/ err=dc1394_video_set_transmission(camera,DC1394_OFF); DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not stop the camera?\n"); /*----------------------------------------------------------------------- * close camera *-----------------------------------------------------------------------*/ dc1394_video_set_transmission(camera, DC1394_OFF); dc1394_capture_stop(camera); dc1394_camera_free(camera); dc1394_free (d); return 0; }
bool CvCaptureCAM_DC1394_v2_CPP::startCapture() { int i; int code = 0; if (!dcCam) return false; if (isoSpeed > 0) { code = dc1394_video_set_iso_speed(dcCam, isoSpeed <= 100 ? DC1394_ISO_SPEED_100 : isoSpeed <= 200 ? DC1394_ISO_SPEED_200 : isoSpeed <= 400 ? DC1394_ISO_SPEED_400 : isoSpeed <= 800 ? DC1394_ISO_SPEED_800 : isoSpeed == 1600 ? DC1394_ISO_SPEED_1600 : DC1394_ISO_SPEED_3200); } if (frameWidth > 0 || frameHeight > 0) { dc1394video_mode_t bestMode = (dc1394video_mode_t) - 1; dc1394video_modes_t videoModes; dc1394_video_get_supported_modes(dcCam, &videoModes); for (i = 0; i < (int)videoModes.num; i++) { dc1394video_mode_t mode = videoModes.modes[i]; if (mode >= DC1394_VIDEO_MODE_FORMAT7_MIN && mode <= DC1394_VIDEO_MODE_FORMAT7_MAX) continue; int pref = -1; dc1394color_coding_t colorCoding; dc1394_get_color_coding_from_video_mode(dcCam, mode, &colorCoding); uint32_t width, height; dc1394_get_image_size_from_video_mode(dcCam, mode, &width, &height); if ((int)width == frameWidth || (int)height == frameHeight) { if (colorCoding == DC1394_COLOR_CODING_RGB8 || colorCoding == DC1394_COLOR_CODING_RGB16 || colorCoding == DC1394_COLOR_CODING_RAW8 || colorCoding == DC1394_COLOR_CODING_RAW16) { bestMode = mode; break; } if (colorCoding == DC1394_COLOR_CODING_YUV411 || colorCoding == DC1394_COLOR_CODING_YUV422 || (colorCoding == DC1394_COLOR_CODING_YUV444 && pref < 1)) { bestMode = mode; pref = 1; } if (colorCoding == DC1394_COLOR_CODING_MONO8 || (colorCoding == DC1394_COLOR_CODING_MONO16 && pref < 0)) { bestMode = mode; pref = 0; } } } if ((int)bestMode >= 0) code = dc1394_video_set_mode(dcCam, bestMode); } if (fps > 0) { dc1394video_mode_t mode; dc1394framerates_t framerates; double minDiff = DBL_MAX; dc1394framerate_t bestFps = (dc1394framerate_t) - 1; dc1394_video_get_mode(dcCam, &mode); dc1394_video_get_supported_framerates(dcCam, mode, &framerates); for (i = 0; i < (int)framerates.num; i++) { dc1394framerate_t ifps = framerates.framerates[i]; double fps1 = (1 << (ifps - DC1394_FRAMERATE_1_875)) * 1.875; double diff = fabs(fps1 - fps); if (diff < minDiff) { minDiff = diff; bestFps = ifps; } } if ((int)bestFps >= 0) code = dc1394_video_set_framerate(dcCam, bestFps); } if (cameraId == VIDERE) { bayerFilter = DC1394_COLOR_FILTER_GBRG; nimages = 2; uint32_t value = 0; dc1394_get_control_register(dcCam, 0x50c, &value); colorStereo = (value & 0x80000000) != 0; } code = dc1394_capture_setup(dcCam, nDMABufs, DC1394_CAPTURE_FLAGS_DEFAULT); if (code >= 0) { FD_SET(dc1394_capture_get_fileno(dcCam), &dc1394.camFds); dc1394_video_set_transmission(dcCam, DC1394_ON); if (cameraId == VIDERE) { enum { PROC_MODE_OFF, PROC_MODE_NONE, PROC_MODE_TEST, PROC_MODE_RECTIFIED, PROC_MODE_DISPARITY, PROC_MODE_DISPARITY_RAW }; int procMode = PROC_MODE_RECTIFIED; usleep(100000); uint32_t qval1 = 0x08000000 | (0x90 << 16) | ((procMode & 0x7) << 16); uint32_t qval2 = 0x08000000 | (0x9C << 16); dc1394_set_control_register(dcCam, 0xFF000, qval1); dc1394_set_control_register(dcCam, 0xFF000, qval2); } started = true; } return code >= 0; }
static void pdp_dc1394_bang(t_pdp_dc1394 *x) { /* if initialized, grab a frame and output it */ unsigned int w,h,nbpixels,packet_size,plane1,plane2; unsigned char *newimage=NULL; int pdp_packt,length,pos,i,encoding; t_pdp* header; t_image* image; unsigned char * data; static short int gain[4] = {0x7fff, 0x7fff, 0x7fff, 0x7fff}; /*----------------------------------------------------------------------- * capture one frame *-----------------------------------------------------------------------*/ //x->err=dc1394_capture_dequeue(x->camera, DC1394_CAPTURE_POLICY_WAIT, &x->frame); //DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not capture a frame"); //post("Could not capture a frame"); if (x->err=dc1394_capture_dequeue(x->camera, DC1394_CAPTURE_POLICY_WAIT, &x->frame)!=DC1394_SUCCESS) { post("Failed to capture from camera %d", x->err); return; } /* create new packet */ dc1394_get_image_size_from_video_mode(x->camera, x->video_mode, &x->width, &x->height); pdp_packt = pdp_packet_new_bitmap_rgb(x->width, x->height); header = pdp_packet_header(pdp_packt); //image = pdp_packet_image_info(pdp_packt); if (!header){ post("pdp_dc1394: ERROR: can't allocate packet"); return; } data = ( unsigned char *) pdp_packet_data(pdp_packt); int j; for (i=0; i<x->width; i++) for (j=0; j<x->height; j++) { data[(j*x->width+i)*3] = x->frame->image[j*x->width+i]; data[(j*x->width+i)*3+1] = x->frame->image[j*x->width+i]; data[(j*x->width+i)*3+2] = x->frame->image[j*x->width+i]; } //memcpy( data, x->frame->image, x->width*x->height*sizeof( unsigned char) ); /*FILE* imagefile=fopen(IMAGE_FILE_NAME, "wb"); if( imagefile == NULL) { perror( "Can't create '" IMAGE_FILE_NAME "'"); cleanup_and_exit(x->camera); } fprintf(imagefile,"P5\n%u %u 255\n", x->width, x->height); fwrite(x->frame->image, 1, x->height*x->width, imagefile); fclose(imagefile); fprintf(stderr,"wrote: " IMAGE_FILE_NAME "\n");*/ if (x->frame) dc1394_capture_enqueue (x->camera, x->frame); pdp_packet_pass_if_valid(x->x_outlet0, &pdp_packt); }
int main(int argc, char *argv[]) { fitsfile *fptr; long fpixel=1, nelements, naxes[2]; dc1394camera_t *camera; int grab_n_frames; struct timeval start_time, end_time; int i, j, status; unsigned int max_height, max_width; 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; unsigned char *buffer; float *average; grab_n_frames = atoi(argv[1]); filename = argv[2]; status = 0; width = 320; height = 240; naxes[0] = width; naxes[1] = height; nelements = naxes[0]*naxes[1]; 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"); 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"); err = dc1394_format7_set_roi (camera, DC1394_VIDEO_MODE_FORMAT7_1, DC1394_COLOR_CODING_MONO8, // 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"); // 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, 100.0); DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set framerate"); // 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, 1.0e-2); DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set shutter"); // 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, 200); DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set gain"); // 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, 50); DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set brightness"); 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"); // err = dc1394_feature_set_value (camera, DC1394_FEATURE_GAIN, 24); //DC1394_ERR_CLN_RTN(err, dc1394_camera_free(camera), "Error setting gain"); err = dc1394_capture_setup(camera, 16, DC1394_CAPTURE_FLAGS_DEFAULT); DC1394_ERR_CLN_RTN(err, dc1394_camera_free(camera), "Error capturing"); /*----------------------------------------------------------------------- * 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); } /* allocate the buffers */ if (!(buffer = malloc(nelements*sizeof(char)))) { printf("Couldn't Allocate Image Buffer\n"); exit(-1); } if (!(average = calloc(nelements, sizeof(float)))) { printf("Couldn't Allocate Average Image Buffer\n"); 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, FLOAT_IMG, 2, 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); } memcpy(buffer, frame->image, nelements*sizeof(char)); // release buffer dc1394_capture_enqueue(camera,frame); for (j=0; j<nelements; j++) { average[j] += (1.0/grab_n_frames)*(buffer[j]); } } gettimeofday(&end_time, NULL); printf("End capture.\n"); /*----------------------------------------------------------------------- * stop data transmission *-----------------------------------------------------------------------*/ 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, TFLOAT, fpixel, naxes[0]*naxes[1], average, &status); fits_close_file(fptr, &status); fits_report_error(stderr, status); free(buffer); free(average); printf("wrote: %s\n", filename); printf("Readout 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; }
size_t CameraIIDC::getFrameHeight(){ uint32_t _width, _height; dc1394_get_image_size_from_video_mode(cam, video_mode, &_width, &_height); return _height; }
Libdc1394SequenceGrabber::Libdc1394SequenceGrabber(const std::string& name, unsigned int w, unsigned int h, unsigned int rate) : cefix::SequenceGrabber(name, w, h, rate), _context(Libdc1394Context::get()), _camera(NULL), _firstFrame(true), _bayerMethod(DC1394_BAYER_METHOD_BILINEAR), _bayerPattern(DC1394_COLOR_FILTER_RGGB) { msg(osg::INFO) << "LibdcSequenceGrabber " << name << std::endl; setImage(new osg::ImageStream()); getImage()->setOrigin(osg::Image::TOP_LEFT); uint64_t uid = 0; bool grey = false; _format7 = false; int format_7_format_delta(0); if (name.empty() == false) { std::vector<std::string> parts; cefix::strTokenize(name,parts,":"); uid=cefix::hexToLong(parts[0]); for(unsigned int i = 1; i < parts.size(); ++i) { std::string part = cefix::strToLower(parts[i]); if (part == "grey") grey = true; else if (part == "format7") { _format7 = true; if (i+1 < parts.size()) { format_7_format_delta = atoi(parts[i+1].c_str()); ++i; } } } } if (_roi.height == 0) _roi.height = h; if (_roi.width == 0) _roi.width = w; initCamera(uid); if (_camera) { unsigned int video_mode(0); unsigned int color_mode(0); if (_format7) { video_mode = DC1394_VIDEO_MODE_FORMAT7_0+format_7_format_delta; color_mode = (!grey) ? DC1394_COLOR_CODING_RGB8 : DC1394_COLOR_CODING_MONO8; } if (!initVideoMode(w,h, grey, video_mode, color_mode)) { grey = !grey; msg(osg::INFO) << " could not find suitable video mode, toggling grey/color " << std::endl; if (!initVideoMode(w,h, grey)) { msg(osg::WARN) << "could not find suitable video mode for " << w << "x" << h << std::endl; } } initFrameRate(rate); dc1394error_t err; if (_format7) { err = dc1394_format7_set_color_coding(_camera, _videomode, (dc1394color_coding_t)color_mode); checkSuccess(err, "dc1394_format7_set_color_coding failed"); } if (_format7) { err = dc1394_format7_get_image_size(_camera, _videomode, &w, &h); checkSuccess(err, "dc1394_format7_get_image_size failed"); } else { err = dc1394_get_image_size_from_video_mode(_camera, _videomode, &w, &h); checkSuccess(err, "dc1394_get_image_size_from_video_mode failed"); } } if (grey) { getImage()->allocateImage(w,h,1,GL_LUMINANCE, GL_UNSIGNED_BYTE); } else { getImage()->allocateImage(w,h,1,GL_RGB, GL_UNSIGNED_BYTE); } _grey = grey; }
int main(int argc, char *argv[]) { FILE* imagefile; dc1394camera_t *camera; unsigned int width, height; dc1394video_frame_t *frame=NULL; //dc1394featureset_t features; dc1394_t * d; dc1394camera_list_t * list; dc1394error_t err; d = dc1394_new (); 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 %llx", list->ids[0].guid); return 1; } dc1394_camera_free_list (list); printf("Using camera with GUID %"PRIx64"\n", camera->guid); /*----------------------------------------------------------------------- * setup capture *-----------------------------------------------------------------------*/ err=dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_400); DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not set iso speed"); err=dc1394_video_set_mode(camera, DC1394_VIDEO_MODE_1280x960_RGB8); DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not set video mode\n"); err=dc1394_video_set_framerate(camera, DC1394_FRAMERATE_7_5); DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not set framerate\n"); err=dc1394_capture_setup(camera,4, DC1394_CAPTURE_FLAGS_DEFAULT); DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not setup camera-\nmake sure that the video mode and framerate are\nsupported by your camera\n"); /*----------------------------------------------------------------------- * 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\n"); /*----------------------------------------------------------------------- * capture one frame *-----------------------------------------------------------------------*/ err=dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_WAIT, &frame); DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not capture a frame\n"); /*----------------------------------------------------------------------- * stop data transmission *-----------------------------------------------------------------------*/ err=dc1394_video_set_transmission(camera,DC1394_OFF); DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not stop the camera?\n"); /*----------------------------------------------------------------------- * save image as 'Image.pgm' *-----------------------------------------------------------------------*/ imagefile=fopen(IMAGE_FILE_NAME, "wb"); if( imagefile == NULL) { perror( "Can't create output file"); cleanup_and_exit(camera); } dc1394_get_image_size_from_video_mode(camera, DC1394_VIDEO_MODE_1280x960_RGB8, &width, &height); fprintf(imagefile,"P6\n%u %u\n255\n", width, height); fwrite(frame->image, 1, height*width*3, imagefile); fclose(imagefile); printf("wrote: " IMAGE_FILE_NAME " (%d image bytes)\n",height*width*3); /*----------------------------------------------------------------------- * close camera *-----------------------------------------------------------------------*/ dc1394_video_set_transmission(camera, DC1394_OFF); dc1394_capture_stop(camera); dc1394_camera_free(camera); dc1394_free (d); return 0; }
bool CvCaptureCAM_DC1394_v2_CPP::startCapture() { int i; int code = 0; if (!dcCam) return false; if (isoSpeed > 0) { code = dc1394_video_set_iso_speed(dcCam, isoSpeed <= 100 ? DC1394_ISO_SPEED_100 : isoSpeed <= 200 ? DC1394_ISO_SPEED_200 : isoSpeed <= 400 ? DC1394_ISO_SPEED_400 : isoSpeed <= 800 ? DC1394_ISO_SPEED_800 : isoSpeed == 1600 ? DC1394_ISO_SPEED_1600 : DC1394_ISO_SPEED_3200); } // should a specific mode be used if (userMode >= 0) { dc1394video_mode_t wantedMode; dc1394video_modes_t videoModes; dc1394_video_get_supported_modes(dcCam, &videoModes); //set mode from number, for example the second supported mode, i.e userMode = 1 if (userMode < (int)videoModes.num) { wantedMode = videoModes.modes[userMode]; } //set modes directly from DC134 constants (from dc1394video_mode_t) else if ((userMode >= DC1394_VIDEO_MODE_MIN) && (userMode <= DC1394_VIDEO_MODE_MAX )) { //search for wanted mode, to check if camera supports it int j = 0; while ((j< (int)videoModes.num) && videoModes.modes[j]!=userMode) { j++; } if ((int)videoModes.modes[j]==userMode) { wantedMode = videoModes.modes[j]; } else { userMode = -1; // wanted mode not supported, search for best mode } } else { userMode = -1; // wanted mode not supported, search for best mode } //if userMode is available: set it and update size if (userMode != -1) { code = dc1394_video_set_mode(dcCam, wantedMode); uint32_t width, height; dc1394_get_image_size_from_video_mode(dcCam, wantedMode, &width, &height); frameWidth = (int)width; frameHeight = (int)height; } } if (userMode == -1 && (frameWidth > 0 || frameHeight > 0)) { dc1394video_mode_t bestMode = (dc1394video_mode_t) - 1; dc1394video_modes_t videoModes; dc1394_video_get_supported_modes(dcCam, &videoModes); for (i = 0; i < (int)videoModes.num; i++) { dc1394video_mode_t mode = videoModes.modes[i]; if (mode >= DC1394_VIDEO_MODE_FORMAT7_MIN && mode <= DC1394_VIDEO_MODE_FORMAT7_MAX) continue; int pref = -1; dc1394color_coding_t colorCoding; dc1394_get_color_coding_from_video_mode(dcCam, mode, &colorCoding); uint32_t width, height; dc1394_get_image_size_from_video_mode(dcCam, mode, &width, &height); if ((int)width == frameWidth || (int)height == frameHeight) { if (colorCoding == DC1394_COLOR_CODING_RGB8 || colorCoding == DC1394_COLOR_CODING_RAW8) { bestMode = mode; break; } if (colorCoding == DC1394_COLOR_CODING_YUV411 || colorCoding == DC1394_COLOR_CODING_YUV422 || (colorCoding == DC1394_COLOR_CODING_YUV444 && pref < 1)) { bestMode = mode; pref = 1; break; } if (colorCoding == DC1394_COLOR_CODING_MONO8) { bestMode = mode; pref = 0; } } } if ((int)bestMode >= 0) code = dc1394_video_set_mode(dcCam, bestMode); } if (fps > 0) { dc1394video_mode_t mode; dc1394framerates_t framerates; double minDiff = DBL_MAX; dc1394framerate_t bestFps = (dc1394framerate_t) - 1; dc1394_video_get_mode(dcCam, &mode); dc1394_video_get_supported_framerates(dcCam, mode, &framerates); for (i = 0; i < (int)framerates.num; i++) { dc1394framerate_t ifps = framerates.framerates[i]; double fps1 = (1 << (ifps - DC1394_FRAMERATE_1_875)) * 1.875; double diff = fabs(fps1 - fps); if (diff < minDiff) { minDiff = diff; bestFps = ifps; } } if ((int)bestFps >= 0) code = dc1394_video_set_framerate(dcCam, bestFps); } if (cameraId == VIDERE) { bayerFilter = DC1394_COLOR_FILTER_GBRG; nimages = 2; uint32_t value = 0; dc1394_get_control_register(dcCam, 0x50c, &value); colorStereo = (value & 0x80000000) != 0; } code = dc1394_capture_setup(dcCam, nDMABufs, DC1394_CAPTURE_FLAGS_DEFAULT); if (code >= 0) { FD_SET(dc1394_capture_get_fileno(dcCam), &dc1394.camFds); dc1394_video_set_transmission(dcCam, DC1394_ON); if (cameraId == VIDERE) { enum { PROC_MODE_OFF, PROC_MODE_NONE, PROC_MODE_TEST, PROC_MODE_RECTIFIED, PROC_MODE_DISPARITY, PROC_MODE_DISPARITY_RAW }; int procMode = PROC_MODE_RECTIFIED; usleep(100000); uint32_t qval1 = 0x08000000 | (0x90 << 16) | ((procMode & 0x7) << 16); uint32_t qval2 = 0x08000000 | (0x9C << 16); dc1394_set_control_register(dcCam, 0xFF000, qval1); dc1394_set_control_register(dcCam, 0xFF000, qval2); } started = true; } return code >= 0; }
static dc1394video_mode_t s_get_appropriate_mode(dc1394camera_t *cam, dc1394video_mode_t mode) { dc1394video_modes_t supported_modes; dc1394video_mode_t selected_mode = mode; uint32_t width, height; dc1394color_coding_t coding; int found = 0; unsigned int num_pixels = 0; dc1394error_t err; unsigned int i; err = dc1394_video_get_supported_modes(cam, &supported_modes); DC1394_WRN(err, "failed to get supported modes."); if (err != DC1394_SUCCESS) { return mode; } for (i = 0; i < supported_modes.num; ++i) { /* return given mode if the camera supports it */ if (supported_modes.modes[i] == mode) { return mode; } } /* reaches here when no mode is exactly matched with one of supported modes */ err = dc1394_get_image_size_from_video_mode(cam, mode, &width, &height); DC1394_WRN(err, "failed to get image size."); if (err != DC1394_SUCCESS) { return mode; } num_pixels = width * height; err = dc1394_get_color_coding_from_video_mode(cam, mode, &coding); DC1394_WRN(err, "failed to get color coding."); if (err != DC1394_SUCCESS) { return mode; } found = 0; /* search the mode of size does not exceed the given mode and has the same color coding */ for (i = 0; i < supported_modes.num; ++i) { dc1394color_coding_t c; if (dc1394_get_color_coding_from_video_mode(cam, supported_modes.modes[i], &c) != DC1394_SUCCESS) { continue; } if (c == coding) { uint32_t w, h; if (dc1394_get_image_size_from_video_mode(cam, supported_modes.modes[i], &w, &h) != DC1394_SUCCESS) { continue; } if (w*h <= width*height && num_pixels < w*h) { num_pixels = w*h; selected_mode = supported_modes.modes[i]; found = 1; } } } if (found == 0) { return mode; } return selected_mode; }
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); }
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; }
void DC1394Camera::init(core::ConfigNode config, uint64_t guid) { LOGGER.infoStream() << guid << ": Initializing camera "; m_guid = guid; // Grab our camera m_camera = dc1394_camera_new(s_libHandle, guid); if (!m_camera) { LOGGER.errorStream() << "Failed to initialize camera with guid: " << guid; assert(m_camera && "Couldn't initialize camera"); } // Determines settings and frame size dc1394error_t err = DC1394_FAILURE; dc1394video_mode_t videoMode = DC1394_VIDEO_MODE_640x480_RGB8; dc1394framerate_t frameRate = DC1394_FRAMERATE_15; // Check for the whitebalance feature dc1394feature_info_t whiteBalance; whiteBalance.id = DC1394_FEATURE_WHITE_BALANCE; err = dc1394_feature_get(m_camera, &whiteBalance); assert(DC1394_SUCCESS == err && "Could not get white balance feature info"); bool hasWhiteBalance = (whiteBalance.available == DC1394_TRUE); uint32_t uValue, vValue; if (hasWhiteBalance) { err = dc1394_feature_whitebalance_get_value(m_camera, &uValue, &vValue); LOGGER.infoStream() << m_guid << ": Current U: " << uValue << " V: " << vValue; } // Actually set the values if the user wants to if (config.exists("uValue") && config.exists("vValue")) { bool uAuto = boost::to_lower_copy(config["uValue"].asString("auto")) == "auto"; bool vAuto = boost::to_lower_copy(config["vValue"].asString("auto")) == "auto"; bool autoVal = uAuto && vAuto; if ((uAuto || vAuto) && !autoVal) { assert(false && "Both Whitebalance values must either be auto or manual"); } if (autoVal) { setWhiteBalance(0, 0, true); } else { // Read in config values uint32_t u_b_value = static_cast<uint32_t>(config["uValue"].asInt()); uint32_t v_r_value = static_cast<uint32_t>(config["vValue"].asInt()); // Set values setWhiteBalance(u_b_value, v_r_value); } } else if (config.exists("uValue") || config.exists("vValue")) { assert(false && "Must set both the U and V values for white balance"); } err = dc1394_feature_whitebalance_get_value(m_camera, &uValue, &vValue); LOGGER.infoStream() << m_guid << ": Set U: " << uValue << " V: " << vValue; if (config.exists("brightness")) { // Read in and set values if (boost::to_lower_copy(config["brightness"].asString("auto")) == "auto") { setBrightness(0, true); } else { uint32_t value = static_cast<uint32_t>(config["brightness"].asInt()); setBrightness(value); } } if (config.exists("exposure")) { // Read in and set values if (boost::to_lower_copy(config["exposure"].asString("auto")) == "auto") { setExposure(0, true); } else { uint32_t value = static_cast<uint32_t>(config["exposure"].asInt()); setExposure(value); } } // Grab image size err = dc1394_get_image_size_from_video_mode(m_camera, videoMode, &m_width, &m_height); assert(DC1394_SUCCESS == err && "Could not get image size"); float fRate; err = dc1394_framerate_as_float(frameRate, &fRate); assert(DC1394_SUCCESS == err && "Could not get framerate as float"); m_fps = fRate; // Setup the capture err = dc1394_video_set_iso_speed(m_camera, DC1394_ISO_SPEED_400); assert(DC1394_SUCCESS == err && "Could not set iso speed"); err = dc1394_video_set_mode(m_camera, videoMode); assert(DC1394_SUCCESS == err && "Could not set video mode"); err = dc1394_video_set_framerate(m_camera, frameRate); assert(DC1394_SUCCESS == err && "Could not set framerate"); // Start data transfer err = dc1394_video_set_transmission(m_camera, DC1394_ON); assert(DC1394_SUCCESS == err && "Could not start camera iso transmission"); err = dc1394_capture_setup(m_camera, DMA_BUFFER_SIZE, DC1394_CAPTURE_FLAGS_DEFAULT); assert(DC1394_SUCCESS == err && "Could not setup camera make sure" " that the video mode and framerate are supported by your camera"); }