Visual Servoing Platform version 3.5.0
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
59const 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
69const 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
73const 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
281void 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
329void 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
372void 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();
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();
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
528uint32_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) {
644 return false;
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();
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
776uint32_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
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
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
1189void 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}
1290void 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
1573unsigned 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}
1679void vp1394TwoGrabber::setAutoShutter(unsigned int minvalue, unsigned int maxvalue)
1680{
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
1703void 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}
1823void 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
1847void 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
1880void 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
1923void 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
2125dc1394video_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
2242dc1394video_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
2397dc1394video_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
2465void 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
2520void 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
2571void 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
2637void 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
2693void 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("Resetting 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
3057void 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) {
3104 feature = DC1394_FEATURE_BRIGHTNESS;
3105 break;
3106 case vpFEATURE_EXPOSURE:
3107 feature = DC1394_FEATURE_EXPOSURE;
3108 break;
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;
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) {
3187 feature = DC1394_FEATURE_BRIGHTNESS;
3188 break;
3189 case vpFEATURE_EXPOSURE:
3190 feature = DC1394_FEATURE_EXPOSURE;
3191 break;
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;
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}
3287void 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
3320inline 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
3337inline 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
3397void dummy_vp1394TwoGrabber(){};
3398#endif
Class for firewire ieee1394 video devices using libdc1394-2.x api.
void setAutoShutter(bool enable=true)
static const char * strColorCoding[DC1394_COLOR_CODING_NUM]
void getVideoMode(vp1394TwoVideoModeType &videomode)
void setAutoGain(bool enable=true)
void setParameterValue(vp1394TwoParametersType param, unsigned int val)
static std::string colorCoding2string(vp1394TwoColorCodingType colorcoding)
void setRingBufferSize(unsigned int size)
void getFramerate(vp1394TwoFramerateType &fps)
uint32_t getFramerateSupported(vp1394TwoVideoModeType videomode, std::list< vp1394TwoFramerateType > &fps)
void acquire(vpImage< unsigned char > &I)
void setPanControl(unsigned int panControlValue)
static vp1394TwoColorCodingType string2colorCoding(std::string colorcoding)
static vp1394TwoVideoModeType string2videoMode(std::string videomode)
void setColorCoding(vp1394TwoColorCodingType coding)
bool isVideoModeFormat7(vp1394TwoVideoModeType videomode)
void setVideoMode(vp1394TwoVideoModeType videomode)
unsigned int getRingBufferSize() const
void setFormat7ROI(unsigned int left=0, unsigned int top=0, unsigned int width=0, unsigned int height=0)
void getAutoShutter(unsigned int &minvalue, unsigned int &maxvalue)
unsigned int getNumCameras() const
void setCamera(uint64_t camera)
unsigned int getWidth()
static vp1394TwoFramerateType string2framerate(std::string fps)
void enqueue(dc1394video_frame_t *frame)
vp1394TwoGrabber & operator>>(vpImage< unsigned char > &I)
unsigned int getParameterValue(vp1394TwoParametersType param)
void getAutoGain(unsigned int &minvalue, unsigned int &maxvalue)
void getColorCoding(vp1394TwoColorCodingType &coding)
void setIsoTransmissionSpeed(vp1394TwoIsoSpeedType isospeed)
uint32_t getColorCodingSupported(vp1394TwoVideoModeType videomode, std::list< vp1394TwoColorCodingType > &codings)
void setFramerate(vp1394TwoFramerateType fps)
static std::string framerate2string(vp1394TwoFramerateType fps)
unsigned int getHeight()
bool isColorCodingSupported(vp1394TwoVideoModeType videomode, vp1394TwoColorCodingType coding)
bool isFramerateSupported(vp1394TwoVideoModeType videomode, vp1394TwoFramerateType fps)
dc1394video_frame_t * dequeue()
static std::string videoMode2string(vp1394TwoVideoModeType videomode)
static const char * strVideoMode[DC1394_VIDEO_MODE_NUM]
vp1394TwoGrabber(bool reset=true)
bool isVideoModeSupported(vp1394TwoVideoModeType videomode)
uint32_t getVideoModeSupported(std::list< vp1394TwoVideoModeType > &videomodes)
void open(vpImage< unsigned char > &I)
static const char * strFramerate[DC1394_FRAMERATE_NUM]
Error that can be emited by the vpFrameGrabber class and its derivates.
unsigned int height
Number of rows in the image.
bool init
Set to true if the frame grabber has been initialized.
unsigned int width
Number of columns in the image.
static void YUV411ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
static void MONO16ToGrey(unsigned char *grey16, unsigned char *grey, unsigned int size)
static void YUV422ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
static void YUV411ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int size)
static void GreyToRGBa(unsigned char *grey, unsigned char *rgba, unsigned int width, unsigned int height)
static void MONO16ToRGBa(unsigned char *grey16, unsigned char *rgba, unsigned int size)
static void RGBToGrey(unsigned char *rgb, unsigned char *grey, unsigned int width, unsigned int height, bool flip=false)
static void RGBToRGBa(unsigned char *rgb, unsigned char *rgba, unsigned int size)
static void YUV422ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int size)
static void YUV444ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int size)
static void YUV444ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
unsigned int getWidth() const
Definition: vpImage.h:246
void resize(unsigned int h, unsigned int w)
resize the image : Image initialization
Definition: vpImage.h:800
Type * bitmap
points toward the bitmap
Definition: vpImage.h:143
unsigned int getHeight() const
Definition: vpImage.h:188
#define vpCTRACE
Definition: vpDebug.h:338
#define vpCERROR
Definition: vpDebug.h:365
#define vpTRACE
Definition: vpDebug.h:416
#define vpERROR_TRACE
Definition: vpDebug.h:393
VISP_EXPORT int wait(double t0, double t)