Visual Servoing Platform  version 3.3.1 under development (2020-05-29)
vp1394TwoGrabber.cpp
1 /****************************************************************************
2  *
3  * ViSP, open source Visual Servoing Platform software.
4  * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
5  *
6  * This software is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  * See the file LICENSE.txt at the root directory of this source
11  * distribution for additional information about the GNU GPL.
12  *
13  * For using ViSP with software that can not be combined with the GNU
14  * GPL, please contact Inria about acquiring a ViSP Professional
15  * Edition License.
16  *
17  * See http://visp.inria.fr for more information.
18  *
19  * This software was developed at:
20  * Inria Rennes - Bretagne Atlantique
21  * Campus Universitaire de Beaulieu
22  * 35042 Rennes Cedex
23  * France
24  *
25  * If you have questions regarding the use of this file, please contact
26  * Inria at visp@inria.fr
27  *
28  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
29  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
30  *
31  * Description:
32  * Firewire cameras video capture.
33  *
34  * Authors:
35  * Fabien Spindler
36  *
37  *****************************************************************************/
38 
44 #include <iostream>
45 
46 #include <visp3/core/vpConfig.h>
47 
48 /*
49  * Interface with libdc1394 2.x
50  */
51 #if defined(VISP_HAVE_DC1394)
52 #include <unistd.h>
53 
54 #include <visp3/core/vpFrameGrabberException.h>
55 #include <visp3/core/vpImageConvert.h>
56 #include <visp3/core/vpTime.h>
57 #include <visp3/sensor/vp1394TwoGrabber.h>
58 
59 const char *vp1394TwoGrabber::strVideoMode[DC1394_VIDEO_MODE_NUM] = {
60  "MODE_160x120_YUV444", "MODE_320x240_YUV422", "MODE_640x480_YUV411", "MODE_640x480_YUV422",
61  "MODE_640x480_RGB8", "MODE_640x480_MONO8", "MODE_640x480_MONO16", "MODE_800x600_YUV422",
62  "MODE_800x600_RGB8", "MODE_800x600_MONO8", "MODE_1024x768_YUV422", "MODE_1024x768_RGB8",
63  "MODE_1024x768_MONO8", "MODE_800x600_MONO16", "MODE_1024x768_MONO16", "MODE_1280x960_YUV422",
64  "MODE_1280x960_RGB8", "MODE_1280x960_MONO8", "MODE_1600x1200_YUV422", "MODE_1600x1200_RGB8",
65  "MODE_1600x1200_MONO8", "MODE_1280x960_MONO16", "MODE_1600x1200_MONO16", "MODE_EXIF",
66  "MODE_FORMAT7_0", "MODE_FORMAT7_1", "MODE_FORMAT7_2", "MODE_FORMAT7_3",
67  "MODE_FORMAT7_4", "MODE_FORMAT7_5", "MODE_FORMAT7_6", "MODE_FORMAT7_7"};
68 
69 const char *vp1394TwoGrabber::strFramerate[DC1394_FRAMERATE_NUM] = {
70  "FRAMERATE_1_875", "FRAMERATE_3_75", "FRAMERATE_7_5", "FRAMERATE_15",
71  "FRAMERATE_30", "FRAMERATE_60", "FRAMERATE_120", "FRAMERATE_240"};
72 
73 const char *vp1394TwoGrabber::strColorCoding[DC1394_COLOR_CODING_NUM] = {
74  "COLOR_CODING_MONO8", "COLOR_CODING_YUV411", "COLOR_CODING_YUV422", "COLOR_CODING_YUV444",
75  "COLOR_CODING_RGB8", "COLOR_CODING_MONO16", "COLOR_CODING_RGB16", "COLOR_CODING_MONO16S",
76  "COLOR_CODING_RGB16S", "COLOR_CODING_RAW8", "COLOR_CODING_RAW16",
77 };
78 
124  : camera(NULL), cameras(NULL), num_cameras(0), camera_id(0), verbose(false), camIsOpen(NULL),
125  num_buffers(4), // ring buffer size
126  isDataModified(NULL), initialShutterMode(NULL), dataCam(NULL)
127 #ifdef VISP_HAVE_DC1394_CAMERA_ENUMERATE // new API > libdc1394-2.0.0-rc7
128  ,
129  d(NULL), list(NULL)
130 #endif
131 {
132  // protected members
133  width = height = 0;
134 
135  // private members
136  init = false;
137 
138  reset = false;
139  initialize(reset);
140 
141  // open();
142 }
143 
154 {
155  /* if(num_cameras >= 1){
156  delete[] isDataModified;
157  delete[] initialShutterMode;
158  delete[] dataCam;
159  }*/
160  close();
161 }
162 
281 void vp1394TwoGrabber::setCamera(uint64_t cam_id)
282 {
283  // Suppose that if camera_id is a camera GUID, this value is greater
284  // than the number of cameras connected to the bus
285  if (cam_id >= num_cameras) {
286  // Check if camera_id is a camera guid
287  bool is_guid = false;
288  // check if the camera_id is a guid
289  for (unsigned int i = 0; i < num_cameras; i++) {
290  if (cameras[i]->guid == cam_id) {
291  this->camera_id = i;
292  is_guid = true;
293  break;
294  }
295  }
296  if (is_guid == false) {
297  std::cout << "Error: The camera with guid 0x" << std::hex << cam_id << " is not present" << std::endl;
298  std::cout << num_cameras << " camera(s) connected" << std::endl;
299  for (unsigned int i = 0; i < num_cameras; i++) {
300  std::cout << " - camera " << i << " with guid 0x" << std::hex << cameras[i]->guid << std::endl;
301  }
302  close();
303  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "The required camera is not present"));
304  }
305  } else {
306  this->camera_id = (unsigned int)cam_id; // The input cam_id is not a
307  // uint64_t guid, but the index of
308  // the camera
309  }
310 
311  // create a pointer to the working camera
312  camera = cameras[this->camera_id];
313 }
314 
329 void vp1394TwoGrabber::getCamera(uint64_t &cam_id)
330 {
331  if (num_cameras) {
332  cam_id = this->camera_id;
333  } else {
334  close();
335  vpERROR_TRACE("No cameras found");
337  }
338 }
339 
355 {
356  if (num_cameras) {
357  return this->camera_id;
358  } else {
359  close();
360  vpERROR_TRACE("No cameras found");
362  }
363 }
364 
372 void vp1394TwoGrabber::getNumCameras(unsigned int &ncameras) const
373 {
374  if (!num_cameras) {
375  vpCTRACE << "No camera found..." << std::endl;
376  ncameras = 0;
377  }
378 
379  ncameras = num_cameras;
380 }
381 
390 {
391  unsigned int ncameras = 0;
392  if (!num_cameras) {
393  vpCTRACE << "No camera found..." << std::endl;
394  ncameras = 0;
395  }
396 
397  ncameras = num_cameras;
398  return ncameras;
399 }
400 
446 {
447  open();
448  if (!num_cameras) {
449  close();
451  }
452  if (!isVideoModeSupported(videomode)) {
453  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Video mode not supported by camera %d",
454  camera_id));
455  }
456  // Stop dma capture if started
457  setTransmission(DC1394_OFF);
458  setCapture(DC1394_OFF);
459 
460  if (dc1394_video_set_mode(camera, (dc1394video_mode_t)videomode) != DC1394_SUCCESS) {
461  close();
462  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't set video mode"));
463  }
464 
465  setCapture(DC1394_ON);
466  setTransmission(DC1394_ON);
467 
468  // Updates image size from new video mode
469  if (dc1394_get_image_size_from_video_mode(camera, (dc1394video_mode_t)videomode, &this->width, &this->height) !=
470  DC1394_SUCCESS) {
471 
472  close();
473  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't get image size"));
474  }
475 }
476 
494 {
495  if (!num_cameras) {
496  close();
497  vpERROR_TRACE("No camera found");
499  }
500 
501  dc1394video_mode_t _videomode;
502  if (dc1394_video_get_mode(camera, &_videomode) != DC1394_SUCCESS) {
503 
504  close();
505  vpERROR_TRACE("Can't get current video mode");
506  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't get current video mode"));
507  }
508  videomode = (vp1394TwoVideoModeType)_videomode;
509 }
510 
528 uint32_t vp1394TwoGrabber::getVideoModeSupported(std::list<vp1394TwoVideoModeType> &videomodes)
529 {
530  // Refresh the list of supported modes
531  videomodes.clear();
532 
533  if (!num_cameras) {
534  close();
535  vpERROR_TRACE("No camera found");
537  }
538  dc1394video_modes_t _videomodes;
539 
540  // get video modes:
541  if (dc1394_video_get_supported_modes(camera, &_videomodes) != DC1394_SUCCESS) {
542 
543  close();
544  vpERROR_TRACE("Can't get video modes");
545  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't get video modes"));
546  }
547 
548  // parse the video modes to add in the list
549  for (unsigned i = 0; i < _videomodes.num; i++) {
550  vp1394TwoVideoModeType _mode = (vp1394TwoVideoModeType)_videomodes.modes[i];
551  videomodes.push_back(_mode);
552  }
553 
554  // return the number of available video modes
555  return _videomodes.num;
556 }
573 {
574  if (!num_cameras) {
575  close();
576  vpERROR_TRACE("No camera found");
578  }
579  dc1394video_modes_t _videomodes;
580 
581  // get video modes:
582  if (dc1394_video_get_supported_modes(camera, &_videomodes) != DC1394_SUCCESS) {
583 
584  close();
585  vpERROR_TRACE("Can't get video modes");
586  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't get video modes"));
587  }
588 
589  // parse the video modes to check with the desired
590  for (unsigned i = 0; i < _videomodes.num; i++) {
591  if ((vp1394TwoVideoModeType)_videomodes.modes[i] == videomode)
592  return true;
593  }
594  return false;
595 }
596 
610 {
611 
612  if (dc1394_is_video_mode_scalable((dc1394video_mode_t)videomode))
613  return true;
614 
615  return false;
616 }
617 
634 {
636  getColorCoding(coding);
637 
638  switch (coding) {
642  case vpCOLOR_CODING_RAW8:
644  return false;
648  case vpCOLOR_CODING_RGB8:
651  return true;
652  }
653  return false;
654 }
655 
681 {
682  open();
683  if (!num_cameras) {
684  close();
686  }
687 
688  vp1394TwoVideoModeType cur_videomode;
689  getVideoMode(cur_videomode);
690  if (isVideoModeFormat7(cur_videomode))
691  return;
692 
693  if (!isFramerateSupported(cur_videomode, fps)) {
694  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Framerate not supported by camera %d",
695  camera_id));
696  }
697 
698  // Stop dma capture if started
699  setTransmission(DC1394_OFF);
700  setCapture(DC1394_OFF);
701 
702  if (dc1394_video_set_framerate(camera, (dc1394framerate_t)fps) != DC1394_SUCCESS) {
703 
704  close();
705  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't set framerate"));
706  }
707 
708  setCapture(DC1394_ON);
709  setTransmission(DC1394_ON);
710 }
711 
729 {
730  if (!num_cameras) {
731  close();
732  vpERROR_TRACE("No camera found");
734  }
735  dc1394framerate_t _fps;
736  if (dc1394_video_get_framerate(camera, &_fps) != DC1394_SUCCESS) {
737 
738  close();
739  vpERROR_TRACE("Can't get current framerate");
740  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't get current framerate"));
741  }
742  fps = (vp1394TwoFramerateType)_fps;
743 }
744 
776 uint32_t vp1394TwoGrabber::getFramerateSupported(vp1394TwoVideoModeType mode, std::list<vp1394TwoFramerateType> &fps)
777 {
778  if (!num_cameras) {
779  close();
780  vpERROR_TRACE("No camera found");
782  }
783 
784  // Refresh the list of supported framerates
785  fps.clear();
786 
787  switch (mode) {
788  // Framerate not available for:
789  // - vpVIDEO_MODE_EXIF ie Format_6
790  // - vpVIDEO_MODE_FORMAT7... ie the Format_7
791  case vpVIDEO_MODE_EXIF:
800  return 0;
801  break;
802  default: {
803  dc1394framerates_t _fps;
804  if (dc1394_video_get_supported_framerates(camera, (dc1394video_mode_t)mode, &_fps) != DC1394_SUCCESS) {
805  close();
806  vpERROR_TRACE("Could not query supported frametates for mode %d\n", mode);
807  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Could not query supported framerates"));
808  }
809  if (_fps.num == 0)
810  return 0;
811 
812  for (unsigned int i = 0; i < _fps.num; i++)
813  fps.push_back((vp1394TwoFramerateType)_fps.framerates[i]);
814 
815  return _fps.num;
816  } break;
817  }
818 }
853 {
854  if (!num_cameras) {
855  close();
856  vpERROR_TRACE("No camera found");
858  }
859 
860  switch (mode) {
861  // Framerate not available for:
862  // - vpVIDEO_MODE_EXIF ie Format_6
863  // - vpVIDEO_MODE_FORMAT7... ie the Format_7
864  case vpVIDEO_MODE_EXIF:
873  return 0;
874  break;
875  default: {
876  dc1394framerates_t _fps;
877  if (dc1394_video_get_supported_framerates(camera, (dc1394video_mode_t)mode, &_fps) != DC1394_SUCCESS) {
878  close();
879  vpERROR_TRACE("Could not query supported frametates for mode %d\n", mode);
880  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Could not query supported framerates"));
881  }
882  if (_fps.num == 0)
883  return 0;
884 
885  for (unsigned int i = 0; i < _fps.num; i++) {
886  if (fps == (vp1394TwoFramerateType)_fps.framerates[i]) {
887  return true;
888  }
889  }
890  return false;
891  } break;
892  }
893 }
894 
943 {
944  if (!num_cameras) {
945  close();
947  }
948 
949  dc1394video_mode_t _videomode;
950  if (dc1394_video_get_mode(camera, &_videomode) != DC1394_SUCCESS) {
951 
952  close();
953  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't get current video mode"));
954  }
955 
956  if (!isColorCodingSupported((vp1394TwoVideoModeType)_videomode, coding)) {
957  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Color coding not supported by camera %d",
958  camera_id));
959  }
960 
961  // Format 7 video mode
962  if (dc1394_is_video_mode_scalable(_videomode)) {
963  setTransmission(DC1394_OFF);
964  setCapture(DC1394_OFF);
965 
966  if (dc1394_format7_set_color_coding(camera, _videomode, (dc1394color_coding_t)coding) != DC1394_SUCCESS) {
967 
968  close();
969  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't set color coding"));
970  }
971 
972  setCapture(DC1394_ON);
973  setTransmission(DC1394_ON);
974  }
975 }
976 
995 {
996  if (!num_cameras) {
997  close();
998  vpERROR_TRACE("No camera found");
1000  }
1001  dc1394video_mode_t _videomode;
1002  if (dc1394_video_get_mode(camera, &_videomode) != DC1394_SUCCESS) {
1003 
1004  close();
1005  vpERROR_TRACE("Can't get current video mode");
1006  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't get current video mode"));
1007  }
1008 
1009  dc1394color_coding_t _coding;
1010  if (dc1394_is_video_mode_scalable(_videomode)) {
1011  // Format 7 video mode
1012  if (dc1394_format7_get_color_coding(camera, _videomode, &_coding) != DC1394_SUCCESS) {
1013 
1014  close();
1015  vpERROR_TRACE("Can't get current color coding");
1016  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't query current color coding"));
1017  }
1018  } else if (dc1394_is_video_mode_still_image((dc1394video_mode_t)_videomode)) {
1019  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "No color coding for format 6 video mode"));
1020  } else {
1021  // Not Format 7 and not Format 6 video modes
1022  if (dc1394_get_color_coding_from_video_mode(camera, (dc1394video_mode_t)_videomode, &_coding) != DC1394_SUCCESS) {
1023  close();
1024  vpERROR_TRACE("Could not query supported color coding for mode %d\n", _videomode);
1025  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't query current color coding"));
1026  }
1027  }
1028  coding = (vp1394TwoColorCodingType)_coding;
1029 }
1030 
1053  std::list<vp1394TwoColorCodingType> &codings)
1054 {
1055  if (!num_cameras) {
1056  close();
1057  vpERROR_TRACE("No camera found");
1059  }
1060 
1061  // Refresh the list of supported framerates
1062  codings.clear();
1063 
1064  if (dc1394_is_video_mode_scalable((dc1394video_mode_t)mode)) {
1065  // Format 7 video mode
1066  dc1394color_codings_t _codings;
1067  if (dc1394_format7_get_color_codings(camera, (dc1394video_mode_t)mode, &_codings) != DC1394_SUCCESS) {
1068  close();
1069  vpERROR_TRACE("Could not query supported color codings for mode %d\n", mode);
1070  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Could not query supported color codings"));
1071  }
1072  if (_codings.num == 0)
1073  return 0;
1074 
1075  for (unsigned int i = 0; i < _codings.num; i++)
1076  codings.push_back((vp1394TwoColorCodingType)_codings.codings[i]);
1077 
1078  return _codings.num;
1079  } else if (dc1394_is_video_mode_still_image((dc1394video_mode_t)mode)) {
1080  // Format 6 video mode
1081  return 0;
1082  } else {
1083  // Not Format 7 and not Format 6 video modes
1084  dc1394color_coding_t _coding;
1085  if (dc1394_get_color_coding_from_video_mode(camera, (dc1394video_mode_t)mode, &_coding) != DC1394_SUCCESS) {
1086  close();
1087  vpERROR_TRACE("Could not query supported color coding for mode %d\n", mode);
1088  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Could not query supported color coding"));
1089  }
1090  codings.push_back((vp1394TwoColorCodingType)_coding);
1091  return 1;
1092  }
1093 }
1116 {
1117  if (!num_cameras) {
1118  close();
1119  vpERROR_TRACE("No camera found");
1121  }
1122 
1123  if (dc1394_is_video_mode_scalable((dc1394video_mode_t)mode)) {
1124  // Format 7 video mode
1125  dc1394color_codings_t _codings;
1126  if (dc1394_format7_get_color_codings(camera, (dc1394video_mode_t)mode, &_codings) != DC1394_SUCCESS) {
1127  close();
1128  vpERROR_TRACE("Could not query supported color codings for mode %d\n", mode);
1129  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Could not query supported color codings"));
1130  }
1131  if (_codings.num == 0)
1132  return 0;
1133 
1134  for (unsigned int i = 0; i < _codings.num; i++) {
1135  if (coding == (vp1394TwoColorCodingType)_codings.codings[i])
1136  return true;
1137  }
1138  return false;
1139  } else if (dc1394_is_video_mode_still_image((dc1394video_mode_t)mode)) {
1140  // Format 6 video mode
1141  return false;
1142  } else {
1143  // Not Format 7 and not Format 6 video modes
1144  dc1394color_coding_t _coding;
1145  if (dc1394_get_color_coding_from_video_mode(camera, (dc1394video_mode_t)mode, &_coding) != DC1394_SUCCESS) {
1146  close();
1147  vpERROR_TRACE("Could not query supported color coding for mode %d\n", mode);
1148  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Could not query supported color coding"));
1149  return false;
1150  }
1151  if (coding == (vp1394TwoColorCodingType)_coding)
1152  return true;
1153 
1154  return false;
1155  }
1156 }
1157 
1189 void vp1394TwoGrabber::setFormat7ROI(unsigned int left, unsigned int top, unsigned int w, unsigned int h)
1190 {
1191  open();
1192  if (!num_cameras) {
1193  close();
1194  vpERROR_TRACE("No camera found");
1196  }
1197 
1198  dc1394video_mode_t _videomode;
1199  if (dc1394_video_get_mode(camera, &_videomode) != DC1394_SUCCESS) {
1200 
1201  close();
1202  vpERROR_TRACE("Can't get current video mode");
1203  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't get current video mode"));
1204  }
1205  if (dc1394_is_video_mode_scalable(_videomode)) {
1206  // Stop dma capture if started
1207  setTransmission(DC1394_OFF);
1208  setCapture(DC1394_OFF);
1209  // Format 7 video mode
1210  unsigned int max_width, max_height;
1211  if (dc1394_format7_get_max_image_size(camera, _videomode, &max_width, &max_height) != DC1394_SUCCESS) {
1212 
1213  close();
1214  vpERROR_TRACE("Can't get format7 max image size");
1215  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't get format7 max image size"));
1216  }
1217 #if 0
1218  vpTRACE("left: %d top: %d width: %d height: %d", left, top,
1219  width == 0 ? DC1394_USE_MAX_AVAIL: w,
1220  height == 0 ? DC1394_USE_MAX_AVAIL : h);
1221  vpTRACE("max_width: %d max_height: %d", max_width, max_height);
1222 #endif
1223 
1224  if (left > max_width) {
1225  vpERROR_TRACE("Can't set format7 ROI");
1226  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't set format7 ROI"));
1227  }
1228  if (top > max_height) {
1229  vpERROR_TRACE("Can't set format7 ROI");
1230  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't set format7 ROI"));
1231  }
1232 
1233  int32_t roi_width;
1234  int32_t roi_height;
1235 
1236  if (w != 0) {
1237  // Check if roi width is acceptable (ie roi is contained in the image)
1238  if (w > (max_width - left))
1239  w = (max_width - left);
1240  roi_width = (int32_t)w;
1241  } else {
1242  roi_width = DC1394_USE_MAX_AVAIL;
1243  }
1244 
1245  if (h != 0) {
1246  // Check if roi height is acceptable (ie roi is contained in the image)
1247  if (h > (max_height - top))
1248  h = (max_height - top);
1249  roi_height = (int32_t)h;
1250  } else {
1251  roi_height = DC1394_USE_MAX_AVAIL;
1252  }
1253 
1254  if (dc1394_format7_set_roi(camera, _videomode,
1255  (dc1394color_coding_t)DC1394_QUERY_FROM_CAMERA, // color_coding
1256  DC1394_USE_MAX_AVAIL /*DC1394_QUERY_FROM_CAMERA*/
1257  , // bytes_per_packet
1258  (int32_t)left, // left
1259  (int32_t)top, // top
1260  roi_width, roi_height) != DC1394_SUCCESS) {
1261  close();
1262  vpERROR_TRACE("Can't set format7 roi");
1263  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't get current video mode"));
1264  }
1265  // Update the image size
1266  if (dc1394_format7_get_image_size(camera, _videomode, &this->width, &this->height) != DC1394_SUCCESS) {
1267  close();
1268  vpERROR_TRACE("Can't get format7 image size");
1269  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Can't get format7 image size"));
1270  }
1271 
1272  setCapture(DC1394_ON);
1273  setTransmission(DC1394_ON);
1274  }
1275 }
1290 void vp1394TwoGrabber::initialize(bool reset)
1291 {
1292  if (init == false) {
1293 // Find cameras
1294 #ifdef VISP_HAVE_DC1394_CAMERA_ENUMERATE // new API > libdc1394-2.0.0-rc7
1295  if (d != NULL)
1296  dc1394_free(d);
1297 
1298  d = dc1394_new();
1299  if (dc1394_camera_enumerate(d, &list) != DC1394_SUCCESS) {
1300  dc1394_camera_free_list(list);
1301  close();
1302  vpERROR_TRACE("Failed to enumerate cameras\n");
1303  throw(vpFrameGrabberException(vpFrameGrabberException::initializationError, "Failed to enumerate cameras"));
1304  }
1305 
1306  if (list->num == 0) {
1307  dc1394_camera_free_list(list);
1308  close();
1309  vpERROR_TRACE("No cameras found");
1311  }
1312 
1313  if (cameras != NULL)
1314  delete[] cameras;
1315 
1316  cameras = new dc1394camera_t *[list->num];
1317 
1318  num_cameras = 0;
1319 
1320  for (unsigned int i = 0; i < list->num; i++) {
1321  cameras[i] = dc1394_camera_new(d, list->ids[i].guid);
1322  if (!cameras[i]) {
1323  vpTRACE("Failed to initialize camera with guid \"%ld\"\n", list->ids[i].guid);
1324  continue;
1325  }
1326  // Update the number of working cameras
1327  num_cameras++;
1328  }
1329 
1330  if (reset) {
1331  // Reset the bus to make firewire working if the program was not
1332  // properly stopped by a CTRL-C. We reset here only the bus attached to
1333  // the first camera
1334  dc1394_reset_bus(cameras[0]);
1335  }
1336 
1337  // if (list != NULL)
1338  dc1394_camera_free_list(list);
1339  list = NULL;
1340 
1341 #elif defined VISP_HAVE_DC1394_FIND_CAMERAS // old API <= libdc1394-2.0.0-rc7
1342  if (cameras != NULL)
1343  free(cameras);
1344  cameras = NULL;
1345  int err = dc1394_find_cameras(&cameras, &num_cameras);
1346 
1347  if (err != DC1394_SUCCESS && err != DC1394_NO_CAMERA) {
1348  close();
1349  vpERROR_TRACE("Unable to look for cameras\n\n"
1350  "Please check \n"
1351  " - if the kernel modules `ieee1394',`raw1394' and "
1352  "`ohci1394' are loaded \n"
1353  " - if you have read/write access to /dev/raw1394\n\n");
1354  throw(vpFrameGrabberException(vpFrameGrabberException::initializationError, "Unable to look for cameras"));
1355  }
1356 #endif
1357 
1358  if (num_cameras == 0) {
1359  close();
1360  vpERROR_TRACE("No cameras found");
1362  }
1363 
1364  // allocation for the parameters
1365  isDataModified = new bool[num_cameras];
1366  for (unsigned int i = 0; i < num_cameras; i++)
1367  isDataModified[i] = false;
1368  initialShutterMode = new dc1394feature_mode_t[num_cameras];
1369  dataCam = new vpDc1394TwoCameraParametersData[num_cameras];
1370 
1371  if (camera_id >= num_cameras) {
1372  // Bad camera id
1373  close();
1374  vpERROR_TRACE("Bad camera id: %u", camera_id);
1375  vpERROR_TRACE("Only %u camera on the bus.", num_cameras);
1377  }
1378 
1379  if (verbose) {
1380  std::cout << "------ Bus information ------" << std::endl;
1381  std::cout << "Number of camera(s) on the bus : " << num_cameras << std::endl;
1382  std::cout << "-----------------------------" << std::endl;
1383  }
1384 
1385  if (camIsOpen != NULL)
1386  delete[] camIsOpen;
1387  camIsOpen = new bool[num_cameras];
1388  for (unsigned int i = 0; i < num_cameras; i++) {
1389  camIsOpen[i] = false;
1390  }
1391 
1392  init = true;
1393  }
1394 }
1405 {
1406  if (init == false)
1407  initialize(false);
1408  if (camIsOpen[camera_id] == false) {
1409  dc1394switch_t status = DC1394_OFF;
1410 
1411  //#ifdef VISP_HAVE_DC1394_CAMERA_ENUMERATE // new API >
1412  // libdc1394-2.0.0-rc7
1413  dc1394_video_get_transmission(cameras[camera_id], &status);
1414  if (status != DC1394_OFF) {
1415  //#endif
1416  if (dc1394_video_set_transmission(cameras[camera_id], DC1394_OFF) != DC1394_SUCCESS)
1417  vpTRACE("Could not stop ISO transmission");
1418  else {
1419  vpTime::wait(500);
1420  if (dc1394_video_get_transmission(cameras[camera_id], &status) != DC1394_SUCCESS)
1421  vpTRACE("Could get ISO status");
1422  else {
1423  if (status == DC1394_ON) {
1424  vpTRACE("ISO transmission refuses to stop");
1425  }
1426 #ifdef VISP_HAVE_DC1394_FIND_CAMERAS // old API <= libdc1394-2.0.0-rc7
1427  // No yet in the new API
1428  cameras[camera_id]->is_iso_on = status;
1429 #endif
1430  }
1431  //#ifdef VISP_HAVE_DC1394_CAMERA_ENUMERATE // new API >
1432  // libdc1394-2.0.0-rc7
1433  }
1434  //#endif
1435  }
1436  setCamera(camera_id);
1437  // setIsoSpeed(DC1394_ISO_SPEED_400);
1438  setCapture(DC1394_ON);
1439  setTransmission(DC1394_ON);
1440  camIsOpen[camera_id] = true;
1441  }
1442 }
1452 {
1453  if (init) {
1454  if (num_cameras) {
1455  for (unsigned int i = 0; i < num_cameras; i++) {
1456  if (camIsOpen[i]) {
1457  camera = cameras[i];
1458  this->camera_id = i; // set camera id for the function updateDataStructToCam
1459  setTransmission(DC1394_OFF);
1460  setCapture(DC1394_OFF);
1461  if (isDataModified[i]) {
1462  // reset values
1463  try {
1464  updateDataStructToCam();
1465  } catch (...) {
1466  }
1467  // reset mode (manual, auto, ...)
1468  if (dc1394_feature_set_mode(camera, DC1394_FEATURE_BRIGHTNESS, initialShutterMode[i]) != DC1394_SUCCESS ||
1469  dc1394_feature_set_mode(camera, DC1394_FEATURE_EXPOSURE, initialShutterMode[i]) != DC1394_SUCCESS ||
1470  dc1394_feature_set_mode(camera, DC1394_FEATURE_SHARPNESS, initialShutterMode[i]) != DC1394_SUCCESS ||
1471  dc1394_feature_set_mode(camera, DC1394_FEATURE_HUE, initialShutterMode[i]) != DC1394_SUCCESS ||
1472  dc1394_feature_set_mode(camera, DC1394_FEATURE_SATURATION, initialShutterMode[i]) != DC1394_SUCCESS ||
1473  dc1394_feature_set_mode(camera, DC1394_FEATURE_GAMMA, initialShutterMode[i]) != DC1394_SUCCESS ||
1474  dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, initialShutterMode[i]) != DC1394_SUCCESS ||
1475  dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, initialShutterMode[i]) != DC1394_SUCCESS ||
1476  dc1394_feature_set_mode(camera, DC1394_FEATURE_IRIS, initialShutterMode[i])) {
1477 
1478  vpERROR_TRACE("Unable to reset the initial mode");
1479  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Unable to reset the initial mode"));
1480  }
1481  }
1482  if (dc1394_camera_set_power(camera, DC1394_OFF) != DC1394_SUCCESS)
1483  std::cout << "Unable to turn camera off" << std::endl;
1484  }
1485 #ifdef VISP_HAVE_DC1394_CAMERA_ENUMERATE // new API > libdc1394-2.0.0-rc7
1486  dc1394_camera_free(cameras[i]);
1487 #elif defined VISP_HAVE_DC1394_FIND_CAMERAS // old API <= libdc1394-2.0.0-rc7
1488  dc1394_free_camera(cameras[i]);
1489 #endif
1490  }
1491  }
1492  if (camIsOpen != NULL) {
1493  delete[] camIsOpen;
1494  camIsOpen = NULL;
1495  }
1496 
1497 #ifdef VISP_HAVE_DC1394_CAMERA_ENUMERATE // new API > libdc1394-2.0.0-rc7
1498  if (cameras != NULL) {
1499  delete[] cameras;
1500  cameras = NULL;
1501  }
1502  if (d != NULL) {
1503  dc1394_free(d);
1504  d = NULL;
1505  }
1506 
1507 #elif defined VISP_HAVE_DC1394_FIND_CAMERAS // old API <= libdc1394-2.0.0-rc7
1508  if (cameras != NULL) {
1509  free(cameras);
1510  cameras = NULL;
1511  }
1512 #endif
1513 
1514  camIsOpen = NULL;
1515  num_cameras = 0;
1516 
1517  // remove data for the parameters
1518  if (isDataModified != NULL) {
1519  delete[] isDataModified;
1520  isDataModified = NULL;
1521  }
1522  if (initialShutterMode != NULL) {
1523  delete[] initialShutterMode;
1524  initialShutterMode = NULL;
1525  }
1526  if (dataCam != NULL) {
1527  delete[] dataCam;
1528  dataCam = NULL;
1529  }
1530 
1531  init = false;
1532  }
1533 }
1534 
1548 {
1549  if (size < 1) {
1550  close();
1551  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Could not set ring buffer size"));
1552  }
1553 
1554  if (size != num_buffers) {
1555  // We need to change the ring buffer size
1556  num_buffers = size;
1557  if (camIsOpen[camera_id]) {
1558  setCapture(DC1394_OFF);
1559  setCapture(DC1394_ON);
1560  }
1561  }
1562 }
1563 
1573 unsigned int vp1394TwoGrabber::getRingBufferSize() const { return num_buffers; }
1574 
1614 {
1615  if (!num_cameras) {
1616  close();
1617  vpERROR_TRACE("No camera found");
1619  }
1620 
1621  dc1394feature_mode_t mode;
1622  if (enable) {
1623  mode = DC1394_FEATURE_MODE_AUTO;
1624  } else {
1625  mode = DC1394_FEATURE_MODE_MANUAL;
1626  }
1627 
1628  if (dc1394_feature_set_power(camera, DC1394_FEATURE_SHUTTER, DC1394_ON) != DC1394_SUCCESS) {
1629  // vpERROR_TRACE("Cannot set shutter on. \n");
1630  close();
1631  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Cannot set shutter on"));
1632  }
1633 
1634  if (dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, mode) != DC1394_SUCCESS) {
1635  // vpERROR_TRACE("Cannot set auto shutter. \n");
1636  close();
1637  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Cannot set auto shutter"));
1638  }
1639 }
1679 void vp1394TwoGrabber::setAutoShutter(unsigned int minvalue, unsigned int maxvalue)
1680 {
1681  setAutoShutter();
1682 
1683  if (dc1394_avt_set_auto_shutter(camera, minvalue, maxvalue) != DC1394_SUCCESS) {
1684  // vpERROR_TRACE("Cannot set auto shutter min and max values. Is the
1685  // camera an AVT one?\n");
1686  close();
1687  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Cannot set auto shutter min and max values"));
1688  }
1689 }
1690 
1703 void vp1394TwoGrabber::getAutoShutter(unsigned int &minvalue, unsigned int &maxvalue)
1704 {
1705  if (!num_cameras) {
1706  close();
1707  vpERROR_TRACE("No camera found");
1709  }
1710 
1711  if (dc1394_avt_get_auto_shutter(camera, &minvalue, &maxvalue) != DC1394_SUCCESS) {
1712  // vpERROR_TRACE("Cannot get auto shutter min and max values. Is the
1713  // camera an AVT one?\n");
1714  close();
1715  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Cannot get auto shutter min and max values"));
1716  }
1717 }
1718 
1758 {
1759  if (!num_cameras) {
1760  close();
1761  vpERROR_TRACE("No camera found");
1763  }
1764 
1765  dc1394feature_mode_t mode;
1766  if (enable) {
1767  mode = DC1394_FEATURE_MODE_AUTO;
1768  } else {
1769  mode = DC1394_FEATURE_MODE_MANUAL;
1770  }
1771 
1772  if (dc1394_feature_set_power(camera, DC1394_FEATURE_GAIN, DC1394_ON) != DC1394_SUCCESS) {
1773  // vpERROR_TRACE("Cannot set shutter on. \n");
1774  close();
1775  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Cannot set shutter on"));
1776  }
1777 
1778  if (dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, mode) != DC1394_SUCCESS) {
1779  // vpERROR_TRACE("Cannot set auto gain. \n");
1780  close();
1781  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Cannot set auto gain"));
1782  }
1783 }
1823 void vp1394TwoGrabber::setAutoGain(unsigned int minvalue, unsigned int maxvalue)
1824 {
1825  setAutoGain();
1826 
1827  if (dc1394_avt_set_auto_gain(camera, minvalue, maxvalue) != DC1394_SUCCESS) {
1828  // vpERROR_TRACE("Cannot set auto gain min and max values. Is the
1829  // camera an AVT one?\n");
1830  close();
1831  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Cannot set auto gain min and max values"));
1832  }
1833 }
1834 
1847 void vp1394TwoGrabber::getAutoGain(unsigned int &minvalue, unsigned int &maxvalue)
1848 {
1849  if (!num_cameras) {
1850  close();
1851  vpERROR_TRACE("No camera found");
1853  }
1854 
1855  if (dc1394_avt_get_auto_gain(camera, &minvalue, &maxvalue) != DC1394_SUCCESS) {
1856  // vpERROR_TRACE("Cannot get auto gain min and max values. Is the
1857  // camera an AVT one?\n");
1858  close();
1859  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Cannot get auto gain min and max values"));
1860  }
1861 }
1862 
1880 void vp1394TwoGrabber::setCapture(dc1394switch_t _switch)
1881 {
1882  if (!num_cameras) {
1883  close();
1884  vpERROR_TRACE("No camera found");
1886  }
1887 
1888  if (_switch == DC1394_ON) {
1889  // if (dc1394_capture_setup(camera, num_buffers) != DC1394_SUCCESS) {
1890  // To be compatible with libdc1394 svn 382 version
1891  if (dc1394_capture_setup(camera, num_buffers, DC1394_CAPTURE_FLAGS_DEFAULT) != DC1394_SUCCESS) {
1892  vpERROR_TRACE("Unable to setup camera capture-\n"
1893  "make sure that the video mode and framerate are "
1894  "supported by your camera.\n");
1895  close();
1896  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Could not setup dma capture"));
1897  }
1898  } else { // _switch == DC1394_OFF
1899  dc1394error_t code = dc1394_capture_stop(camera);
1900 
1901  if (code != DC1394_SUCCESS && code != DC1394_CAPTURE_IS_NOT_SET) {
1902  vpERROR_TRACE("Unable to stop camera capture\n");
1903  close();
1904  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Could not setup dma capture"));
1905  }
1906  }
1907 }
1908 
1923 void vp1394TwoGrabber::setTransmission(dc1394switch_t _switch)
1924 {
1925  if (!num_cameras) {
1926  close();
1927  vpERROR_TRACE("No camera found");
1929  }
1930 
1931  dc1394switch_t status = DC1394_OFF;
1932 
1933  if (dc1394_video_get_transmission(camera, &status) != DC1394_SUCCESS) {
1934  vpERROR_TRACE("Unable to get transmision status");
1935  close();
1936  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Could not setup dma capture"));
1937  }
1938 
1939  // if (status!=_switch){
1940  // Start dma capture if halted
1941  if (dc1394_video_set_transmission(camera, _switch) != DC1394_SUCCESS) {
1942  vpERROR_TRACE("Unable to setup camera capture-\n"
1943  "make sure that the video mode and framerate are "
1944  "supported by your camera.\n");
1945  close();
1946  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Could not setup dma capture"));
1947  }
1948 
1949  if (_switch == DC1394_ON) {
1950  status = DC1394_OFF;
1951 
1952  int i = 0;
1953  while (status == DC1394_OFF && i++ < 5) {
1954  usleep(50000);
1955  if (dc1394_video_get_transmission(camera, &status) != DC1394_SUCCESS) {
1956  vpERROR_TRACE("Unable to get transmision status");
1957  close();
1958  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Could not setup dma capture"));
1959  }
1960  }
1961  }
1962  // }
1963 }
1964 
1999 {
2000  if (!num_cameras) {
2001  close();
2002  vpERROR_TRACE("No camera found");
2004  }
2005 
2006  dc1394operation_mode_t op_mode;
2007  dc1394speed_t speed;
2008 
2009  // Check the speed to configure in B-mode or A-mode
2010  if (isospeed >= vpISO_SPEED_800) {
2011  if (camera->bmode_capable != DC1394_TRUE) {
2012  // vpERROR_TRACE("Camera is not 1394B mode capable. \n"
2013  // "Set the iso speed lower or equal to 400Mbps");
2014  close();
2015  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Camera is not 1394B mode capable"));
2016  }
2017 
2018  if (dc1394_video_set_operation_mode(camera, DC1394_OPERATION_MODE_1394B) != DC1394_SUCCESS) {
2019  // vpERROR_TRACE("Cannot set camera to 1394B mode. \n");
2020  close();
2021  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Cannot set camera to 1394B mode"));
2022  }
2023 
2024  if (dc1394_video_get_operation_mode(camera, &op_mode) != DC1394_SUCCESS) {
2025  // vpERROR_TRACE("Failed to set 1394B mode. \n");
2026  close();
2027  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Failed to set 1394B mode"));
2028  }
2029  } else {
2030  if (dc1394_video_set_operation_mode(camera, DC1394_OPERATION_MODE_LEGACY) != DC1394_SUCCESS) {
2031  // vpERROR_TRACE("Cannot set camera to 1394A mode. \n");
2032  close();
2033  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Cannot set camera to 1394A mode"));
2034  }
2035 
2036  if (dc1394_video_get_operation_mode(camera, &op_mode) != DC1394_SUCCESS) {
2037  // vpERROR_TRACE("Failed to set 1394A mode. \n");
2038  close();
2039  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Failed to set 1394A mode"));
2040  }
2041  }
2042 
2043  if (dc1394_video_set_iso_speed(camera, (dc1394speed_t)isospeed) != DC1394_SUCCESS) {
2044  // vpERROR_TRACE("Cannot set requested iso speed. \n");
2045  close();
2046  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Cannot set requested iso speed"));
2047  }
2048 
2049  if (dc1394_video_get_iso_speed(camera, &speed) != DC1394_SUCCESS) {
2050  // vpERROR_TRACE("Failed to set iso speed. \n");
2051  close();
2052  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Failed to set iso speed"));
2053  }
2054 }
2055 
2067 {
2068  open();
2069  acquire(I);
2070 }
2071 
2083 {
2084  open();
2085  acquire(I);
2086 }
2087 
2125 dc1394video_frame_t *vp1394TwoGrabber::dequeue()
2126 {
2127 
2128  if (!num_cameras) {
2129  close();
2130  vpERROR_TRACE("No camera found");
2132  }
2133 
2134  dc1394video_frame_t *frame = NULL;
2135 
2136  if (dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_WAIT, &frame) != DC1394_SUCCESS) {
2137  vpERROR_TRACE("Error: Failed to capture from camera %d\n", camera_id);
2138  }
2139 
2140  return frame;
2141 }
2142 
2184 {
2185  uint64_t timestamp;
2186  uint32_t id;
2187 
2188  dc1394video_frame_t *frame;
2189 
2190  frame = dequeue(I, timestamp, id);
2191 
2192  return frame;
2193 }
2194 
2242 dc1394video_frame_t *vp1394TwoGrabber::dequeue(vpImage<unsigned char> &I, uint64_t &timestamp, uint32_t &id)
2243 {
2244 
2245  open();
2246 
2247  dc1394video_frame_t *frame;
2248 
2249  frame = dequeue();
2250 
2251  // Timeval data structure providing the unix time
2252  // [microseconds] at which the frame was captured in the ring buffer.
2253  timestamp = frame->timestamp;
2254  id = frame->id;
2255 
2256  this->width = frame->size[0];
2257  this->height = frame->size[1];
2258  unsigned int size = this->width * this->height;
2259 
2260  if ((I.getWidth() != this->width) || (I.getHeight() != this->height))
2261  I.resize(this->height, this->width);
2262 
2263  switch (frame->color_coding) {
2264  case DC1394_COLOR_CODING_MONO8:
2265  case DC1394_COLOR_CODING_RAW8:
2266  memcpy(I.bitmap, (unsigned char *)frame->image, size * sizeof(unsigned char));
2267  break;
2268  case DC1394_COLOR_CODING_MONO16:
2269  case DC1394_COLOR_CODING_RAW16:
2270  vpImageConvert::MONO16ToGrey((unsigned char *)frame->image, I.bitmap, size);
2271  break;
2272 
2273  case DC1394_COLOR_CODING_YUV411:
2274  vpImageConvert::YUV411ToGrey((unsigned char *)frame->image, I.bitmap, size);
2275  break;
2276 
2277  case DC1394_COLOR_CODING_YUV422:
2278  vpImageConvert::YUV422ToGrey((unsigned char *)frame->image, I.bitmap, size);
2279  break;
2280 
2281  case DC1394_COLOR_CODING_YUV444:
2282  vpImageConvert::YUV444ToGrey((unsigned char *)frame->image, I.bitmap, size);
2283  break;
2284 
2285  case DC1394_COLOR_CODING_RGB8:
2286  vpImageConvert::RGBToGrey((unsigned char *)frame->image, I.bitmap, size);
2287  break;
2288 
2289  default:
2290  close();
2291  vpERROR_TRACE("Format conversion not implemented. Acquisition failed.");
2292  throw(vpFrameGrabberException(vpFrameGrabberException::otherError, "Format conversion not implemented. "
2293  "Acquisition failed."));
2294  };
2295 
2296  return frame;
2297 }
2298 
2339 {
2340  uint64_t timestamp;
2341  uint32_t id;
2342 
2343  dc1394video_frame_t *frame;
2344 
2345  frame = dequeue(I, timestamp, id);
2346 
2347  return frame;
2348 }
2349 
2397 dc1394video_frame_t *vp1394TwoGrabber::dequeue(vpImage<vpRGBa> &I, uint64_t &timestamp, uint32_t &id)
2398 {
2399 
2400  open();
2401 
2402  dc1394video_frame_t *frame;
2403 
2404  frame = dequeue();
2405 
2406  // Timeval data structure providing the unix time
2407  // [microseconds] at which the frame was captured in the ring buffer.
2408  timestamp = frame->timestamp;
2409  id = frame->id;
2410 
2411  this->width = frame->size[0];
2412  this->height = frame->size[1];
2413  unsigned int size = this->width * this->height;
2414 
2415  if ((I.getWidth() != width) || (I.getHeight() != height))
2416  I.resize(height, width);
2417 
2418  switch (frame->color_coding) {
2419  case DC1394_COLOR_CODING_MONO8:
2420  case DC1394_COLOR_CODING_RAW8:
2421  vpImageConvert::GreyToRGBa((unsigned char *)frame->image, (unsigned char *)I.bitmap, size);
2422  break;
2423 
2424  case DC1394_COLOR_CODING_MONO16:
2425  case DC1394_COLOR_CODING_RAW16:
2426  vpImageConvert::MONO16ToRGBa((unsigned char *)frame->image, (unsigned char *)I.bitmap, size);
2427  break;
2428 
2429  case DC1394_COLOR_CODING_YUV411:
2430  vpImageConvert::YUV411ToRGBa((unsigned char *)frame->image, (unsigned char *)I.bitmap, size);
2431  break;
2432 
2433  case DC1394_COLOR_CODING_YUV422:
2434  vpImageConvert::YUV422ToRGBa((unsigned char *)frame->image, (unsigned char *)I.bitmap, size);
2435  break;
2436 
2437  case DC1394_COLOR_CODING_YUV444:
2438  vpImageConvert::YUV444ToRGBa((unsigned char *)frame->image, (unsigned char *)I.bitmap, size);
2439  break;
2440 
2441  case DC1394_COLOR_CODING_RGB8:
2442  vpImageConvert::RGBToRGBa((unsigned char *)frame->image, (unsigned char *)I.bitmap, size);
2443  break;
2444 
2445  default:
2446  close();
2447  vpERROR_TRACE("Format conversion not implemented. Acquisition failed.");
2448  throw(vpFrameGrabberException(vpFrameGrabberException::otherError, "Format conversion not implemented. "
2449  "Acquisition failed."));
2450  };
2451 
2452  return frame;
2453 }
2454 
2465 void vp1394TwoGrabber::enqueue(dc1394video_frame_t *frame)
2466 {
2467 
2468  if (!num_cameras) {
2469  close();
2470  vpERROR_TRACE("No camera found");
2472  }
2473 
2474  if (frame)
2475  dc1394_capture_enqueue(camera, frame);
2476 }
2477 
2492 {
2493  uint64_t timestamp;
2494  uint32_t id;
2495 
2496  dc1394video_frame_t *frame;
2497 
2498  frame = dequeue(I, timestamp, id);
2499  enqueue(frame);
2500 }
2501 
2520 void vp1394TwoGrabber::acquire(vpImage<unsigned char> &I, uint64_t &timestamp, uint32_t &id)
2521 {
2522  dc1394video_frame_t *frame;
2523 
2524  open();
2525  frame = dequeue(I, timestamp, id);
2526  enqueue(frame);
2527 }
2528 
2543 {
2544  uint64_t timestamp;
2545  uint32_t id;
2546  dc1394video_frame_t *frame;
2547 
2548  open();
2549  frame = dequeue(I, timestamp, id);
2550  enqueue(frame);
2551 }
2552 
2571 void vp1394TwoGrabber::acquire(vpImage<vpRGBa> &I, uint64_t &timestamp, uint32_t &id)
2572 {
2573  dc1394video_frame_t *frame;
2574 
2575  open();
2576  frame = dequeue();
2577  // Timeval data structure providing the unix time
2578  // [microseconds] at which the frame was captured in the ring buffer.
2579  timestamp = frame->timestamp;
2580  id = frame->id;
2581 
2582  this->width = frame->size[0];
2583  this->height = frame->size[1];
2584  unsigned int size = this->width * this->height;
2585 
2586  if ((I.getWidth() != width) || (I.getHeight() != height))
2587  I.resize(height, width);
2588 
2589  switch (frame->color_coding) {
2590  case DC1394_COLOR_CODING_MONO8:
2591  case DC1394_COLOR_CODING_RAW8:
2592  vpImageConvert::GreyToRGBa((unsigned char *)frame->image, (unsigned char *)I.bitmap, size);
2593  break;
2594 
2595  case DC1394_COLOR_CODING_YUV411:
2596  vpImageConvert::YUV411ToRGBa((unsigned char *)frame->image, (unsigned char *)I.bitmap, size);
2597  break;
2598 
2599  case DC1394_COLOR_CODING_YUV422:
2600  vpImageConvert::YUV422ToRGBa((unsigned char *)frame->image, (unsigned char *)I.bitmap, size);
2601  break;
2602 
2603  case DC1394_COLOR_CODING_YUV444:
2604  vpImageConvert::YUV444ToRGBa((unsigned char *)frame->image, (unsigned char *)I.bitmap, size);
2605  break;
2606 
2607  case DC1394_COLOR_CODING_RGB8:
2608  vpImageConvert::RGBToRGBa((unsigned char *)frame->image, (unsigned char *)I.bitmap, size);
2609  break;
2610 
2611  default:
2612  close();
2613  vpERROR_TRACE("Format conversion not implemented. Acquisition failed.");
2614  throw(vpFrameGrabberException(vpFrameGrabberException::otherError, "Format conversion not implemented. "
2615  "Acquisition failed."));
2616  };
2617 
2618  enqueue(frame);
2619 }
2620 
2637 void vp1394TwoGrabber::getWidth(unsigned int &w)
2638 {
2639  if (!num_cameras) {
2640  close();
2641  vpERROR_TRACE("No camera found");
2643  }
2644 
2645  w = this->width;
2646 }
2647 
2666 {
2667  if (!num_cameras) {
2668  close();
2669  vpERROR_TRACE("No camera found");
2671  }
2672 
2673  return this->width;
2674 }
2675 
2693 void vp1394TwoGrabber::getHeight(unsigned int &h)
2694 {
2695  if (!num_cameras) {
2696  close();
2697  vpERROR_TRACE("No camera found");
2699  }
2700 
2701  h = this->height;
2702 }
2721 {
2722  if (!num_cameras) {
2723  close();
2724  vpERROR_TRACE("No camera found");
2726  }
2727 
2728  return this->height;
2729 }
2730 
2737 {
2738  std::cout << "----------------------------------------------------------" << std::endl
2739  << "----- Information for camera " << camera_id << " -----" << std::endl
2740  << "----------------------------------------------------------" << std::endl;
2741 
2742 #ifdef VISP_HAVE_DC1394_CAMERA_ENUMERATE // new API > libdc1394-2.0.0-rc7
2743  dc1394_camera_print_info(camera, stdout);
2744 #elif defined VISP_HAVE_DC1394_FIND_CAMERAS // old API <= libdc1394-2.0.0-rc7
2745  dc1394_print_camera_info(camera);
2746 #endif
2747 
2748  dc1394featureset_t features;
2749 #ifdef VISP_HAVE_DC1394_CAMERA_ENUMERATE // new API > libdc1394-2.0.0-rc7
2750  if (dc1394_feature_get_all(camera, &features) != DC1394_SUCCESS)
2751 #elif defined VISP_HAVE_DC1394_FIND_CAMERAS // old API <= libdc1394-2.0.0-rc7
2752  if (dc1394_get_camera_feature_set(camera, &features) != DC1394_SUCCESS)
2753 #endif
2754  {
2755  close();
2756  vpERROR_TRACE("unable to get feature set for camera %d\n", camera_id);
2757  throw(vpFrameGrabberException(vpFrameGrabberException::initializationError, "Cannot get camera features"));
2758 
2759  } else {
2760 #ifdef VISP_HAVE_DC1394_CAMERA_ENUMERATE // new API > libdc1394-2.0.0-rc7
2761  dc1394_feature_print_all(&features, stdout);
2762 #elif defined VISP_HAVE_DC1394_FIND_CAMERAS // old API <= libdc1394-2.0.0-rc7
2763  dc1394_print_feature_set(&features);
2764 #endif
2765  }
2766  std::cout << "----------------------------------------------------------" << std::endl;
2767 }
2768 
2782 {
2783  std::string _str = "";
2784  dc1394video_mode_t _videomode = (dc1394video_mode_t)videomode;
2785 
2786  if ((_videomode >= DC1394_VIDEO_MODE_MIN) && (_videomode <= DC1394_VIDEO_MODE_MAX)) {
2787  _str = strVideoMode[_videomode - DC1394_VIDEO_MODE_MIN];
2788  } else {
2789  vpCERROR << "The video mode " << (int)videomode << " is not supported by the camera" << std::endl;
2790  }
2791 
2792  return _str;
2793 }
2794 
2808 {
2809  std::string _str = "";
2810  dc1394framerate_t _fps = (dc1394framerate_t)fps;
2811 
2812  if ((_fps >= DC1394_FRAMERATE_MIN) && (_fps <= DC1394_FRAMERATE_MAX)) {
2813  _str = strFramerate[_fps - DC1394_FRAMERATE_MIN];
2814  } else {
2815  vpCERROR << "The framerate " << (int)fps << " is not supported by the camera" << std::endl;
2816  }
2817 
2818  return _str;
2819 }
2820 
2834 {
2835  std::string _str = "";
2836  dc1394color_coding_t _coding = (dc1394color_coding_t)colorcoding;
2837 
2838  if ((_coding >= DC1394_COLOR_CODING_MIN) && (_coding <= DC1394_COLOR_CODING_MAX)) {
2839  _str = strColorCoding[_coding - DC1394_COLOR_CODING_MIN];
2840 
2841  } else {
2842  vpCERROR << "The color coding " << (int)colorcoding << " is not supported by the camera" << std::endl;
2843  }
2844 
2845  return _str;
2846 }
2847 
2866 {
2868 
2869  for (int i = DC1394_VIDEO_MODE_MIN; i <= DC1394_VIDEO_MODE_MAX; i++) {
2870  _id = (vp1394TwoVideoModeType)i;
2871  if (videomode.compare(videoMode2string(_id)) == 0)
2872  return _id;
2873  };
2874 
2875  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "The required videomode is not valid"));
2876 
2877  return (vp1394TwoVideoModeType)0;
2878 }
2879 
2898 {
2900 
2901  for (int i = DC1394_FRAMERATE_MIN; i <= DC1394_FRAMERATE_MAX; i++) {
2902  _id = (vp1394TwoFramerateType)i;
2903  if (framerate.compare(framerate2string(_id)) == 0)
2904  return _id;
2905  };
2906 
2907  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "The required framerate is not valid"));
2908 
2909  return (vp1394TwoFramerateType)0;
2910 }
2911 
2930 {
2932 
2933  for (int i = DC1394_COLOR_CODING_MIN; i <= DC1394_COLOR_CODING_MAX; i++) {
2934  _id = (vp1394TwoColorCodingType)i;
2935  if (colorcoding.compare(colorCoding2string(_id)) == 0)
2936  return _id;
2937  };
2938 
2939  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "The required color coding is not valid"));
2940 
2941  return (vp1394TwoColorCodingType)0;
2942 }
2943 
2976 {
2977  for (unsigned int i = 0; i < num_cameras; i++) {
2978  if (camIsOpen[i]) {
2979  camera = cameras[i];
2980  setTransmission(DC1394_OFF);
2981  setCapture(DC1394_OFF);
2982  }
2983  }
2984 #ifdef VISP_HAVE_DC1394_CAMERA_ENUMERATE // new API > libdc1394-2.0.0-rc7
2985  setCamera(camera_id);
2986  // free the other cameras
2987  for (unsigned int i = 0; i < num_cameras; i++) {
2988  if (i != camera_id)
2989  dc1394_camera_free(cameras[i]);
2990  }
2991 
2992  printf("Reseting bus...\n");
2993  dc1394_reset_bus(camera);
2994 
2995  dc1394_camera_free(camera);
2996  dc1394_free(d);
2997  d = NULL;
2998  // if (cameras != NULL)
2999  delete[] cameras;
3000  cameras = NULL;
3001 #elif defined VISP_HAVE_DC1394_FIND_CAMERAS // old API <= libdc1394-2.0.0-rc7
3002 
3003  setCamera(camera_id);
3004  // free the other cameras
3005  for (unsigned int i = 0; i < num_cameras; i++) {
3006  if (i != camera_id)
3007  dc1394_free_camera(cameras[i]);
3008  }
3009  free(cameras);
3010  cameras = NULL;
3011 
3012  dc1394_reset_bus(camera);
3013  dc1394_free_camera(camera);
3014 
3015 #endif
3016  if (camIsOpen != NULL)
3017  delete[] camIsOpen;
3018  camIsOpen = NULL;
3019 
3020  num_cameras = 0;
3021 
3022  init = false;
3023  vpTime::wait(1000);
3024  initialize(false);
3025 }
3026 
3057 void vp1394TwoGrabber::setPanControl(unsigned int panControlValue)
3058 {
3059  open();
3060  if (!num_cameras) {
3061  close();
3062  vpERROR_TRACE("No camera found");
3064  }
3065  uint64_t offset = 0x884;
3066  uint32_t value = 0x82000000 + (uint32_t)panControlValue;
3067  dc1394error_t err;
3068  err = dc1394_set_control_register(camera, offset, value);
3069  if (err != DC1394_SUCCESS) {
3070  vpERROR_TRACE("Unable to set PAN register");
3071  close();
3072  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Unable to set PAN register"));
3073  }
3074 }
3075 
3093 {
3094  if (!num_cameras) {
3095  close();
3096  vpERROR_TRACE("No camera found");
3098  }
3099 
3100  uint32_t value;
3101  dc1394feature_t feature = DC1394_FEATURE_BRIGHTNESS; // = (dc1394feature_t)param;
3102  switch (param) {
3103  case vpFEATURE_BRIGHTNESS:
3104  feature = DC1394_FEATURE_BRIGHTNESS;
3105  break;
3106  case vpFEATURE_EXPOSURE:
3107  feature = DC1394_FEATURE_EXPOSURE;
3108  break;
3109  case vpFEATURE_SHARPNESS:
3110  feature = DC1394_FEATURE_SHARPNESS;
3111  break;
3112  // vpFEATURE_WHITE_BALANCE = DC1394_FEATURE_WHITE_BALANCE,
3113  case vpFEATURE_HUE:
3114  feature = DC1394_FEATURE_HUE;
3115  break;
3116  case vpFEATURE_SATURATION:
3117  feature = DC1394_FEATURE_SATURATION;
3118  break;
3119  case vpFEATURE_GAMMA:
3120  feature = DC1394_FEATURE_GAMMA;
3121  break;
3122  case vpFEATURE_SHUTTER:
3123  feature = DC1394_FEATURE_SHUTTER;
3124  break;
3125  case vpFEATURE_GAIN:
3126  feature = DC1394_FEATURE_GAIN;
3127  break;
3128  case vpFEATURE_IRIS:
3129  feature = DC1394_FEATURE_IRIS;
3130  break;
3131  // vpFEATURE_FOCUS = DC1394_FEATURE_FOCUS,
3132  // vpFEATURE_TEMPERATURE = DC1394_FEATURE_TEMPERATURE,
3133  // vpFEATURE_TRIGGER = DC1394_FEATURE_TRIGGER,
3134  // vpFEATURE_TRIGGER_DELAY = DC1394_FEATURE_TRIGGER_DELAY,
3135  // vpFEATURE_WHITE_SHADING = DC1394_FEATURE_WHITE_SHADING,
3136  // vpFEATURE_FRAME_RATE = DC1394_FEATURE_FRAME_RATE,
3137  // vpFEATURE_ZOOM = DC1394_FEATURE_ZOOM,
3138  // vpFEATURE_PAN = DC1394_FEATURE_PAN,
3139  // vpFEATURE_TILT = DC1394_FEATURE_TILT,
3140  // vpFEATURE_OPTICAL_FILTER = DC1394_FEATURE_OPTICAL_FILTER,
3141  // vpFEATURE_CAPTURE_SIZE = DC1394_FEATURE_CAPTURE_SIZE,
3142  // vpFEATURE_CAPTURE_QUALITY = DC1394_FEATURE_CAPTURE_QUALITY
3143  }
3144 
3145  dc1394error_t err;
3146  err = dc1394_feature_get_value(camera, feature, &value);
3147  if (err != DC1394_SUCCESS) {
3148  vpERROR_TRACE("Unable to get the information");
3149  close();
3150  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Unable to get the information"));
3151  }
3152  return (unsigned int)value;
3153 }
3154 
3177 {
3178  if (!num_cameras) {
3179  close();
3180  vpERROR_TRACE("No camera found");
3182  }
3183  uint32_t value = (uint32_t)val;
3184  dc1394feature_t feature = DC1394_FEATURE_BRIGHTNESS; // = (dc1394feature_t)param;
3185  switch (param) {
3186  case vpFEATURE_BRIGHTNESS:
3187  feature = DC1394_FEATURE_BRIGHTNESS;
3188  break;
3189  case vpFEATURE_EXPOSURE:
3190  feature = DC1394_FEATURE_EXPOSURE;
3191  break;
3192  case vpFEATURE_SHARPNESS:
3193  feature = DC1394_FEATURE_SHARPNESS;
3194  break;
3195  // vpFEATURE_WHITE_BALANCE = DC1394_FEATURE_WHITE_BALANCE,
3196  case vpFEATURE_HUE:
3197  feature = DC1394_FEATURE_HUE;
3198  break;
3199  case vpFEATURE_SATURATION:
3200  feature = DC1394_FEATURE_SATURATION;
3201  break;
3202  case vpFEATURE_GAMMA:
3203  feature = DC1394_FEATURE_GAMMA;
3204  break;
3205  case vpFEATURE_SHUTTER:
3206  feature = DC1394_FEATURE_SHUTTER;
3207  break;
3208  case vpFEATURE_GAIN:
3209  feature = DC1394_FEATURE_GAIN;
3210  break;
3211  case vpFEATURE_IRIS:
3212  feature = DC1394_FEATURE_IRIS;
3213  break;
3214  // vpFEATURE_FOCUS = DC1394_FEATURE_FOCUS,
3215  // vpFEATURE_TEMPERATURE = DC1394_FEATURE_TEMPERATURE,
3216  // vpFEATURE_TRIGGER = DC1394_FEATURE_TRIGGER,
3217  // vpFEATURE_TRIGGER_DELAY = DC1394_FEATURE_TRIGGER_DELAY,
3218  // vpFEATURE_WHITE_SHADING = DC1394_FEATURE_WHITE_SHADING,
3219  // vpFEATURE_FRAME_RATE = DC1394_FEATURE_FRAME_RATE,
3220  // vpFEATURE_ZOOM = DC1394_FEATURE_ZOOM,
3221  // vpFEATURE_PAN = DC1394_FEATURE_PAN,
3222  // vpFEATURE_TILT = DC1394_FEATURE_TILT,
3223  // vpFEATURE_OPTICAL_FILTER = DC1394_FEATURE_OPTICAL_FILTER,
3224  // vpFEATURE_CAPTURE_SIZE = DC1394_FEATURE_CAPTURE_SIZE,
3225  // vpFEATURE_CAPTURE_QUALITY = DC1394_FEATURE_CAPTURE_QUALITY
3226  }
3227 
3228  dc1394error_t err;
3229  dc1394bool_t hasManualMode = DC1394_FALSE;
3230  dc1394feature_modes_t modesAvailable;
3231 
3232  // test wether we can set the shutter value (manual mode available or not)
3233  err = dc1394_feature_get_modes(camera, feature, &modesAvailable);
3234  if (err != DC1394_SUCCESS) {
3235  vpERROR_TRACE("Unable to detect the manual mode information");
3236  close();
3237  throw(
3238  vpFrameGrabberException(vpFrameGrabberException::settingError, "Unable to detect the manual mode information"));
3239  }
3240 
3241  for (unsigned int i = 0; i < modesAvailable.num; i++) {
3242  if (modesAvailable.modes[i] == DC1394_FEATURE_MODE_MANUAL) {
3243  hasManualMode = DC1394_TRUE;
3244  }
3245  }
3246 
3247  if (hasManualMode == DC1394_TRUE) {
3248 
3249  if (!isDataModified[camera_id]) { // to ensure we save the first mode
3250  // even after several set
3251  /* we update the structure */
3252  updateDataCamToStruct();
3253  err = dc1394_feature_get_mode(camera, feature, &(initialShutterMode[camera_id]));
3254  if (err != DC1394_SUCCESS) {
3255  vpERROR_TRACE("Unable to get the initial mode");
3256  close();
3257  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Unable to get the initial mode"));
3258  }
3259  isDataModified[camera_id] = true;
3260  }
3261 
3262  dc1394feature_mode_t manualMode = DC1394_FEATURE_MODE_MANUAL;
3263  err = dc1394_feature_set_mode(camera, feature, manualMode);
3264  if (err != DC1394_SUCCESS) {
3265  vpERROR_TRACE("Unable to set the muanual mode");
3266  close();
3267  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Unable to set the manual mode"));
3268  }
3269  err = dc1394_feature_set_value(camera, feature, value);
3270  if (err != DC1394_SUCCESS) {
3271  vpERROR_TRACE("Unable to set the shutter information");
3272  close();
3273  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "Unable to set the shutter information"));
3274  }
3275  } else {
3276  vpERROR_TRACE("The camera does not have a manual mode.\nCannot change the value");
3277  throw(vpFrameGrabberException(vpFrameGrabberException::settingError, "The camera does not have a manual mode"));
3278  }
3279 }
3287 void vp1394TwoGrabber::getGuid(uint64_t &guid)
3288 {
3289  if (!num_cameras) {
3290  close();
3291  vpERROR_TRACE("No camera found");
3293  }
3294 
3295  guid = camera->guid;
3296 }
3297 
3306 {
3307  if (!num_cameras) {
3308  close();
3309  vpERROR_TRACE("No camera found");
3311  }
3312 
3313  return camera->guid;
3314 }
3315 
3320 inline void vp1394TwoGrabber::updateDataCamToStruct()
3321 {
3322  dataCam[camera_id].brightness = getParameterValue(vpFEATURE_BRIGHTNESS);
3323  dataCam[camera_id].exposure = getParameterValue(vpFEATURE_EXPOSURE);
3324  dataCam[camera_id].sharpness = getParameterValue(vpFEATURE_SHARPNESS);
3325  dataCam[camera_id].hue = getParameterValue(vpFEATURE_HUE);
3326  dataCam[camera_id].saturation = getParameterValue(vpFEATURE_SATURATION);
3327  dataCam[camera_id].gamma = getParameterValue(vpFEATURE_GAMMA);
3328  dataCam[camera_id].shutter = getParameterValue(vpFEATURE_SHUTTER);
3329  dataCam[camera_id].gain = getParameterValue(vpFEATURE_GAIN);
3330  dataCam[camera_id].iris = getParameterValue(vpFEATURE_IRIS);
3331 }
3332 
3337 inline void vp1394TwoGrabber::updateDataStructToCam()
3338 {
3339  setParameterValue(vpFEATURE_BRIGHTNESS, dataCam[camera_id].brightness);
3340  setParameterValue(vpFEATURE_EXPOSURE, dataCam[camera_id].exposure);
3341  setParameterValue(vpFEATURE_SHARPNESS, dataCam[camera_id].sharpness);
3342  setParameterValue(vpFEATURE_HUE, dataCam[camera_id].hue);
3343  setParameterValue(vpFEATURE_SATURATION, dataCam[camera_id].saturation);
3344  setParameterValue(vpFEATURE_GAMMA, dataCam[camera_id].gamma);
3345  setParameterValue(vpFEATURE_SHUTTER, dataCam[camera_id].shutter);
3346  setParameterValue(vpFEATURE_GAIN, dataCam[camera_id].gain);
3347  setParameterValue(vpFEATURE_IRIS, dataCam[camera_id].iris);
3348 }
3349 
3367 {
3368  this->acquire(I);
3369  return *this;
3370 }
3371 
3389 {
3390  this->acquire(I);
3391  return *this;
3392 }
3393 
3394 #elif !defined(VISP_BUILD_SHARED_LIBS)
3395 // Work arround to avoid warning: libvisp_sensor.a(vp1394TwoGrabber.cpp.o) has
3396 // no symbols
3397 void dummy_vp1394TwoGrabber(){};
3398 #endif
void getColorCoding(vp1394TwoColorCodingType &coding)
static const char * strFramerate[DC1394_FRAMERATE_NUM]
VISP_EXPORT int wait(double t0, double t)
Definition: vpTime.cpp:173
uint32_t getColorCodingSupported(vp1394TwoVideoModeType videomode, std::list< vp1394TwoColorCodingType > &codings)
static std::string colorCoding2string(vp1394TwoColorCodingType colorcoding)
static void RGBToGrey(unsigned char *rgb, unsigned char *grey, unsigned int size)
void setAutoGain(bool enable=true)
void setIsoTransmissionSpeed(vp1394TwoIsoSpeedType isospeed)
static std::string framerate2string(vp1394TwoFramerateType fps)
void getAutoGain(unsigned int &minvalue, unsigned int &maxvalue)
unsigned int getNumCameras() const
void resize(unsigned int h, unsigned int w)
resize the image : Image initialization
Definition: vpImage.h:881
#define vpCERROR
Definition: vpDebug.h:365
static void RGBToRGBa(unsigned char *rgb, unsigned char *rgba, unsigned int size)
Type * bitmap
points toward the bitmap
Definition: vpImage.h:143
static void MONO16ToGrey(unsigned char *grey16, unsigned char *grey, unsigned int size)
#define vpERROR_TRACE
Definition: vpDebug.h:393
vp1394TwoGrabber(bool reset=true)
bool isVideoModeFormat7(vp1394TwoVideoModeType videomode)
static const char * strColorCoding[DC1394_COLOR_CODING_NUM]
static void GreyToRGBa(unsigned char *grey, unsigned char *rgba, unsigned int size)
static void YUV422ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int size)
vp1394TwoGrabber & operator>>(vpImage< unsigned char > &I)
unsigned int getParameterValue(vp1394TwoParametersType param)
void acquire(vpImage< unsigned char > &I)
static vp1394TwoColorCodingType string2colorCoding(std::string colorcoding)
Error that can be emited by the vpFrameGrabber class and its derivates.
uint32_t getVideoModeSupported(std::list< vp1394TwoVideoModeType > &videomodes)
static void YUV444ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int size)
bool isFramerateSupported(vp1394TwoVideoModeType videomode, vp1394TwoFramerateType fps)
void setColorCoding(vp1394TwoColorCodingType coding)
void open(vpImage< unsigned char > &I)
unsigned int getRingBufferSize() const
static void YUV422ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
void setRingBufferSize(unsigned int size)
static vp1394TwoVideoModeType string2videoMode(std::string videomode)
void setFormat7ROI(unsigned int left=0, unsigned int top=0, unsigned int width=0, unsigned int height=0)
#define vpTRACE
Definition: vpDebug.h:416
unsigned int height
Number of rows in the image.
void setCamera(uint64_t camera)
static const char * strVideoMode[DC1394_VIDEO_MODE_NUM]
static void MONO16ToRGBa(unsigned char *grey16, unsigned char *rgba, unsigned int size)
void enqueue(dc1394video_frame_t *frame)
static vp1394TwoFramerateType string2framerate(std::string fps)
unsigned int getWidth()
void getFramerate(vp1394TwoFramerateType &fps)
static std::string videoMode2string(vp1394TwoVideoModeType videomode)
bool init
Set to true if the frame grabber has been initialized.
void setParameterValue(vp1394TwoParametersType param, unsigned int val)
static void YUV444ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
unsigned int getHeight() const
Definition: vpImage.h:188
#define vpCTRACE
Definition: vpDebug.h:338
bool isColorCodingSupported(vp1394TwoVideoModeType videomode, vp1394TwoColorCodingType coding)
static void YUV411ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int size)
void setFramerate(vp1394TwoFramerateType fps)
dc1394video_frame_t * dequeue()
void getAutoShutter(unsigned int &minvalue, unsigned int &maxvalue)
void setVideoMode(vp1394TwoVideoModeType videomode)
void setPanControl(unsigned int panControlValue)
uint32_t getFramerateSupported(vp1394TwoVideoModeType videomode, std::list< vp1394TwoFramerateType > &fps)
bool isVideoModeSupported(vp1394TwoVideoModeType videomode)
Class for firewire ieee1394 video devices using libdc1394-2.x api.
static void YUV411ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
unsigned int getWidth() const
Definition: vpImage.h:246
void getVideoMode(vp1394TwoVideoModeType &videomode)
unsigned int width
Number of columns in the image.
unsigned int getHeight()
void setAutoShutter(bool enable=true)