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
49using namespace fawkes;
50
51namespace 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 */
84const unsigned int Bumblebee2Camera::ORIGINAL = 0;
85
86/** Deinterlaced image */
87const unsigned int Bumblebee2Camera::DEINTERLACED = 1;
88
89/** From bayer tile decoded RGB image */
90const 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 */
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 */
205uint32_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 */
230bool
231Bumblebee2Camera::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
248void
249Bumblebee2Camera::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
299void
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
312void
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
344void
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
392void
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
408void
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
424unsigned char *
426{
427 return buffer_;
428}
429
430void
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 */
444bool
446{
447 if (!_opened)
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. */
454void
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 */
465void
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 */
483void
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 */
507void
508Bumblebee2Camera::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 */
533void
534Bumblebee2Camera::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 */
571void
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
Base class for exceptions in Fawkes.
Definition: exception.h:36
void append(const char *format,...) noexcept
Append messages to the message list.
Definition: exception.cpp:333
virtual void capture()
Capture an image.
Definition: bumblebee2.cpp:409
void deinterlace_stereo()
De-interlace the 16 bit data into 2 bayer tile pattern images.
Definition: bumblebee2.cpp:455
void decode_bayer()
Extract RGB color image from the bayer tile image.
Definition: bumblebee2.cpp:466
bool is_bumblebee2()
Check if connected camera is a Bumblebee2.
Definition: bumblebee2.cpp:445
virtual void open_device()
Open the desired device.
Definition: bumblebee2.cpp:313
virtual void close()
Close camera.
Definition: bumblebee2.cpp:393
virtual void open()
Open the camera.
Definition: bumblebee2.cpp:345
virtual uint32_t serial_no() const
Get BB2 serial no.
Definition: bumblebee2.cpp:206
static const unsigned int RGB_IMAGE
From bayer tile decoded RGB image.
Definition: bumblebee2.h:39
virtual bool verify_guid(uint64_t ver_guid) const
Verify GUID validity.
Definition: bumblebee2.cpp:231
static const unsigned int DEINTERLACED
Deinterlaced image.
Definition: bumblebee2.h:38
virtual void set_image_number(unsigned int image_num)
Set image number to retrieve.
Definition: bumblebee2.cpp:431
virtual void print_info()
Print out camera information.
Definition: bumblebee2.cpp:300
virtual ~Bumblebee2Camera()
Destructor.
Definition: bumblebee2.cpp:194
virtual unsigned char * buffer()
Get access to current image buffer.
Definition: bumblebee2.cpp:425
static const unsigned int ORIGINAL
Original image in RAW16.
Definition: bumblebee2.h:37
void write_triclops_config_from_camera_to_file(const char *filename)
Retrieve config from camera.
Definition: bumblebee2.cpp:572
Camera argument parser.
Definition: camargp.h:36
std::string cam_id() const
Get camera ID.
Definition: camargp.cpp:133
bool has(std::string s) const
Check if an parameter was given.
Definition: camargp.cpp:145
std::string get(std::string s) const
Get the value of the given parameter.
Definition: camargp.cpp:156
Camera not opened exception.
Capturing a frame failed.
Firewire camera.
Definition: firewire.h:41
int _format7_starty
Format7 ROI Start Y coordinate.
Definition: firewire.h:170
bool _device_opened
true if device has been opened, false otherwise
Definition: firewire.h:125
virtual void print_info()
Print out camera information.
Definition: firewire.cpp:279
virtual void close()
Close camera.
Definition: firewire.cpp:384
virtual void parse_set_white_balance(const char *white_balance)
Parse white balance and set value.
Definition: firewire.cpp:739
virtual unsigned int pixel_width()
Width of image in pixels.
Definition: firewire.cpp:408
int _format7_width
Format7 width.
Definition: firewire.h:164
int _format7_startx
Format7 ROI Start X coordinate.
Definition: firewire.h:168
virtual void capture()
Capture an image.
Definition: firewire.cpp:329
dc1394camera_t * _camera
DC1394 camera handle.
Definition: firewire.h:156
virtual void parse_set_shutter(const char *shutter)
Parse shutter and set value.
Definition: firewire.cpp:780
virtual unsigned int pixel_height()
Height of image in pixels.
Definition: firewire.cpp:430
virtual void open()
Open the camera.
Definition: firewire.cpp:147
virtual unsigned int buffer_size()
Size of buffer.
Definition: firewire.cpp:374
char * _model
Camera model, used in open to identify the camera, if empty first found camera is used.
Definition: firewire.h:189
dc1394_t * _dc1394
DC1394 main context.
Definition: firewire.h:146
bool _opened
true if camera has been opened, false otherwise
Definition: firewire.h:127
dc1394color_coding_t _format7_coding
Format7 color coding.
Definition: firewire.h:160
virtual uint64_t guid() const
Get Firewire GUID of camera.
Definition: firewire.cpp:306
int _format7_height
Format7 height.
Definition: firewire.h:166
int _num_buffers
Number of DMA buffers.
Definition: firewire.h:123
virtual void parse_set_focus(const char *focus)
Parse focus and set value.
Definition: firewire.cpp:713
dc1394video_frame_t * _frame
Last captured DC1394 video frame.
Definition: firewire.h:158
Fawkes library namespace.