Camera.cpp

Go to the documentation of this file.

/*
 * Camera.cpp
 *
 *  Created on: Jul 9, 2010
 *      Author: petrito1@cmp.felk.cvut.cz
 */

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

#include "Camera.h"
#include "CameraException.h"

namespace nifti {
namespace dc1394 {

Camera::Camera() :
  camera(NULL), bayerMethod(DC1394_BAYER_METHOD_HQLINEAR) {
  pthread_mutex_init(&captureMutex, NULL);
}

Camera::Camera(dc1394camera_t* camera) :
  camera(camera), bayerMethod(DC1394_BAYER_METHOD_HQLINEAR) {
  pthread_mutex_init(&captureMutex, NULL);
}

Camera::~Camera() {
  // Camera is freed by its associated context.
  unlockCapture();
}

void Camera::setup() {
  printf("Camera::setup()\n");

  setOperationMode(DC1394_OPERATION_MODE_1394B);
  setIsoSpeed(DC1394_ISO_SPEED_800);
  setVideoMode(DC1394_VIDEO_MODE_FORMAT7_0);
  setFormat7Roi(DC1394_VIDEO_MODE_FORMAT7_0, DC1394_COLOR_CODING_RAW8, 9792, 0, 0, 1616, 7392);
}

dc1394color_coding_t Camera::getFormat7ColorCoding() {
  dc1394color_coding_t colorCoding;
  dc1394error_t error;
  error = dc1394_format7_get_color_coding(camera, DC1394_VIDEO_MODE_FORMAT7_0, &colorCoding);
  CAMERA_EXCEPTION(error, "Could not get Format 7 color coding.");
  return colorCoding;
}

dc1394color_filter_t Camera::getFormat7ColorFilter() {
  dc1394color_filter_t colorFilter;
  dc1394error_t error;
  error = dc1394_format7_get_color_filter(camera, DC1394_VIDEO_MODE_FORMAT7_0, &colorFilter);
  CAMERA_EXCEPTION(error, "Could not get Format 7 color filter.");
  return colorFilter;
}

float Camera::getFormat7FrameInterval() {
  float frameInterval;
  dc1394error_t error;
  error = dc1394_format7_get_frame_interval(camera, DC1394_VIDEO_MODE_FORMAT7_0, &frameInterval);
  CAMERA_EXCEPTION(error, "Could not get Format 7 frame interval.");
  return frameInterval;
}

uint32_t Camera::getFormat7PacketsPerFrame() {
  uint32_t packetsPerFrame;
  dc1394error_t error;
  error = dc1394_format7_get_packets_per_frame(camera, DC1394_VIDEO_MODE_FORMAT7_0, &packetsPerFrame);
  CAMERA_EXCEPTION(error, "Could not get Format 7 packets per frame.");
  return packetsPerFrame;
}

uint32_t Camera::getFormat7PacketSize() {
  uint32_t packetSize;
  dc1394error_t error;
  error = dc1394_format7_get_packet_size(camera, DC1394_VIDEO_MODE_FORMAT7_0, &packetSize);
  CAMERA_EXCEPTION(error, "Could not get Format 7 packet size.");
  return packetSize;
}

uint32_t Camera::getFormat7RecommendedPacketSize() {
  uint32_t packetSize;
  dc1394error_t error;
  error = dc1394_format7_get_recommended_packet_size(camera, DC1394_VIDEO_MODE_FORMAT7_0, &packetSize);
  CAMERA_EXCEPTION(error, "Could not get Format 7 recommended packet size.");
  return packetSize;
}

dc1394operation_mode_t Camera::getOperationMode() {
  printf("Camera::getOperationMode()\n");
  dc1394operation_mode_t operationMode;
  dc1394error_t error;
  error = dc1394_video_get_operation_mode(camera, &operationMode);
  CAMERA_EXCEPTION(error, "Could not get operation mode.");
  printf("Camera::getOperationMode(): %i\n", operationMode);
  return operationMode;
}

void Camera::setOperationMode(dc1394operation_mode_t operationMode) {
  printf("Camera::setOperationMode(): %i\n", operationMode);
  dc1394error_t error;
  error = dc1394_video_set_operation_mode(camera, operationMode);
  CAMERA_EXCEPTION(error, "Could not set operation mode.");
}

dc1394speed_t Camera::getIsoSpeed() {
  printf("Camera::getIsoSpeed()\n");
  dc1394speed_t isoSpeed;
  dc1394error_t error;
  error = dc1394_video_get_iso_speed(camera, &isoSpeed);
  CAMERA_EXCEPTION(error, "Could not get ISO speed.");
  printf("Camera::getIsoSpeed(): %i\n", isoSpeed);
  return isoSpeed;
}

void Camera::setIsoSpeed(dc1394speed_t isoSpeed) {
  printf("Camera::setIsoSpeed(): %i\n", isoSpeed);
  dc1394error_t error;
  error = dc1394_video_set_iso_speed(camera, isoSpeed);
  CAMERA_EXCEPTION(error, "Could not set ISO speed.");
}

dc1394video_mode_t Camera::getVideoMode() {
  printf("Camera::getVideoMode()\n");
  dc1394video_mode_t videoMode;
  dc1394error_t error;
  error = dc1394_video_get_mode(camera, &videoMode);
  CAMERA_EXCEPTION(error, "Could not get video mode.");
  printf("Camera::getVideoMode(): %i\n", videoMode);
  return videoMode;
}

void Camera::setVideoMode(dc1394video_mode_t videoMode) {
  printf("Camera::setVideoMode(): %i\n", videoMode);
  dc1394error_t error;
  error = dc1394_video_set_mode(camera, videoMode);
  CAMERA_EXCEPTION(error, "Could not set video mode.");
}

void Camera::getFormat7Roi(dc1394video_mode_t videoMode, dc1394color_coding_t* colorCoding, uint32_t* packetSize,
    uint32_t* left, uint32_t* top, uint32_t* width, uint32_t* height) {
  printf("Camera::getFormat7Roi()\n");
  dc1394error_t error;
  error = dc1394_format7_get_roi(camera, videoMode, colorCoding, packetSize, left, top, width, height);
  CAMERA_EXCEPTION(error, "Could not get Format 7 ROI.");
  printf(
      "Camera::getFormat7Roi(): video mode: %i, color coding: %i, packet size: %i, left: %i, top: %i, width: %i, height: %i\n",
      videoMode, *colorCoding, *packetSize, *left, *top, *width, *height);
}

void Camera::setFormat7Roi(dc1394video_mode_t videoMode, dc1394color_coding_t colorCoding, int32_t packetSize,
    int32_t left, int32_t top, int32_t width, int32_t height) {
  printf(
      "Camera::setFormat7Roi(): video mode: %i, color coding: %i, packet size: %i, left: %i, top: %i, width: %i, height: %i\n",
      videoMode, colorCoding, packetSize, left, top, width, height);
  dc1394error_t error;
  error = dc1394_format7_set_roi(camera, videoMode, colorCoding, packetSize, left, top, width, height);
  CAMERA_EXCEPTION(error, "Could not set Format 7 ROI.");
}

void Camera::setupCapture() {

  printf("Camera::setupCapture()\n");
  dc1394error_t error;
  // TODO: Set up DMA buffer... 1-sized buffer is probably not good.
//  error = dc1394_capture_setup(camera, 1, DC1394_CAPTURE_FLAGS_DEFAULT);
  error = dc1394_capture_setup(camera, 2, DC1394_CAPTURE_FLAGS_DEFAULT);
  CAMERA_EXCEPTION(error, "Could not setup capture.");
}

void Camera::stopCapture() {

  dc1394error_t error;
  error = dc1394_capture_stop(camera);
  CAMERA_EXCEPTION(error, "Could not stop capture.");
}

void Camera::startVideoTransmission() {
  printf("Camera::startVideoTransmission()\n");
  dc1394error_t error;
  error = dc1394_video_set_transmission(camera, DC1394_ON);
  CAMERA_EXCEPTION(error, "Could not start video transmission.");
}

void Camera::stopVideoTransmission() {

  dc1394error_t error;
  error = dc1394_video_set_transmission(camera, DC1394_OFF);
  CAMERA_EXCEPTION(error, "Could not stop video transmission");
}

void Camera::flushFrames() {

  lockCapture();

  dc1394video_frame_t* frame;
  dc1394error_t error;

  error = dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_POLL, &frame);
  CAMERA_EXCEPTION(error, "Capture dequeue failed while flushing frames.");

  while (frame) {
    error = dc1394_capture_enqueue(camera, frame);
    CAMERA_EXCEPTION(error, "Capture enqueue failed while flushing frames.");
    error = dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_POLL, &frame);
    CAMERA_EXCEPTION(error, "Capture dequeue failed while flushing frames.");
  }

  unlockCapture();
}

void Camera::dropFrames(int n) {

  lockCapture();

  dc1394video_frame_t* frame;
  dc1394error_t error;

  for (int i = 0; i < n; i++) {
    error = dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_WAIT, &frame);
    CAMERA_EXCEPTION(error, "Capture dequeue failed while dropping frames.");
    error = dc1394_capture_enqueue(camera, frame);
    CAMERA_EXCEPTION(error, "Capture enqueue failed while dropping frames.");
  }

  unlockCapture();
}

void Camera::startOneShot() {

  dc1394error_t error;
  error = dc1394_video_set_one_shot(camera, DC1394_ON);
  CAMERA_EXCEPTION(error, "Failed to start one shot video.");
}

void Camera::stopOneShot() {

  dc1394error_t error;
  error = dc1394_video_set_one_shot(camera, DC1394_OFF);
  CAMERA_EXCEPTION(error, "Failed to stop one shot video.");
}

void Camera::lockCapture() {
  pthread_mutex_lock(&captureMutex);
}

void Camera::unlockCapture() {
  pthread_mutex_unlock(&captureMutex);
}

dc1394video_frame_t* Camera::dequeueFrame(const dc1394capture_policy_t capturePolicy) {

  lockCapture();
  dc1394error_t error;
  dc1394video_frame_t* frame;
  error = dc1394_capture_dequeue(camera, capturePolicy, &frame);
  CAMERA_EXCEPTION(error, "Failed to dequeue frame.");

  dequeuedFrames.push(frame);
  unlockCapture();

  return frame;
}

bool Camera::isFrameCorrupt(dc1394video_frame_t* frame) {
  return dc1394_capture_is_frame_corrupt(camera, frame) == DC1394_TRUE;
}

void Camera::enqueueFrameLater(const dc1394video_frame_t* frame) {

  lockCapture();
  framesToEnqueue.insert(const_cast<dc1394video_frame_t*> (frame));
  unlockCapture();
}

void Camera::enqueueFrames() {

  lockCapture();

  // Enqueue all frames marked as ready, in the order of dequeuing.
  while (framesToEnqueue.find(dequeuedFrames.front()) != framesToEnqueue.end()) {

    dc1394error_t error;
    error = dc1394_capture_enqueue(camera, dequeuedFrames.front());
    CAMERA_EXCEPTION(error, "Failed to enqueue frame.");

    framesToEnqueue.erase(dequeuedFrames.front());
    dequeuedFrames.pop();
  }

  unlockCapture();
}

void Camera::debayerFrame(dc1394video_frame_t* in, dc1394video_frame_t* out) {
  // Init output frame with target settings.
  out->color_coding = DC1394_COLOR_CODING_RGB8;
  out->image = NULL;
  out->allocated_image_bytes = 0;

  dc1394error_t error;
  error = dc1394_debayer_frames(in, out, bayerMethod);
  if (error != DC1394_SUCCESS) {
    free(out->image);
  }
  CAMERA_EXCEPTION(error, "Could not debayer frames.");
}

void Camera::captureColorMat(cv::Mat& bgrMat,  uint64_t& timestamp, bool wait) {
  // Initialize an empty matrix for case of any errors
  // or when no frame is available.
  bgrMat.create(0, 0, CV_8UC3);

  dc1394capture_policy_t capturePolicy = wait ? DC1394_CAPTURE_POLICY_WAIT : DC1394_CAPTURE_POLICY_POLL;
  dc1394video_frame_t* capturedFrame = dequeueFrame(capturePolicy);

  // Return an empty image if no frame is captured.
  // This may happen for polling captures.
  if (!capturedFrame) {
    return;
  }

  // TODO: Move to LadybugCamera. JPEG compression for particular video mode is Ladybug-specific.
  // Decompress JPEG frames.
  // opencv example
  /*
  static bool
mjpeg_to_rgb24 (int width, int height,
  unsigned char *src, int length,
  unsigned char *dst)
{
cv::Mat temp=cv::imdecode(cv::Mat(std::vector<uchar>(src, src + length)), 1);
if( !temp.data || temp.cols != width || temp.rows != height )
  return false;
memcpy(dst, temp.data, width*height*3);
return true;
}
  */
//http://libdc1394-22.sourcearchive.com/documentation/2.0.2/ladybug_8c-source.html
  if (capturedFrame->video_mode == DC1394_VIDEO_MODE_FORMAT7_6) {
    cv::Mat decodedFrame(capturedFrame->size[1], capturedFrame->size[0], CV_8UC1);

    unsigned int jpgadr, jpgsize, adr;
    for (int cam = 0; cam < 6; cam++) {
      adr = 0x340 + (5 - cam) * 32;
      jpgadr = (((unsigned int)*(capturedFrame->image + adr)) << 24)+
          (((unsigned int)*(capturedFrame->image + adr + 1)) << 16)+
          (((unsigned int)*(capturedFrame->image + adr + 2)) << 8)+
          (((unsigned int)*(capturedFrame->image + adr + 3)));
      adr += 4;
      jpgsize = (((unsigned int)*(capturedFrame->image + adr)) << 24)+
          (((unsigned int)*(capturedFrame->image+adr + 1)) << 16)+
          (((unsigned int)*(capturedFrame->image+adr + 2)) << 8)+
          (((unsigned int)*(capturedFrame->image+adr + 3)));

      if (jpgsize != 0) {
//        fwrite((unsigned char *)(jpgadr+frame->image),jpgsize,1,fd);
        // capturedFrame->image + jpgadr + jpgsize - 1?
        cv::Mat decodedImage = cv::imdecode(cv::Mat(std::vector<uchar>(capturedFrame->image + jpgadr, capturedFrame->image + jpgadr + jpgsize)), -1);
        if (decodedImage.empty()) {
          printf("Decoding failed.\n");
          enqueueFrameLater(capturedFrame);
          enqueueFrames();
          return;
        }
        cv::Mat targetRowRange = decodedFrame.rowRange(cam * 1232, (cam + 1) * 1232);
        decodedImage.copyTo(targetRowRange);
      }
    }
    memcpy(capturedFrame->image, decodedFrame.data, capturedFrame->size[1] * capturedFrame->size[0]);

    // NB: Buffer of captured frame is managed by DMA and must not be released.
//    cv::Mat encoded(capturedFrame->size[1], capturedFrame->size[0], CV_8UC1, capturedFrame->image);
    // NB: Buffer of decoded image should not be release before converted to result.
//    cv::Mat decoded = cv::imdecode(cv::Mat(std::vector<uchar>(capturedFrame->image, capturedFrame->image + capturedFrame->allocated_image_bytes)), 0);
//    if (decoded.empty()) {
//      printf("Decoding failed.\n");
//      enqueueFrameLater(capturedFrame);
//      enqueueFrames();
//      return;
//    }
//
//    memcpy(capturedFrame->image, decoded.data, capturedFrame->size[1] * capturedFrame->size[0]);
  }

  // Enqueue the frame and return an empty image if the frame is corrupted.
  if (isFrameCorrupt(capturedFrame)) {
    dc1394_log_warning("Frame corrupted.");
    enqueueFrameLater(capturedFrame);
    enqueueFrames();
    return;
  }

  timestamp = capturedFrame->timestamp;

  printf("Frame captured: frames behind: %u, id: %u, timestamp: %lu\n", capturedFrame->frames_behind, capturedFrame->id,
      static_cast<unsigned long>(capturedFrame->timestamp));

  // Init output frame with target settings.
  dc1394video_frame_t rgbFrame;
  debayerFrame(capturedFrame, &rgbFrame);

  enqueueFrameLater(capturedFrame);
  enqueueFrames();

  cv::Mat rgbMat(rgbFrame.size[1], rgbFrame.size[0], CV_8UC3, rgbFrame.image);
  cv::cvtColor(rgbMat, bgrMat, CV_RGB2BGR);

  free(rgbFrame.image);
}

void Camera::powerOn() {

  dc1394error_t error;
  error = dc1394_camera_set_power(camera, DC1394_ON);
  CAMERA_EXCEPTION(error, "Could not power on the camera.");
}

void Camera::powerOff() {

  dc1394error_t error;
  error = dc1394_camera_set_power(camera, DC1394_OFF);
  CAMERA_EXCEPTION(error, "Could not power off the camera.");
}

void Camera::reset() {

  dc1394error_t error;
  error = dc1394_camera_reset(camera);
  CAMERA_EXCEPTION(error, "Camera reset failed.");
}

void Camera::resetBus() {

  dc1394error_t error;
  error = dc1394_reset_bus(camera);
  CAMERA_EXCEPTION(error, "Reseting bus failed.");
}

void Camera::releaseAll() {

  dc1394error_t error;
  error = dc1394_iso_release_all(camera);
  CAMERA_EXCEPTION(error, "Releasing ISO channels and bandwidth failed.");
}

dc1394bayer_method_t Camera::getBayerMethod() {
  return bayerMethod;
}

void Camera::setBayerMethod(dc1394bayer_method_t method) {
  bayerMethod = method;
}

uint32_t Camera::getRegister(uint64_t offset) {
  uint32_t value;
  dc1394error_t err;
  err = dc1394_get_register(camera, offset, &value);
  CAMERA_EXCEPTION(err, "Getting camera register failed.");
  return value;
}

void Camera::setRegister(uint64_t offset, uint32_t value) {
  dc1394error_t err;
  err = dc1394_set_register(camera, offset, value);
  CAMERA_EXCEPTION(err, "Setting camera register failed.");
}

uint32_t Camera::getControlRegister(uint64_t offset) {
  uint32_t value;
  dc1394error_t err;
  err = dc1394_get_control_register(camera, offset, &value);
  CAMERA_EXCEPTION(err, "Getting camera control register failed.");
  return value;
}

void Camera::setControlRegister(uint64_t offset, uint32_t value) {
  dc1394error_t err;
  err = dc1394_set_control_register(camera, offset, value);
  CAMERA_EXCEPTION(err, "Setting camera control register failed.");
}

bool Camera::isFeaturePresent(dc1394feature_t feat) {
  dc1394error_t err;
  dc1394bool_t f_pres;
  err = dc1394_feature_is_present(camera, feat, &f_pres);
  CAMERA_EXCEPTION(err, "Getting feature present failed.");
  return f_pres == DC1394_TRUE;
}

bool Camera::isFeatureReadable(dc1394feature_t feat) {
  dc1394error_t err;
  dc1394bool_t f_read;
  err = dc1394_feature_is_readable(camera, feat, &f_read);
  CAMERA_EXCEPTION(err, "Getting feature readable failed.");
  return f_read == DC1394_TRUE;
}

bool Camera::isFeatureSwitchable(dc1394feature_t feat) {
  dc1394error_t err;
  dc1394bool_t f_sw;
  err = dc1394_feature_is_switchable(camera, feat, &f_sw);
  CAMERA_EXCEPTION(err, "Getting feature switchable failed.");
  return f_sw == DC1394_TRUE;
}

bool Camera::isFeaturePowerOn(dc1394feature_t feat) {
  dc1394error_t err;
  dc1394switch_t f_pwr;
  err = dc1394_feature_get_power(camera, feat, &f_pwr);
  CAMERA_EXCEPTION(err, "Getting feature power failed.");
  return f_pwr == DC1394_ON;
}

dc1394feature_mode_t Camera::getFeatureMode(dc1394feature_t feat) {
  dc1394error_t err;
  dc1394feature_mode_t f_mode;
  err = dc1394_feature_get_mode(camera, feat, &f_mode);
  CAMERA_EXCEPTION(err, "Getting feature mode failed.");
  return f_mode;
}

bool Camera::isFeatureAbsoluteControlAvailable(dc1394feature_t feat) {
  dc1394error_t err;
  dc1394bool_t f_avail;
  err = dc1394_feature_has_absolute_control(camera, feat, &f_avail);
  CAMERA_EXCEPTION(err, "Getting feature absolute control available failed.");
  return f_avail == DC1394_TRUE;
}

bool Camera::isFeatureAbsoluteControlOn(dc1394feature_t feat) {
  dc1394error_t err;
  dc1394switch_t f_sw;
  err = dc1394_feature_get_absolute_control(camera, feat, &f_sw);
  CAMERA_EXCEPTION(err, "Getting feature absolute control failed.");
  return f_sw == DC1394_ON;
}

uint32_t Camera::getFeatureMinBoundary(dc1394feature_t feat) {
  dc1394error_t err;
  uint32_t bound_min;
  uint32_t bound_max;
  err = dc1394_feature_get_boundaries(camera, feat, &bound_min, &bound_max);
  CAMERA_EXCEPTION(err, "Getting feature boundaries failed.");
  return bound_min;
}

uint32_t Camera::getFeatureMaxBoundary(dc1394feature_t feat) {
  dc1394error_t err;
  uint32_t bound_min;
  uint32_t bound_max;
  err = dc1394_feature_get_boundaries(camera, feat, &bound_min, &bound_max);
  CAMERA_EXCEPTION(err, "Getting feature boundaries failed.");
  return bound_max;
}

uint32_t Camera::getFeatureValue(dc1394feature_t feat) {
  dc1394error_t err;
  uint32_t val;
  err = dc1394_feature_get_value(camera, feat, &val);
  CAMERA_EXCEPTION(err, "Getting feature value failed.");
  return val;
}

float Camera::getFeatureMinAbsoluteBoundary(dc1394feature_t feat) {
  dc1394error_t err;
  float bound_min;
  float bound_max;
  err = dc1394_feature_get_absolute_boundaries(camera, feat, &bound_min, &bound_max);
  CAMERA_EXCEPTION(err, "Getting feature absolute boundaries failed.");
  return bound_min;
}

float Camera::getFeatureMaxAbsoluteBoundary(dc1394feature_t feat) {
  dc1394error_t err;
  float bound_min;
  float bound_max;
  err = dc1394_feature_get_absolute_boundaries(camera, feat, &bound_min, &bound_max);
  CAMERA_EXCEPTION(err, "Getting feature absolute boundaries failed.");
  return bound_max;
}

float Camera::getFeatureAbsoluteValue(dc1394feature_t feat) {
  dc1394error_t err;
  float abs_val;
  err = dc1394_feature_get_absolute_value(camera, feat, &abs_val);
  CAMERA_EXCEPTION(err, "Getting feature absolute value failed.");
  return abs_val;
}

void Camera::setFeaturePowerOn(dc1394feature_t feat) {
  dc1394error_t err;
  err = dc1394_feature_set_power(camera, feat, DC1394_ON);
  CAMERA_EXCEPTION(err, "Setting feature power on failed.");
}

void Camera::setFeaturePowerOff(dc1394feature_t feat) {
  dc1394error_t err;
  err = dc1394_feature_set_power(camera, feat, DC1394_OFF);
  CAMERA_EXCEPTION(err, "Setting feature power failed.");
}

void Camera::setFeaturetMode(dc1394feature_t feat, dc1394feature_mode_t mode) {
  dc1394error_t err;
  err = dc1394_feature_set_mode(camera, feat, mode);
  CAMERA_EXCEPTION(err, "Setting feature mode failed.");
}

void Camera::setFeatureAbsoluteControlOn(dc1394feature_t feat) {
  dc1394error_t err;
  err = dc1394_feature_set_absolute_control(camera, feat, DC1394_ON);
  CAMERA_EXCEPTION(err, "Setting feature absolute control on failed.");
}

void Camera::setFeatureAbsoluteControlOff(dc1394feature_t feat) {
  dc1394error_t err;
  err = dc1394_feature_set_absolute_control(camera, feat, DC1394_OFF);
  CAMERA_EXCEPTION(err, "Setting feature absolute control off failed.");
}

void Camera::setFeatureValue(dc1394feature_t feat, uint32_t value) {
  dc1394error_t err;
  err = dc1394_feature_set_value(camera, feat, value);
  CAMERA_EXCEPTION(err, "Setting feature value failed.");
}

void Camera::setFeatureAbsoluteValue(dc1394feature_t feat, float value) {
  dc1394error_t err;
  err = dc1394_feature_set_absolute_value(camera, feat, value);
  CAMERA_EXCEPTION(err, "Setting feature absolute value failed.");
}

uint32_t Camera::getWhiteBalanceBlue() {
  uint32_t u_b_value;
  uint32_t v_r_value;
  dc1394error_t err;
  err = dc1394_feature_whitebalance_get_value(camera, &u_b_value, &v_r_value);
  CAMERA_EXCEPTION(err, "Getting camera whitebalance feature failed.");
  return u_b_value;
}

uint32_t Camera::getWhiteBalanceRed() {
  uint32_t u_b_value;
  uint32_t v_r_value;
  dc1394error_t err;
  err = dc1394_feature_whitebalance_get_value(camera, &u_b_value, &v_r_value);
  CAMERA_EXCEPTION(err, "Getting camera whitebalance feature failed.");
  return v_r_value;
}

void Camera::setWhiteBalance(uint32_t u_b_value, uint32_t v_r_value) {
  dc1394error_t err;
  err = dc1394_feature_whitebalance_set_value(camera, u_b_value, v_r_value);
  CAMERA_EXCEPTION(err, "Setting camera whitebalance feature failed.");
}

void Camera::setWhiteBalanceBlue(uint32_t u_b_value) {
  dc1394error_t err;
  err = dc1394_feature_whitebalance_set_value(camera, u_b_value, getWhiteBalanceRed());
  CAMERA_EXCEPTION(err, "Setting camera whitebalance feature failed.");
}

void Camera::setWhiteBalanceRed(uint32_t v_r_value) {
  dc1394error_t err;
  err = dc1394_feature_whitebalance_set_value(camera, getWhiteBalanceBlue(), v_r_value);
  CAMERA_EXCEPTION(err, "Setting camera whitebalance feature failed.");
}

}
}