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);
}
int list_framerates(QSP_ARG_DECL PGR_Cam *pgcp)
{
unsigned int i;
dc1394framerates_t framerates;
const char *s;
// format7 doesn't have a framerate!?
if( mode_is_format7(pgcp) ){
WARN("list_framerates: No framerates associated with format7 video mode!?");
return -1;
}
if ( dc1394_video_get_supported_framerates( pgcp->pc_cam_p, pgcp->pc_video_mode, &framerates )
!= DC1394_SUCCESS ){
warn("error fetching framerates");
return -1;
}
if( framerates.num <= 0 ){
warn("no framerates for this video mode!?");
return -1;
}
for(i=0;i<framerates.num; i++){
s=name_for_framerate(framerates.framerates[i]);
assert( s != NULL );
prt_msg_frag("\t");
prt_msg(s);
}
return 0;
}
void FWCamera::getCameraImageFormats(dc1394camera_t* pCamera, CameraInfo* camInfo)
{
dc1394video_modes_t videoModes;
dc1394framerates_t framerates;
dc1394error_t err = dc1394_video_get_supported_modes(pCamera, &videoModes);
if (err != DC1394_SUCCESS) {
AVG_ASSERT(false);
return;
}
for (unsigned i = 0; i < videoModes.num; i++) {
//Covers only libavg supported formats, other capabilities are ignored
if (videoModes.modes[i] >= DC1394_VIDEO_MODE_320x240_YUV422
&& videoModes.modes[i] <= DC1394_VIDEO_MODE_1600x1200_MONO16){
PixelFormat pixFormat = getPFFromVideoMode(videoModes.modes[i]);
IntPoint size = getFrameSizeFromVideoMode(videoModes.modes[i]);
FrameratesVector framerateList;
err = dc1394_video_get_supported_framerates(pCamera, videoModes.modes[i],
&framerates);
if (err != DC1394_SUCCESS) {
AVG_LOG_WARNING("Camera: No framerates. Error was: " << err);
} else {
for (unsigned j = 0; j < framerates.num; j++)
{
float rate = framerateToFloat(framerates.framerates[j]);
framerateList.push_back(rate);
}
}
CameraImageFormat format = CameraImageFormat(size,pixFormat,framerateList);
camInfo->addImageFormat(format);
}
}
}
bool Libdc1394SequenceGrabber::initFrameRate(unsigned int rate)
{
msg(osg::INFO) << "initFrameRate" << std::endl;
if (!_camera) return false;
if (_format7) {
uint32_t bit_size;
dc1394_get_color_coding_bit_size(_sourceFormat,&bit_size);
int packet_size = DC1394_USE_MAX_AVAIL;
if(rate != 0) {
double bus_period;
if(_speed == DC1394_ISO_SPEED_800) {
bus_period = 0.0000625;
}
else {
bus_period = 0.000125;
}
int num_packets = (int)(1.0/(bus_period*rate)+0.5);
packet_size = ((_roi.width - _roi.x)*(_roi.height - _roi.y)*bit_size + (num_packets*8) - 1) / (num_packets*8);
}
dc1394error_t err = dc1394_format7_set_packet_size(_camera, _videomode, packet_size);
checkSuccess(err, "dc1394_format7_set_packet_size failed");
err = dc1394_format7_set_roi(_camera, _videomode, _sourceFormat, packet_size, _roi.x,_roi.y,_roi.width,_roi.height);
checkSuccess(err, "dc1394_format7_set_roi failed");
return (err == DC1394_SUCCESS);
}
dc1394framerates_t framerates;
dc1394error_t err=dc1394_video_get_supported_framerates(_camera,_videomode, &framerates);
checkSuccess(err, "dc1394_video_get_supported_framerates failed");
dc1394framerate_t framerate=framerates.framerates[framerates.num-1];
switch (rate) {
case 15:
framerate = DC1394_FRAMERATE_15;
break;
case 30:
framerate = DC1394_FRAMERATE_30;
break;
case 60:
framerate = DC1394_FRAMERATE_60;
break;
case 120:
framerate = DC1394_FRAMERATE_120;
break;
case 240:
framerate = DC1394_FRAMERATE_240;
}
err=dc1394_video_set_framerate(_camera, framerate);
checkSuccess(err, "dc1394_video_set_framerate failed");
return (err == DC1394_SUCCESS);
}
int pick_framerate(QSP_ARG_DECL PGR_Cam *pgcp,const char *pmpt)
{
int i;
int j;
dc1394framerates_t framerates;
const char **choices;
const char *s;
if( pgcp == NULL ) return -1;
// format7 doesn't have a framerate!?
if( mode_is_format7(pgcp) ){
WARN("Can't specify framerate for format7 video mode...");
// eat the argument
s = NAMEOF("dummy argument");
return -1;
}
if ( dc1394_video_get_supported_framerates( pgcp->pc_cam_p, pgcp->pc_video_mode, &framerates )
!= DC1394_SUCCESS )
return -1;
choices = (const char **) getbuf( framerates.num * sizeof(char *) );
j=0;
for(i=0;i<framerates.num;i++){
s=name_for_framerate(framerates.framerates[i]);
if( s != NULL ){
choices[j] = s;
j++;
}
}
i=WHICH_ONE(pmpt,j,choices);
givbuf(choices);
return(i);
}
static dc1394framerate_t s_get_appropriate_framerate(dc1394camera_t *cam, dc1394video_mode_t mode, dc1394framerate_t framerate)
{
dc1394framerates_t framerates;
dc1394framerate_t selected_framerate;
dc1394error_t err;
unsigned int i;
err = dc1394_video_get_supported_framerates(cam, mode, &framerates);
DC1394_WRN(err, "failed to get framerates");
if (err != DC1394_SUCCESS) {
return framerate;
}
selected_framerate = (dc1394framerate_t)0;
for (i = 0; i < framerates.num; ++i) {
if (selected_framerate < framerates.framerates[i] && framerates.framerates[i] <= framerate) {
selected_framerate = framerates.framerates[i];
}
}
if (selected_framerate == 0) {
return framerate;
}
return selected_framerate;
}
void print_video_mode_info( dc1394camera_t *camera, dc1394video_mode_t mode) {
int j;
dc1394error_t err;
printf("Mode: ");
print_video_mode(mode);
printf("\n");
if((mode == DC1394_VIDEO_MODE_FORMAT7_0) ||
(mode == DC1394_VIDEO_MODE_FORMAT7_1) ||
(mode == DC1394_VIDEO_MODE_FORMAT7_2) ||
(mode == DC1394_VIDEO_MODE_FORMAT7_3) ||
(mode == DC1394_VIDEO_MODE_FORMAT7_4) ||
(mode == DC1394_VIDEO_MODE_FORMAT7_5) ||
(mode == DC1394_VIDEO_MODE_FORMAT7_6) ||
(mode == DC1394_VIDEO_MODE_FORMAT7_7))
{
dc1394format7mode_t f7mode;
err=dc1394_format7_get_mode_info(camera, mode, &f7mode);
if(err) {
DC1394_ERR(err,"Could not format 7 information");
} else {
printf( "Image Sizes:\n"
" size = %ix%i\n"
" max = %ix%i\n"
" pixels = %i\n",
f7mode.size_x, f7mode.size_y,
f7mode.max_size_x, f7mode.max_size_y,
f7mode.pixnum);
printf( "Color:\n");
for(j=0; j<f7mode.color_codings.num; j++) {
printf(" [%d] coding = ", j);
print_color_coding(f7mode.color_codings.codings[j]);
printf("\n");
}
printf(" filter = ");
print_color_filter(f7mode.color_filter);
printf("\n");
}
} else {
dc1394framerates_t framerates;
err=dc1394_video_get_supported_framerates(camera,mode,&framerates);
if(err) {
DC1394_ERR(err,"Could not get frame rates");
} else {
printf("Frame Rates:\n");
for(j = 0; j < framerates.num; j++) {
uint32_t rate = framerates.framerates[j];
float f_rate;
dc1394_framerate_as_float(rate,&f_rate);
printf(" [%d] rate = %f\n",j,f_rate );
}
}
}
}
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);
}
/** Get non-scalable frame rate.
*
* @pre camera is NOT in a Format7 video mode.
*
* @param camera points to DC1394 camera struct.
* @param video_mode currently selected non-Format7 video mode.
* @param[in,out] frame_rate Config parameter for this option,
* updated if the camera does not support the
* requested value.
* @return corresponding dc1394framerate_t enum value selected,
* if successful; DC1394_FRAMERATE_NUM if not.
*/
dc1394framerate_t getFrameRate(dc1394camera_t *camera,
dc1394video_mode_t video_mode,
double &frame_rate)
{
// list frame rates supported for this video mode
dc1394framerates_t avail_rates;
dc1394error_t err =
dc1394_video_get_supported_framerates(camera, video_mode, &avail_rates);
if (err != DC1394_SUCCESS)
{
ROS_FATAL("getFrameRate() cannot be used for Format7 modes");
return (dc1394framerate_t) DC1394_FRAMERATE_NUM; // failure
}
int result = DC1394_FRAMERATE_240;
double rate = 240.0;
// round frame rate down to next-lower defined value
while (result >= DC1394_FRAMERATE_MIN)
{
for (uint32_t i = 0; i < avail_rates.num; ++i)
{
if (avail_rates.framerates[i] == result
&& rate <= frame_rate)
{
// update configured rate to match selected value
frame_rate = rate;
return (dc1394framerate_t) result;
}
}
// continue with next-lower possible value
--result;
rate = rate / 2.0;
}
// no valid frame rate discovered
ROS_ERROR("requested frame_rate (%.3f) not available", frame_rate);
return (dc1394framerate_t) DC1394_FRAMERATE_NUM; // failure
}
static int set_default_framerate(QSP_ARG_DECL PGR_Cam *pgcp)
{
int r;
// get highest framerate
// Hmm... the avaialable framerates appear to depend on the video mode!
// Therefore, we should re-call this when we change the video mode!
// format7 doesn't have a framerate!?
// format7 doesn't have a framerate!?
if( mode_is_format7(pgcp) ){
//warn("set_default_framerate: No framerate associated with format7 video mode!?");
pgcp->pc_framerate = -1;
set_script_var_from_int("n_framerates",0);
return 0;
}
if ( dc1394_video_get_supported_framerates( pgcp->pc_cam_p, pgcp->pc_video_mode, &(pgcp->pc_framerates) )
!= DC1394_SUCCESS ) {
warn("Can't get framerates");
return -1;
}
r = pgcp->pc_framerates.framerates[ pgcp->pc_framerates.num-1];
pgcp->pc_framerate = r;
sprintf(ERROR_STRING,"set_default_framerate: setting to %s", name_for_framerate(r));
advise(ERROR_STRING);
dc1394_video_set_framerate( pgcp->pc_cam_p, pgcp->pc_framerate );
// BUG if this fails, then pc_framerate is wrong!?
// stash the number of framerates in a script variable
// in case the user wants to fetch the strings...
set_script_var_from_int("n_framerates",pgcp->pc_framerates.num);
return 0;
}
/*-----------------------------------------------------------------------
* Prints various information about the mode the camera is in
*-----------------------------------------------------------------------*/
void of1394VideoGrabber::print_mode_info(dc1394video_mode_t mode )
{
int j;
printf("Mode: ");
print_format(mode);
printf("\n");
dc1394framerates_t framerates;
dc1394error_t err;
err=dc1394_video_get_supported_framerates(camera,mode,&framerates);
DC1394_ERR(err,"Could not get frame rates");
printf("Frame Rates:\n");
for( j = 0; j < framerates.num; j++ ) {
dc1394framerate_t rate = framerates.framerates[j];
float f_rate;
dc1394_framerate_as_float(rate,&f_rate);
printf(" [%d] rate = %f\n",j,f_rate );
}
}
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;
}
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;
}
void Camera1394::save_capa ( string filename ) {
dc1394video_modes_t modes;
dc1394error_t err ;
bool framerates ;
string modename ;
string frate ;
err=dc1394_video_get_supported_modes(cam, &modes);
if ( err != DC1394_SUCCESS ) {
std::cerr << "[vision_server] Could not get list of modes" ;
return ;
}
ofstream capafile ( filename.c_str() , ios::out ) ;
for ( unsigned int i=0; i<modes.num; i++) {
framerates = true ;
if ( ( modes.modes[i] == DC1394_VIDEO_MODE_EXIF ) ||
( modes.modes[i] == DC1394_VIDEO_MODE_FORMAT7_0 ) ||
( modes.modes[i] == DC1394_VIDEO_MODE_FORMAT7_1 ) ||
( modes.modes[i] == DC1394_VIDEO_MODE_FORMAT7_2 ) ||
( modes.modes[i] == DC1394_VIDEO_MODE_FORMAT7_3 ) ||
( modes.modes[i] == DC1394_VIDEO_MODE_FORMAT7_4 ) ||
( modes.modes[i] == DC1394_VIDEO_MODE_FORMAT7_5 ) ||
( modes.modes[i] == DC1394_VIDEO_MODE_FORMAT7_6 ) ||
( modes.modes[i] == DC1394_VIDEO_MODE_FORMAT7_7 ) )
framerates = false ;
capafile << "[Mode] " << mode_2_string ( modes.modes[i] ) << endl ;
if (framerates) {
dc1394framerates_t framerates;
err = dc1394_video_get_supported_framerates (cam, modes.modes[i], &framerates);
if ( err != DC1394_SUCCESS ) {
std::cerr << "[vision_server] ERROR : could not retrieve framerate" << endl ;
exit(0) ;
}
for ( unsigned int j = 0; j < framerates.num; j++) {
dc1394framerate_t rate = framerates.framerates[j];
switch (rate) {
case DC1394_FRAMERATE_1_875 :
frate = "DC1394_FRAMERATE_1_875" ;
break ;
case DC1394_FRAMERATE_3_75 :
frate = "DC1394_FRAMERATE_3_75" ;
break ;
case DC1394_FRAMERATE_7_5 :
frate = "DC1394_FRAMERATE_7_5" ;
break ;
case DC1394_FRAMERATE_15 :
frate = "DC1394_FRAMERATE_15" ;
break ;
case DC1394_FRAMERATE_30 :
frate = "DC1394_FRAMERATE_30" ;
break ;
case DC1394_FRAMERATE_60 :
frate = "DC1394_FRAMERATE_60" ;
break ;
case DC1394_FRAMERATE_120 :
frate = "DC1394_FRAMERATE_120" ;
break ;
case DC1394_FRAMERATE_240 :
frate = "DC1394_FRAMERATE_240" ;
break ;
default :
frate ="Unknown framerate" ;
break ;
}
capafile << "[Framerate] " << frate << endl ;
}
}
capafile << endl ;
}
// Enumerates features
dc1394featureset_t features ;
dc1394_feature_get_all( cam, &features );
for ( int i=0; i<DC1394_FEATURE_NUM; i++ ) {
if ( features.feature[i].available ) {
capafile << std::endl << "[Feature] " << feature_2_string ( features.feature[i].id ) << std::endl ;
for (unsigned int j=0; j<features.feature[i].modes.num; j++ ) {
capafile << " Mode : " << featuremode_2_string ( features.feature[i].modes.modes[j] ) << std::endl ;
if (features.feature[i].modes.modes[j] == DC1394_FEATURE_MODE_MANUAL ) {
uint32_t min = 0 ;
uint32_t max = 0 ;
err = dc1394_feature_get_boundaries( cam, features.feature[i].id , &min, &max);
if ( err != DC1394_SUCCESS ) {
std::cerr << "[vision_server] ERROR : Could not get boudaries for mode " << featuremode_2_string ( features.feature[i].modes.modes[j] ) << endl ;
exit(0) ;
}
capafile << " Value : " << min << " - " << max << std::endl ;
}
}
}
}
// close file
capafile.close() ;
}
void Libdc1394SequenceGrabber::populateDeviceInfoList(cefix::SequenceGrabberDeviceInfoList& devices)
{
dc1394_t * d;
dc1394camera_list_t * list;
dc1394error_t err;
dc1394video_modes_t video_modes;
dc1394framerates_t framerates;
d = Libdc1394Context::get();
if (!d)
return;
err=dc1394_camera_enumerate (d, &list);
for(unsigned int i = 0; i < list->num; ++i) {
osg::notify(osg::INFO) << "UID: " << list->ids[i].guid << std::endl;
dc1394camera_t* camera = dc1394_camera_new (d, list->ids[i].guid);
if (!camera) continue;
devices.push_back(cefix::SequenceGrabber::DeviceInfo(getGrabberId(), cefix::longToHexString(list->ids[i].guid)));
dc1394_camera_print_info(camera, stdout);
err=dc1394_video_get_supported_modes(camera,&video_modes);
osg::notify(osg::INFO) << "available video-modes: " << std::endl;
for (int j = 0;j < video_modes.num;j++)
{
osg::notify(osg::INFO) << "* " << getVideoMode(video_modes.modes[j]);
if (dc1394_video_get_supported_framerates(camera, video_modes.modes[j], &framerates) == DC1394_SUCCESS) {
osg::notify(osg::INFO) << " fps: ";
for(unsigned int k = 0; k < framerates.num; ++k) {
osg::notify(osg::INFO) << " " << getFrameRate(framerates.framerates[k]);
}
}
osg::notify(osg::INFO) << std::endl;
}
dc1394featureset_t features;
dc1394_feature_get_all(camera, &features);
dc1394_feature_print_all(&features, stdout);
/*
for( int j = 0; j < DC1394_FEATURE_NUM; j++ )
{
const dc1394feature_info_t& f = features.feature[j];
if( f.available )
{
std::cout << getNameOfFeature(f.id) << std::endl;
std::cout << " current mode: ";
switch(f.current_mode) {
case DC1394_FEATURE_MODE_MANUAL:
std::cout << "manual";
break;
case DC1394_FEATURE_MODE_AUTO:
std::cout << "auto";
break;
case DC1394_FEATURE_MODE_ONE_PUSH_AUTO:
std::cout << "one-push";
break;
}
std::cout << std::endl;
std::cout << " min: " << f.min << " max: " << f.max << " value: " << f.value << std::endl;
if (f.absolute_capable==DC1394_TRUE) {
std::cout << " abs:min: " << f.abs_min << " max: " << f.abs_max << " value: " << f.abs_value << std::endl;
}
}
}
*/
dc1394_camera_free(camera);
}
dc1394_camera_free_list(list);
}
GstCaps *
gst_dc1394_get_cam_caps (GstDc1394 * src)
{
dc1394camera_t *camera = NULL;
dc1394camera_list_t *cameras = NULL;
dc1394error_t camerr;
gint i, j;
dc1394video_modes_t modes;
dc1394framerates_t framerates;
GstCaps *gcaps = NULL;
gcaps = gst_caps_new_empty ();
camerr = dc1394_camera_enumerate (src->dc1394, &cameras);
if (camerr != DC1394_SUCCESS || cameras == NULL) {
GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND,
("Can't find cameras error : %d", camerr),
("Can't find cameras error : %d", camerr));
goto error;
}
if (cameras->num == 0) {
GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND, ("There were no cameras"),
("There were no cameras"));
goto error;
}
if (src->camnum > (cameras->num - 1)) {
GST_ELEMENT_ERROR (src, RESOURCE, FAILED, ("Invalid camera number"),
("Invalid camera number %d", src->camnum));
goto error;
}
camera =
dc1394_camera_new_unit (src->dc1394, cameras->ids[src->camnum].guid,
cameras->ids[src->camnum].unit);
dc1394_camera_free_list (cameras);
cameras = NULL;
camerr = dc1394_video_get_supported_modes (camera, &modes);
if (camerr != DC1394_SUCCESS) {
GST_ELEMENT_ERROR (src, RESOURCE, FAILED, ("Error getting supported modes"),
("Error getting supported modes"));
goto error;
}
for (i = modes.num - 1; i >= 0; i--) {
int m = modes.modes[i];
if (m < DC1394_VIDEO_MODE_EXIF) {
GstStructure *gs = gst_structure_empty_new ("video");
gst_structure_set (gs, "vmode", G_TYPE_INT, m, NULL);
if (gst_dc1394_caps_set_format_vmode_caps (gs, m) < 0) {
GST_ELEMENT_ERROR (src, STREAM, FAILED,
("attempt to set mode to %d failed", m),
("attempt to set mode to %d failed", m));
goto error;
} else {
camerr = dc1394_video_get_supported_framerates (camera, m, &framerates);
gst_dc1394_caps_set_framerate_list (gs, &framerates);
gst_caps_append_structure (gcaps, gs);
}
} else {
// FORMAT 7
guint maxx, maxy;
GstStructure *gs = gst_structure_empty_new ("video");
dc1394color_codings_t colormodes;
guint xunit, yunit;
gst_structure_set (gs, "vmode", G_TYPE_INT, m, NULL);
// Get the maximum frame size
camerr = dc1394_format7_get_max_image_size (camera, m, &maxx, &maxy);
if (camerr != DC1394_SUCCESS) {
GST_ELEMENT_ERROR (src, RESOURCE, FAILED,
("Error getting format 7 max image size"),
("Error getting format 7 max image size"));
goto error;
}
GST_LOG_OBJECT (src, "Format 7 maxx=%d maxy=%d", maxx, maxy);
camerr = dc1394_format7_get_unit_size (camera, m, &xunit, &yunit);
if (camerr != DC1394_SUCCESS) {
GST_ELEMENT_ERROR (src, RESOURCE, FAILED,
("Error getting format 7 image unit size"),
("Error getting format 7 image unit size"));
goto error;
}
GST_LOG_OBJECT (src, "Format 7 unitx=%d unity=%d", xunit, yunit);
gst_dc1394_set_caps_framesize_range (gs, xunit, maxx, xunit,
yunit, maxy, yunit);
// note that format 7 has no concept of a framerate, so we pass the
// full range
gst_structure_set (gs,
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
// get the available color codings
camerr = dc1394_format7_get_color_codings (camera, m, &colormodes);
if (camerr != DC1394_SUCCESS) {
GST_ELEMENT_ERROR (src, RESOURCE, FAILED,
("Error getting format 7 color modes"),
("Error getting format 7 color modes"));
goto error;
}
for (j = 0; j < colormodes.num; j++) {
GstStructure *newgs = gst_structure_copy (gs);
gst_dc1394_set_caps_color (newgs, colormodes.codings[j]);
GST_LOG_OBJECT (src, "Format 7 colormode set : %d",
colormodes.codings[j]);
// note that since there are multiple color modes, we append
// multiple structures.
gst_caps_append_structure (gcaps, newgs);
}
}
}
if (camera) {
dc1394_camera_free (camera);
}
return gcaps;
error:
if (gcaps) {
gst_caps_unref (gcaps);
}
if (cameras) {
dc1394_camera_free_list (cameras);
cameras = NULL;
}
if (camera) {
dc1394_camera_free (camera);
camera = NULL;
}
return NULL;
}
void *pdp_dc1394_new(t_symbol *vdef)
{
t_pdp_dc1394 *x = (t_pdp_dc1394 *)pd_new(pdp_dc1394_class);
x->x_outlet0 = outlet_new(&x->x_obj, &s_anything);
x->d = dc1394_new ();
x->err=dc1394_camera_enumerate (x->d, &x->list);
//DC1394_ERR_RTN(x->err,"Failed to enumerate cameras");
//post("Failed to enumerate cameras");
if (x->list->num == 0) {
dc1394_log_error("No cameras found");
return 1;
}
x->camera = dc1394_camera_new (x->d, x->list->ids[0].guid);
if (!x->camera) {
//dc1394_log_error("Failed to initialize camera with guid %"PRIx64, list->ids[0].guid);
return 1;
}
dc1394_camera_free_list (x->list);
//printf("Using camera with GUID %"PRIx64"\n", camera->guid);
/*-----------------------------------------------------------------------
* get the best video mode and highest framerate. This can be skipped
* if you already know which mode/framerate you want...
*-----------------------------------------------------------------------*/
// get video modes:
x->err=dc1394_video_get_supported_modes(x->camera,&x->video_modes);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Can't get video modes");
// select highest res mode:
for (x->i=x->video_modes.num-1;x->i>=0;x->i--) {
if (!dc1394_is_video_mode_scalable(x->video_modes.modes[x->i])) {
dc1394_get_color_coding_from_video_mode(x->camera,x->video_modes.modes[x->i], &x->coding);
if (x->coding==DC1394_COLOR_CODING_MONO8) {
x->video_mode=x->video_modes.modes[x->i];
fprintf(stderr,"video_mode %d: %d\n",x->i,x->video_modes.modes[x->i]);
break;
}
}
}
if (x->i < 0) {
dc1394_log_error("Could not get a valid MONO8 mode");
cleanup_and_exit(x->camera);
}
x->err=dc1394_get_color_coding_from_video_mode(x->camera, x->video_mode,&x->coding);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not get color coding");
fprintf(stderr,"color_coding : %d\n",x->coding);
// get highest framerate
x->err=dc1394_video_get_supported_framerates(x->camera,x->video_mode,&x->framerates);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not get framrates");
x->framerate=x->framerates.framerates[x->framerates.num-1];
fprintf(stderr,"framerate : %d\n",x->framerate);
/*-----------------------------------------------------------------------
* setup capture
*-----------------------------------------------------------------------*/
x->err=dc1394_video_set_iso_speed(x->camera, DC1394_ISO_SPEED_400);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not set iso speed");
x->err=dc1394_video_set_mode(x->camera, x->video_mode);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not set video mode");
x->err=dc1394_video_set_framerate(x->camera, x->framerate);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not set framerate");
x->err=dc1394_capture_setup(x->camera,4, DC1394_CAPTURE_FLAGS_DEFAULT);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not setup camera-\nmake sure that the video mode and framerate are\nsupported by your camera");
/*-----------------------------------------------------------------------
* report camera's features
*-----------------------------------------------------------------------*/
x->err=dc1394_feature_get_all(x->camera,&x->features);
if (x->err!=DC1394_SUCCESS) {
dc1394_log_warning("Could not get feature set");
}
else {
dc1394_feature_print_all(&x->features, stdout);
}
/*-----------------------------------------------------------------------
* have the camera start sending us data
*-----------------------------------------------------------------------*/
x->err=dc1394_video_set_transmission(x->camera, DC1394_ON);
//DC1394_ERR_CLN_RTN(x->err,cleanup_and_exit(x->camera),"Could not start camera iso transmission");
x->x_initialized = true;
return (void *)x;
}
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 i,j;
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;
}
printf("Total cameras found %d\n",list->num);
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);
dc1394video_modes_t video_modes;
err=dc1394_video_get_supported_modes(camera,&video_modes);
DC1394_ERR_RTN(err,"Failed get camera modes");
printf("Video Modes:\n");
for( i = 0; i < video_modes.num; i++ ) {
printVideoMode(video_modes.modes[i]);
if( video_modes.modes[i] < DC1394_VIDEO_MODE_FORMAT7_0 ) {
dc1394framerates_t rates;
err=dc1394_video_get_supported_framerates(camera,video_modes.modes[i],&rates);
DC1394_ERR_RTN(err,"Failed get mode frame rates");
for( j = 0; j < rates.num; j++ ) {
printFrameRates(rates.framerates[j]);
}
} else {
dc1394color_codings_t codings;
err=dc1394_format7_get_color_codings(camera,video_modes.modes[i],&codings);
DC1394_ERR_RTN(err,"Failed get format7 color codings");
for( j = 0; j < codings.num; j++ ) {
printColorCodings(codings.codings[j]);
}
uint32_t width,height;
err=dc1394_format7_get_max_image_size(camera,video_modes.modes[i],&width,&height);
DC1394_ERR_RTN(err,"Failed get format7 max size");
printf(" Max dimension = %d %d\n",width,height);
}
}
dc1394_camera_free(camera);
dc1394_free (d);
return 0;
}
