Fawkes API  Fawkes Development Version
bumblebee2.cpp
1 
2 /***************************************************************************
3  * bumblebee2.cpp - Point Grey Bumblebee 2 camera
4  *
5  * Generated: Sat Apr 14 20:51:19 2007 (watching Ghostbusters)
6  * Copyright 2005-2007 Tim Niemueller [www.niemueller.de]
7  *
8  ****************************************************************************/
9 
10 /* This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version. A runtime exception applies to
14  * this software (see LICENSE.GPL_WRE file mentioned below for details).
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU Library General Public License for more details.
20  *
21  * Read the full text in the LICENSE.GPL_WRE file in the doc directory.
22  */
23 
24 #include "bumblebee2.h"
25 
26 #include <core/exception.h>
27 #include <fvcams/cam_exceptions.h>
28 #include <fvutils/system/camargp.h>
29 // include <fvutils/writers/pnm.h>
30 
31 #include <cstring>
32 #include <stdlib.h>
33 #include <string>
34 #include <unistd.h>
35 #ifdef __FreeBSD__
36 # include <sys/endian.h>
37 #elif defined(__MACH__) && defined(__APPLE__)
38 # include <sys/_endian.h>
39 #else
40 # include <endian.h>
41 #endif
42 
43 #include <dc1394/register.h>
44 #include <dc1394/utils.h>
45 #include <utils/math/angle.h>
46 
47 #include <cstdio>
48 
49 using namespace fawkes;
50 
51 namespace firevision {
52 
53 /** @class Bumblebee2Camera <fvcams/bumblebee2.h>
54  * Bumblebee2 camera.
55  * Camera implementation that allows fo access to the PointGrey Research Bumblebee2
56  * camera. It uses libdc1394 to access the camera for fast image transfers (as recommended
57  * by PTGrey) and can be used in conjunction with the TriclopsStereoProcessor in the
58  * stereo utilities library.
59  *
60  * and the Triclops SDK by PTGrey for calculation of the stereo image.
61  * This implementation is based on the Firewire implementation and extends it. The
62  * capture() method implicitly does all the stereo processing needed. This cannot
63  * be turned off. The video modes is appropriately configured for the camera. You can
64  * get access to the left and right images where necessary using the set_image_number()
65  * method and the constants LEFT_ORIGINAL and RIGHT_ORIGINAL. The disparity image buffer
66  * can be retrieved via buffer_disparity().
67  *
68  * Currently only the low resolution version (640x480) of the Bumblebee2 is supported,
69  * an extension for the hires version may follow if we get one of these cameras.
70  *
71  * This class also encapsulates a coordinate system transformation that you can use to
72  * transform the coordinates from the camera system to another right-handed system like
73  * the robot system.
74  *
75  * The camera coordinate system has the X-axis pointing to the right,
76  * Y-axis to the floor and Z-axis forward, if the camera is placed parallel to the ground
77  * and you look in the direction of the camera. The origin of the system is in the right
78  * lens system of the Bumblebee.
79  *
80  * @author Tim Niemueller
81  */
82 
83 /** Original image in RAW16 */
84 const unsigned int Bumblebee2Camera::ORIGINAL = 0;
85 
86 /** Deinterlaced image */
87 const unsigned int Bumblebee2Camera::DEINTERLACED = 1;
88 
89 /** From bayer tile decoded RGB image */
90 const unsigned int Bumblebee2Camera::RGB_IMAGE = 2;
91 
92 /// PGR specific registers
93 /** PTGrey proprietary register: Bayer tile mapping information */
94 #define PGR_BAYER_TILE_MAPPING_REGISTER (0x1040)
95 
96 #define PGR_SENSOR_BOARD_INFO_REGISTER (0x1f28)
97 
98 /** PTGrey proprietary: config data length */
99 #define PGR_REG_CONFIG_LENGTH (0x1FFC)
100 
101 /** PTGrey proprietary register: config register */
102 #define PGR_REG_CONFIG_DATA (0x2000)
103 
104 /** PTGrey proprietary register: unit directory offset */
105 #define PGR_REG_UNIT_DIRECTORY_OFFSET (0x0424)
106 
107 /** PTGrey proprietary register: image data format */
108 #define PGR_REG_IMAGE_DATA_FORMAT (0x1048)
109 /** PTGrey image data format: PGR-specific (little endian) mode */
110 #define PTG_Y16_Data_Format_PGR_specific (0xFFFFFFFE)
111 
112 /** PTGrey proprietary register: serial number */
113 #define PGR_REG_SERIAL_NUMBER (0x1F20)
114 
115 /** PTGrey image data format: PGR-specific (little endian) mode */
116 /** Constructor.
117  * Initialize and take parameters from camera argument parser. The following
118  * arguments are supported:
119  * - nbufs=NBUFS, number of DMA buffers, integer, 0 < n <= 32
120  * - width=WIDTH, width in pixels of Format7 ROI
121  * - height=HEIGHT, height in pixels of Format7 ROI
122  * - startx=STARTX, X start of Format7 ROI
123  * - starty=STARTY, Y start of Format7 ROI
124  * @param cap camera argument parser
125  */
126 Bumblebee2Camera::Bumblebee2Camera(const CameraArgumentParser *cap)
127 : FirewireCamera(DC1394_FRAMERATE_30,
128  DC1394_VIDEO_MODE_FORMAT7_3,
129  DC1394_ISO_SPEED_400,
130  /* num buffers */ 8)
131 {
132  // Defaults
133 
134  _supports_color = true;
135  _auto_acquire_sensor_info = false;
136 
137  _model = strdup(cap->cam_id().c_str());
138  // num_buffers set in constructor call
139  _format7_coding = DC1394_COLOR_CODING_RAW16;
140  _format7_width = 640;
141  _format7_height = 480;
143 
144  if (cap->has("nbufs")) {
145  _num_buffers = atoi(cap->get("nbufs").c_str());
146  }
147  if (cap->has("width")) {
148  _format7_width = atoi(cap->get("width").c_str());
149  }
150  if (cap->has("height")) {
151  _format7_height = atoi(cap->get("height").c_str());
152  }
153  if (cap->has("startx")) {
154  _format7_startx = atoi(cap->get("startx").c_str());
155  }
156  if (cap->has("starty")) {
157  _format7_starty = atoi(cap->get("starty").c_str());
158  }
159  if (cap->has("focus")) {
160  parse_set_focus(cap->get("focus").c_str());
161  }
162  if (cap->has("white_balance")) {
163  parse_set_white_balance(cap->get("white_balance").c_str());
164  }
165  if (cap->has("shutter")) {
166  parse_set_shutter(cap->get("shutter").c_str());
167  }
168 
169  buffer_deinterlaced_ = NULL;
170  buffer_rgb_ = NULL;
171 }
172 
173 /** Constructor.
174  * Initialize and use largest possible video mode suitable for stereo
175  * processing.
176  */
178 : FirewireCamera(DC1394_FRAMERATE_30,
179  DC1394_VIDEO_MODE_FORMAT7_3,
180  DC1394_ISO_SPEED_400,
181  /* num buffers */ 8)
182 {
183  _auto_acquire_sensor_info = true;
184 
185  _model = strdup("Bumblebee2");
186  // num_buffers set in constructor call
187  _format7_coding = DC1394_COLOR_CODING_RAW16;
188  _format7_width = 640;
189  _format7_height = 480;
191 }
192 
193 /** Destructor. */
195 {
196  if (buffer_deinterlaced_ != NULL)
197  free(buffer_deinterlaced_);
198  if (buffer_rgb_ != NULL)
199  free(buffer_rgb_);
200 }
201 
202 /** Get BB2 serial no.
203  * @return BB2 serial number.
204  */
205 uint32_t
207 {
208  if (!_opened)
209  throw Exception("Camera not opened");
210 
211  uint32_t value = 0;
212  dc1394error_t err = dc1394_get_control_register(_camera, PGR_REG_SERIAL_NUMBER, &value);
213  if (err != DC1394_SUCCESS) {
214  throw Exception(
215  "Bumblebee2::serial_no: dc1394_get_control_register(PGR_REG_SERIAL_NUMBER) failed\n");
216  }
217  return value;
218 }
219 
220 /** Verify GUID validity.
221  * Compares the given GUID with the GUID of the camera. The GUID may be of two
222  * forms. If the first four bytes are all 0xFF then it is assumed that the
223  * GUID was created from the BB2-specific serial number. For example if a
224  * rectification LUT was generated with the context file only but without
225  * access to the real camera. Otherwise the GUID is matched against the
226  * Firewire GUID.
227  * @param ver_guid GUID to verify
228  * @return true if the given GUID matches the current camera, false otherwise
229  */
230 bool
231 Bumblebee2Camera::verify_guid(uint64_t ver_guid) const
232 {
233  if (!_opened)
234  throw Exception("Camera not opened");
235 
236  uint64_t tguid = ver_guid;
237  tguid >>= 32;
238  tguid &= 0xFFFFFFFF;
239  if (tguid == 0xFFFFFFFF) {
240  // serial number!
241  ver_guid &= 0xFFFFFFFF;
242  return (serial_no() == ver_guid);
243  } else {
244  return (guid() == ver_guid);
245  }
246 }
247 
248 void
249 Bumblebee2Camera::get_sensor_info()
250 {
251  uint32_t value;
252  dc1394error_t err;
253 
254  // This register is an advanced PGR register called SENSOR_BOARD_INFO
255  err = dc1394_get_control_register(_camera, PGR_SENSOR_BOARD_INFO_REGISTER, &value);
256  if (err != DC1394_SUCCESS) {
257  throw Exception("Failed to read sensor borad info register");
258  }
259 
260  unsigned char ucSensorInfo = 0xf & value;
261 
262  switch (ucSensorInfo) {
263  default:
264  // unknown sensor!
265  throw Exception("Illegal sensor board info detected!");
266  case 0xA: // color 640x480
267  _supports_color = true;
268  _format7_height = 480;
269  _format7_width = 640;
270  break;
271  case 0xB: // mono 640x480
272  _supports_color = false;
273  _format7_height = 480;
274  _format7_width = 640;
275  break;
276  case 0xC: // color 1024x768
277  _supports_color = true;
278  _format7_height = 768;
279  _format7_width = 1024;
280  break;
281  case 0xD: // mono 1024x768
282  _supports_color = false;
283  _format7_height = 768;
284  _format7_width = 1024;
285  break;
286  case 0xE: // color 1280x960
287  _supports_color = true;
288  _format7_height = 960;
289  _format7_width = 1280;
290  break;
291  case 0xF: // mono 1280x960
292  _supports_color = false;
293  _format7_height = 960;
294  _format7_width = 1280;
295  break;
296  }
297 }
298 
299 void
301 {
303 
304  printf("Serial: %u\n", serial_no());
305 #if (defined(__WORDSIZE) && __WORDSIZE == 64) || (defined(LONG_BIT) && LONG_BIT == 64)
306  printf("GUID: 0x%016lx\n", (long unsigned int)guid());
307 #else
308  printf("GUID: 0x%016llx\n", guid());
309 #endif
310 }
311 
312 void
314 {
315  _dc1394 = dc1394_new();
316  dc1394camera_list_t *list;
317 
318  if (dc1394_camera_enumerate(_dc1394, &list) != DC1394_SUCCESS) {
319  throw Exception("Could not enumerate cameras");
320  }
321 
322  if (list->num > 0) {
323  _camera = NULL;
324  for (unsigned int i = 0; i < list->num; ++i) {
325  dc1394camera_t *tmpcam = dc1394_camera_new(_dc1394, list->ids[i].guid);
326  if (strncmp("Bumblebee2", tmpcam->model, strlen("Bumblebee2")) == 0) {
327  // found desired camera
328  _camera = tmpcam;
329  break;
330  } else {
331  dc1394_camera_free(tmpcam);
332  }
333  }
334  if (_camera == NULL) {
335  throw Exception("Could not find camera with model %s", _model);
336  }
337  } else {
338  throw Exception("No cameras connected");
339  }
340 
341  _device_opened = true;
342 }
343 
344 void
346 {
347  if (_auto_acquire_sensor_info) {
348  open_device();
349  get_sensor_info();
350  }
352 
353  if (!_opened) {
354  throw Exception("Bumblebee2Camera::open: FirewireCamera::open dit not suceed");
355  }
356 
357  size_t buffer_size = (size_t)pixel_width() * (size_t)pixel_height() * 2;
358  buffer_deinterlaced_ = (unsigned char *)malloc(buffer_size);
359  buffer_rgb_ = malloc_buffer(RGB, pixel_width(), pixel_height() * 2);
360  buffer_ = NULL;
361 
362 #if BYTE_ORDER_ == LITTLE_ENDIAN_
363  dc1394error_t err;
364  typedef union {
365  uint32_t value;
366  struct
367  {
368  uint32_t presence : 1;
369  uint32_t reserved1 : 21;
370  uint32_t mirror : 1;
371  uint32_t bayer_mono : 1;
372  uint32_t reserved2 : 7;
373  uint32_t data_format : 1;
374  } idf;
375  } idf_u;
376  idf_u value;
377  err = dc1394_get_control_register(_camera, PGR_REG_IMAGE_DATA_FORMAT, &(value.value));
378  if (err != DC1394_SUCCESS) {
379  throw Exception("Bumblebee2::open: dc1394_get_control_register(PGR_REG_DATA_FORMAT) failed\n");
380  }
381  value.value &= PTG_Y16_Data_Format_PGR_specific;
382  value.idf.data_format = 0;
383  err = dc1394_set_control_register(_camera, PGR_REG_IMAGE_DATA_FORMAT, value.value);
384  if (err != DC1394_SUCCESS) {
385  throw Exception("Bumblebee2::open: Setting PGR-specific mode on little-endian system failed\n");
386  }
387 #endif
388 
389  get_bayer_tile();
390 }
391 
392 void
394 {
395  if (_opened) {
397  if (buffer_deinterlaced_ != NULL) {
398  free(buffer_deinterlaced_);
399  buffer_deinterlaced_ = NULL;
400  }
401  if (buffer_rgb_ != NULL) {
402  free(buffer_rgb_);
403  buffer_rgb_ = NULL;
404  }
405  }
406 }
407 
408 void
410 {
411  try {
413  } catch (CaptureException &e) {
414  e.append("Bumblebee2Camera::capture: failed to retrieve image");
415  if (ORIGINAL == image_num_)
416  buffer_ = NULL;
417  throw;
418  }
419  if (ORIGINAL == image_num_) {
420  buffer_ = _frame->image;
421  }
422 }
423 
424 unsigned char *
426 {
427  return buffer_;
428 }
429 
430 void
431 Bumblebee2Camera::set_image_number(unsigned int image_num)
432 {
433  image_num_ = image_num;
434  switch (image_num) {
435  case DEINTERLACED: buffer_ = buffer_deinterlaced_; break;
436  case RGB_IMAGE: buffer_ = buffer_rgb_; break;
437  default: buffer_ = NULL; break;
438  }
439 }
440 
441 /** Check if connected camera is a Bumblebee2.
442  * @return true, if the connected camera is a Bumblebee2, false otherwise
443  */
444 bool
446 {
447  if (!_opened)
448  throw CameraNotOpenedException();
449 
450  return (strncmp(_camera->model, "Bumblebee2", strlen("Bumblebee2")) == 0);
451 }
452 
453 /** De-interlace the 16 bit data into 2 bayer tile pattern images. */
454 void
456 {
457  dc1394_deinterlace_stereo(_frame->image, buffer_deinterlaced_, pixel_width(), 2 * pixel_height());
458 }
459 
460 /** Extract RGB color image from the bayer tile image.
461  * This will transform the bayer tile image to an RGB image using the
462  * nearest neighbour method.
463  * Note: this will alias colors on the top and bottom rows
464  */
465 void
467 {
468  dc1394_bayer_decoding_8bit(buffer_deinterlaced_,
469  buffer_rgb_,
470  pixel_width(),
471  2 * pixel_height(),
472  bayer_pattern_,
473  DC1394_BAYER_METHOD_NEAREST);
474 }
475 
476 /** De-interlace the 16 bit data into 2 bayer tile pattern images.
477  * Can be used for offline de-interlacing.
478  * @param raw16 In-buffer RAW16-encoded
479  * @param deinterlaced upon return contains the deinterlaced image
480  * @param width width of image in pixels
481  * @param height height of image in pixels
482  */
483 void
485  unsigned char *deinterlaced,
486  unsigned int width,
487  unsigned int height)
488 {
489  dc1394_deinterlace_stereo(raw16, deinterlaced, width, 2 * height);
490 }
491 
492 /** Extract RGB color image from the bayer tile image.
493  * This will transform the bayer tile image to an RGB image using the
494  * nearest neighbour method.
495  * Note: this will alias colors on the top and bottom rows
496  * @param deinterlaced in-buffer with deinterlaced image
497  * @param rgb upon return contains RGB image
498  * @param width width of image in pixels
499  * @param height height of image in pixels
500  * @param bayer_pattern bayer pattern, one of
501  * - 0x59595959 (YYYY, no pattern)
502  * - 0x52474742 (RGGB)
503  * - 0x47524247 (GRBG)
504  * - 0x42474752 (BGGR)
505  * This depends on the used camera.
506  */
507 void
508 Bumblebee2Camera::decode_bayer(unsigned char * deinterlaced,
509  unsigned char * rgb,
510  unsigned int width,
511  unsigned int height,
512  bayer_pattern_t bayer_pattern)
513 {
514  dc1394color_filter_t dc_bayer_pattern;
515 
516  switch (bayer_pattern) {
517  default:
518  case BAYER_PATTERN_YYYY: dc_bayer_pattern = (dc1394color_filter_t)0; break;
519  case BAYER_PATTERN_RGGB: dc_bayer_pattern = DC1394_COLOR_FILTER_RGGB; break;
520  case BAYER_PATTERN_GBRG: dc_bayer_pattern = DC1394_COLOR_FILTER_GBRG; break;
521  case BAYER_PATTERN_GRBG: dc_bayer_pattern = DC1394_COLOR_FILTER_GRBG; break;
522  case BAYER_PATTERN_BGGR: dc_bayer_pattern = DC1394_COLOR_FILTER_BGGR; break;
523  }
524 
525  dc1394_bayer_decoding_8bit(
526  deinterlaced, rgb, width, 2 * height, dc_bayer_pattern, DC1394_BAYER_METHOD_NEAREST);
527 }
528 
529 /** Retrieve bayer tile.
530  * This is an internal method that access a special PTGrey register in the camera to
531  * determine the bayer tile mode.
532  */
533 void
534 Bumblebee2Camera::get_bayer_tile()
535 {
536  uint32_t value;
537  if (dc1394_get_control_register(_camera, PGR_BAYER_TILE_MAPPING_REGISTER, &value)
538  != DC1394_SUCCESS) {
539  throw Exception("Could not query bayer tile register");
540  }
541 
542  // Magic numbers are specific to PTGrey cameras
543  switch (value) {
544  default:
545  case 0x59595959: // YYYY
546  // no bayer
547  bayer_pattern_ = (dc1394color_filter_t)0;
548  break;
549  case 0x52474742: // RGGB
550  bayer_pattern_ = DC1394_COLOR_FILTER_RGGB;
551  break;
552  case 0x47425247: // GBRG
553  bayer_pattern_ = DC1394_COLOR_FILTER_GBRG;
554  break;
555  case 0x47524247: // GRBG
556  bayer_pattern_ = DC1394_COLOR_FILTER_GRBG;
557  break;
558  case 0x42474752: // BGGR
559  bayer_pattern_ = DC1394_COLOR_FILTER_BGGR;
560  break;
561  }
562 }
563 
564 /** Retrieve config from camera.
565  * This method retrieves the config from the camera and writes it to a file such that
566  * the Triclops SDK can use it for context initialization.
567  * @param filename filename to write the config to
568  * @exception Exception thrown if there is an error when trying to retrieve the config
569  * or writing it to a file.
570  */
571 void
573 {
574  dc1394error_t err;
575  uint32_t value;
576 
577  err = dc1394_get_control_register(_camera, PGR_REG_CONFIG_LENGTH, &value);
578  if (err != DC1394_SUCCESS) {
579  throw Exception("dc1394_get_control_register(PGR_REG_CONFIG_LENGTH) failed\n");
580  }
581 
582  // the length of the config file
583  unsigned long file_size_bytes = value;
584  if (file_size_bytes == 0) {
585  throw Exception("File size == 0!\n");
586  }
587 
588  FILE *file = fopen(filename, "w");
589  if (!file) {
590  throw Exception("Can't open temporary file\n");
591  }
592 
593  // Read the config file, and save it to the output file,
594  // while fixing endianness.
595  for (unsigned long offset = 0; offset < file_size_bytes; offset += 4) {
596  err = dc1394_get_control_register(_camera, PGR_REG_CONFIG_DATA + offset, &value);
597 
598  if (err != DC1394_SUCCESS) {
599  Exception e("Failed to get control register");
600  e.append("Can't get control register 0x%x\n", (int)(PGR_REG_CONFIG_DATA + offset));
601  fclose(file);
602  throw e;
603  }
604 
605  for (int i = 24; i >= 0; i -= 8) {
606  fputc(((value >> i) & 0xFF), file);
607  }
608  }
609  fclose(file);
610 }
611 
612 } // end namespace firevision
virtual ~Bumblebee2Camera()
Destructor.
Definition: bumblebee2.cpp:194
bool _opened
true if camera has been opened, false otherwise
Definition: firewire.h:127
virtual void open()
Open the camera.
Definition: bumblebee2.cpp:345
int _format7_width
Format7 width.
Definition: firewire.h:164
virtual unsigned int pixel_width()
Width of image in pixels.
Definition: firewire.cpp:408
virtual void parse_set_focus(const char *focus)
Parse focus and set value.
Definition: firewire.cpp:713
virtual void set_image_number(unsigned int image_num)
Set image number to retrieve.
Definition: bumblebee2.cpp:431
static const unsigned int RGB_IMAGE
From bayer tile decoded RGB image.
Definition: bumblebee2.h:39
virtual void print_info()
Print out camera information.
Definition: firewire.cpp:279
virtual unsigned int pixel_height()
Height of image in pixels.
Definition: firewire.cpp:430
static const unsigned int DEINTERLACED
Deinterlaced image.
Definition: bumblebee2.h:38
void write_triclops_config_from_camera_to_file(const char *filename)
Retrieve config from camera.
Definition: bumblebee2.cpp:572
Fawkes library namespace.
Capturing a frame failed.
void decode_bayer()
Extract RGB color image from the bayer tile image.
Definition: bumblebee2.cpp:466
virtual void close()
Close camera.
Definition: firewire.cpp:384
virtual uint32_t serial_no() const
Get BB2 serial no.
Definition: bumblebee2.cpp:206
virtual unsigned int buffer_size()
Size of buffer.
Definition: firewire.cpp:374
Camera argument parser.
Definition: camargp.h:35
std::string cam_id() const
Get camera ID.
Definition: camargp.cpp:133
dc1394video_frame_t * _frame
Last captured DC1394 video frame.
Definition: firewire.h:158
Camera not opened exception.
static const unsigned int ORIGINAL
Original image in RAW16.
Definition: bumblebee2.h:37
virtual uint64_t guid() const
Get Firewire GUID of camera.
Definition: firewire.cpp:306
virtual void parse_set_white_balance(const char *white_balance)
Parse white balance and set value.
Definition: firewire.cpp:739
bool _device_opened
true if device has been opened, false otherwise
Definition: firewire.h:125
bool is_bumblebee2()
Check if connected camera is a Bumblebee2.
Definition: bumblebee2.cpp:445
virtual void capture()
Capture an image.
Definition: bumblebee2.cpp:409
bool has(std::string s) const
Check if an parameter was given.
Definition: camargp.cpp:145
virtual void parse_set_shutter(const char *shutter)
Parse shutter and set value.
Definition: firewire.cpp:780
Base class for exceptions in Fawkes.
Definition: exception.h:35
virtual void print_info()
Print out camera information.
Definition: bumblebee2.cpp:300
virtual void close()
Close camera.
Definition: bumblebee2.cpp:393
char * _model
Camera model, used in open to identify the camera, if empty first found camera is used.
Definition: firewire.h:189
int _format7_height
Format7 height.
Definition: firewire.h:166
void deinterlace_stereo()
De-interlace the 16 bit data into 2 bayer tile pattern images.
Definition: bumblebee2.cpp:455
dc1394color_coding_t _format7_coding
Format7 color coding.
Definition: firewire.h:160
virtual void open()
Open the camera.
Definition: firewire.cpp:147
dc1394camera_t * _camera
DC1394 camera handle.
Definition: firewire.h:156
virtual void capture()
Capture an image.
Definition: firewire.cpp:329
int _format7_startx
Format7 ROI Start X coordinate.
Definition: firewire.h:168
int _num_buffers
Number of DMA buffers.
Definition: firewire.h:123
std::string get(std::string s) const
Get the value of the given parameter.
Definition: camargp.cpp:156
virtual bool verify_guid(uint64_t ver_guid) const
Verify GUID validity.
Definition: bumblebee2.cpp:231
Firewire camera.
Definition: firewire.h:40
dc1394_t * _dc1394
DC1394 main context.
Definition: firewire.h:146
void append(const char *format,...)
Append messages to the message list.
Definition: exception.cpp:333
virtual void open_device()
Open the desired device.
Definition: bumblebee2.cpp:313
virtual unsigned char * buffer()
Get access to current image buffer.
Definition: bumblebee2.cpp:425
int _format7_starty
Format7 ROI Start Y coordinate.
Definition: firewire.h:170