VideoSource_DCAM.cpp

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003, 2004    (see file CONTACTS for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <dc1394/control.h>

#include "VideoSource_DCAM.hh"
#include "sys/time.h"
#include "unistd.h"
#include <sys/stat.h>

// Number of DMA buffers was previously limited to 1 which resulted
// in deadlocks, hence the number was increased (esquivel, 05/09/2012)
#define NUM_DMA_BUFFERS 10

using namespace BIAS;
using namespace std;

int VideoSource_DCAM::InstancesTotal_ = 0;

int
BIAS::ScanBus(std::stringstream &ss)
{
  VideoSource_DCAM *cam;
  int ncams = 0;

  dc1394camera_list_t *camsList;
  dc1394error_t err;

  dc1394_t *d = dc1394_new();
  err = dc1394_camera_enumerate(d, &camsList);
  ncams = (int) camsList->num;

  if (err != DC1394_SUCCESS)
    {
      BIASERR("Scanning bus failed");
    }

  if (ncams > 0)
    {
      cam = new VideoSource_DCAM();
      //cam.SetDebugLevel(0);
      for (int i = 0; i < ncams; i++)
        {
          cam->SetSize(0, 0);
          cam->OpenDevice(camsList->ids[i].guid & 0x00000FFF);
          if (ss)
            {
              ss << "0" << "  " << (camsList->ids[i].guid & 0x00000FFF) << "  "
                  << cam->GetWidth() << "  " << cam->GetHeight() << " 0"
                  << " 0" << endl;
            }
          cam->CloseDevice();
        }
      delete cam;
    }
  else
    {
      dc1394_free(d);
      BIASERR("No cameras found on bus ");
      return -1;
    }
  dc1394_free(d);
  return ncams;
}

int
BIAS::ScanBus(vector<CameraInfo> &camInfos)
{
  camInfos.clear();
  int ncams = 0;

  dc1394camera_t *cams;
  dc1394camera_list_t *camsList;
  dc1394error_t err;

  dc1394_t *d = dc1394_new();
  err = dc1394_camera_enumerate(d, &camsList);
  ncams = (int) camsList->num;

  if (err != DC1394_SUCCESS)
    return 0;

  for (int i = 0; i < ncams; i++)
    {
      CameraInfo camInfo;
      cams = dc1394_camera_new(d, camsList->ids[i].guid);
      //    dc1394_reset_camera(cams);

      camInfo.camid = (camsList->ids[i].guid & 0x00000FFF);
      string m(cams->model);
      string v(cams->vendor);
      camInfo.model = m;
      camInfo.vendor = v;
      camInfo.guid = camsList->ids[i].guid;

      bool setFirewireManual = false;

      unsigned int vendor = (camsList->ids[i].guid) >> 40;
      unsigned int model = (camsList->ids[i].guid >> 12) & 0xFF;

      // we have a scorpion cam. firewire b detection doesnt work correctly
      if ((model == 0xf5 || model == 0x28) && vendor == 0x00b09d)
        {
          setFirewireManual = true;
        }
      else if (m == "Firefly MV FFMV-03MTM")
        {
          setFirewireManual = true;
        }

      if (cams->bmode_capable == DC1394_TRUE && !setFirewireManual)
        {
          camInfo.b_capable = true;
        }
      else
        {
          camInfo.b_capable = false;
        }

      dc1394video_modes_t modes;
      vector<dc1394video_mode_t> modesVector;
      vector<vector<float> > framesVector;
      unsigned MaxWidth_, MaxHeight_, UnitWidth_, UnitHeight_, MinBpP_;
      unsigned MaxBpP_, BestBpP_;

      dc1394_video_get_supported_modes(cams, &modes);
      for (unsigned int j = 0; j < modes.num; j++)
        {

          modesVector.push_back(modes.modes[j]);

          if (modes.modes[j] < DC1394_VIDEO_MODE_EXIF)
            {
              vector<float> innerFramesVector;
              dc1394framerates_t framerates;
              float fr;
              dc1394_video_get_supported_framerates(cams, modes.modes[j],
                  &framerates);
              for (unsigned int l = 0; l < framerates.num; l++)
                {
                  dc1394_framerate_as_float(framerates.framerates[l], &fr);
                  innerFramesVector.push_back(fr);
                }
              framesVector.push_back(innerFramesVector);
            }

          else if (modes.modes[j] > DC1394_VIDEO_MODE_EXIF)
            {

              dc1394_format7_get_max_image_size(cams, modes.modes[j],
                  &MaxWidth_, &MaxHeight_);
              dc1394_format7_get_unit_size(cams, modes.modes[j], &UnitWidth_,
                  &UnitHeight_);
              dc1394_format7_get_packet_parameters(cams, modes.modes[j],
                  &MinBpP_, &MaxBpP_);
              dc1394_format7_get_recommended_packet_size(cams, modes.modes[j],
                  &BestBpP_);

              for (int k = 0; k < 8; k++)
                {
                  if (modes.modes[j] == DC1394_VIDEO_MODE_FORMAT7_0 + k)
                    {
                      camInfo.f7_modes.push_back(
                          (dc1394video_mode_t) (DC1394_VIDEO_MODE_FORMAT7_0 + k));
                      camInfo.f7_MinBpP.push_back(MinBpP_);
                      camInfo.f7_MaxBpP.push_back(MaxBpP_);
                      camInfo.f7_maxHeight.push_back(MaxHeight_);
                      camInfo.f7_maxWidth.push_back(MaxWidth_);
                      camInfo.f7_unitHeight.push_back(UnitHeight_);
                      camInfo.f7_unitWidth.push_back(UnitWidth_);
                      camInfo.f7_bestBpP.push_back(BestBpP_);
                      //             cout << "Format7 Mode" << k << ": Size = "
                      // << MaxWidth_ <<  " x " << MaxHeight_ << endl;
                      //             cout << "Format7 Mode" << k << ": Unit = "
                      //<< UnitWidth_ <<  " x " << UnitHeight_ << endl;
                      //             cout << "Format7 Mode" << k
                      //<< ": Bytes per Packet = " << MinBpP_ <<  " - "
                      //<< MaxBpP_ << endl;
                    }
                }
            }
        }

      camInfo.framerates = framesVector;
      camInfo.videoModes = modesVector;

      // here we scan for the best mode and framerate...
      dc1394color_coding_t colorCoding;
      // search for best mode
      int y;
      for (y = modes.num - 1; y >= 0; y--)
        {
          if (modes.modes[y] < DC1394_VIDEO_MODE_EXIF)
            {
              camInfo.bestMode = modes.modes[y];
              // get color from video mode
              dc1394_get_color_coding_from_video_mode(cams, modes.modes[y],
                  &colorCoding);
              // dont set mono16 as default for compatibility reasons
              if (colorCoding != DC1394_COLOR_CODING_MONO16)
                {
                  break;
                }
            }
        }

      cout << "Best Mode: " << camInfo.bestMode << endl;

      // calc best framerate
      camInfo.bestFramerate = framesVector[y][framesVector[y].size() - 1];

      camInfos.push_back(camInfo);

      dc1394_camera_free(cams);
    }
  dc1394_camera_free_list(camsList);
  dc1394_free(d);
  return ncams;
}

VideoSource_DCAM::VideoSource_DCAM(int Card) : VideoSource()
{
  camid = 0;
  // IEEE1394Card_ = Card;
  //SetDebugLevel(D_DCAM);
  TransmissionTime_ = 0;
  UserTopLeft_ = false;
  UseBinning_ = false;
  Shift16_ = 0;
  IsControllable_ = true;
  SelectedCam_ = 0;
  // New Default: Use DMA
  UseDMA_ = true;
  bEnsureLatestFrame_ = false;

  DcamMode_ = DC1394_VIDEO_MODE_160x120_YUV444;
  DcamFormat_ = 0;
  DcamFps_ = DC1394_FRAMERATE_30;
  FramesPerSecond_ = 0.0;
  ForceF7_ = false;
  DirectF7_ = false;
  f7ColorCoding_ = DC1394_COLOR_CODING_RAW8;
  ColorMode_ = ImageBase::CM_UYVY422;
  Width_ = 0;
  Height_ = 0;
  BytesPerPacket_ = 0;
  ColorChannels_ = 0;

  TryFirewireB_ = true;
  UserMode_ = false;

  dcbus = NULL;
  camera = NULL;
  cameraList = NULL;

  InstancesTotal_++;

  minContrast_ = 0; //?
  maxContrast_ = 40;
  minGain_=0; //db
  maxGain_ = 56;
  minShutter_ = 0; //ms
  maxShutter_ = 400;

  // create new file for cam infos
  // ofstream fout( "cams.info" );
  //fout.close();

#ifdef BIAS_HAVE_PTHREADS
  pthread_mutex_init(&grabMutex_, NULL);
#endif
}

VideoSource_DCAM::~VideoSource_DCAM()
{
  InstancesTotal_--;
  if (Active_)
    {
      PostGrab();
      dc1394_camera_free(camera);
      dc1394_free(dcbus);
    }
}

void
VideoSource_DCAM::GetBytesPerPacketForFormat7(int camid,
    dc1394video_mode_t mode, int width, int height, unsigned int& minbpp,
    unsigned int& maxbpp)
{
  dcbus = dc1394_new();
  err = dc1394_camera_enumerate(dcbus, &cameraList);
  numCamsOnBus = cameraList->num;
  if (numCamsOnBus < 1)
    {
      BIASDOUT(D_DCAM,"There is no cam to open");
    }
  else
    {
      if (camid == 0)
        {
          camera = dc1394_camera_new(dcbus, cameraList->ids[camid].guid);
          SelectedCam_ = 0;
          ID_ = (camera->guid & 0x00000FFF);
        }
      else
        {
          for (unsigned int i = 0; i < numCamsOnBus; i++)
            {
              camera = dc1394_camera_new(dcbus, cameraList->ids[i].guid);
              ID_ = (camera->guid & 0x00000FFF);
              if (ID_ == camid)
                {
                  SelectedCam_ = i;
                  break;
                }
              //dc1394_reset_bus(camera);
              //dc1394_camera_free(camera);
            }
        }
      dc1394_format7_set_image_position(camera, mode, 0, 0);
      dc1394_format7_set_image_size(camera, mode, width, height);
      dc1394_format7_get_packet_parameters(camera, mode, &minbpp, &maxbpp);
    }
}

void
VideoSource_DCAM::SetCam_ID(int manualcamid_)
{
  camid = manualcamid_;

}


int
VideoSource_DCAM::OpenDevice(int camid)
{
  BIASDOUT(D_DCAM,"VideoSource_DCAM::OpenDevice("<< camid <<")");
  dcbus = dc1394_new();
  if (dcbus == NULL)
    {
      BIASERR("dc1394_new() failed.");
      return -1;
    }
  err = dc1394_camera_enumerate(dcbus, &cameraList);
  if (err != DC1394_SUCCESS)
    {
      BIASERR("dc1394_camera_enumerate() failed.");
      return -2;
    }

  numCamsOnBus = cameraList->num;

  if (numCamsOnBus < 1)
    {
      BIASERR("There is no cam to open");
      return -3;
    }
  else
    {
      BIASDOUT(D_DCAM,"Found " << numCamsOnBus << " cams");

      if (camid == 0)
        {
          camera = dc1394_camera_new(dcbus, cameraList->ids[camid].guid);
          SelectedCam_ = 0;
          ID_ = (camera->guid & 0x00000FFF);
        }
      else
        {
          bool foundCamWithId = false;

          for (unsigned int i = 0; i < numCamsOnBus; i++)
            {

              camera = dc1394_camera_new(dcbus, cameraList->ids[i].guid);
              ID_ = (camera->guid & 0x00000FFF);

              BIASDOUT(D_DCAM,"List guid" << cameraList->ids[i].guid << "masked" << (cameraList->ids[i].guid & 0x00000FFF)   << endl);
              BIASDOUT(D_DCAM,"ID of the new device" << camera->guid << " cams" << "masked:" << ID_ << endl);

          // ofl: camid is between 0 and numCamsOnBus but ID_ is the guid, an arbitrary int
          // this new check should always be true
              //if((camera->guid & 0x00000FFF) == (cameraList->ids[i].guid & 0x00000FFF))
              if (ID_ == camid)
                {
                  SelectedCam_ = i;
                  foundCamWithId = true;
                  break;
                }
              else {
                dc1394_camera_free(camera);
              }
              //dc1394_reset_bus(camera);
            }
      // cam not found
          if (!foundCamWithId)
            {
              return -4;
            }
        }
    }
  //dc1394_cleanup_iso_channels_and_bandwidth(camera);
  CamModel_ = GetModelForEuid(camera->guid);
  QueryCam();

  return InitCam();

}

int
VideoSource_DCAM::OpenDevice()
{
  return OpenDevice(camid);
}

void
VideoSource_DCAM::SetModeAndFramerate(dc1394video_mode_t mode, float framerate)
{
  DcamMode_ = mode;
  if (DcamMode_ == 84)
    {
      SetColorModel(ImageBase::CM_Bayer_RGGB);
      cout << "SMAFR ColorModel:" << GetColorModel() << endl;
    }
  SetFPS(framerate);
  UserMode_ = true;
}

int
VideoSource_DCAM::SetFormat7(int mode, int bpp, dc1394color_coding_t colorCoding)
{
  f7ColorCoding_ = colorCoding;
  DcamMode_ = (dc1394video_mode_t) (DC1394_VIDEO_MODE_FORMAT7_MIN + mode);
  BytesPerPacket_ = bpp;
  DirectF7_ = true;
  return 0;
}

int
VideoSource_DCAM::CloseDevice()
{
  // release cam and clean up
  if (Active_)
    {
      PostGrab();
    }
  return 0;
}

void
VideoSource_DCAM::SetFirewireB(bool on)
{
  TryFirewireB_ = on;
}

/*
 int VideoSource_DCAM::UsePort(int channel)
 {
 //IEEE1394Card_ = channel;
 return 0;
 }
 */

int
VideoSource_DCAM::GrabSingle(Camera<unsigned char> &image)
{

#ifdef BIAS_HAVE_PTHREADS
  pthread_mutex_lock(&grabMutex_);
#endif

  BIASDOUT(D_DCAM,"VideoSource_DCAM::GrabSingle("<<SelectedCam_<<")");
  //  assert(! image.IsEmpty());
  if (image.IsEmpty())
    {
      BIASERR("VideoSource_DCAM::GrabSingle(): Given Image is empty, use InitImage()");
      //return -1;
    }

  if (!Active_)
    {
      BIASERR("VideoSource_DCAM::GrabSingle(): VideoSource Object not active, use PreGrab()");
      return -1;
    }
  if (Grabbing_)
    {
      BIASERR("VideoSource_DCAM::GrabSingle(): VideoSource Object is already grabbing()");
      return -1;
    }
  Grabbing_ = true;

  dc1394video_frame_t * frame;
  err = dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_WAIT, &frame);
  if (err != DC1394_SUCCESS)
    {
      BIASERR("VideoSource_DCAM::GrabSingle(): unable to capture from camera:"<< CamModel_);
      Grabbing_ = false;
      return -1;
    }
  if (bEnsureLatestFrame_)
    {
      while(frame && err == DC1394_SUCCESS) {
        // cout << "Grabbing again for latest frame:" << endl;
        err = dc1394_capture_enqueue(camera, frame);
        err = dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_POLL, &frame);
      }
    }

  image.CopyIn_NoInit((unsigned char *) frame->image);
  // set time in micro seconds
  image.SetTime(0, frame->timestamp);
  image.UpdateMetaData();

  err = dc1394_capture_enqueue(camera, frame);

  image.InvalidateUID();
  image.SetUID(UUID::GenerateUUID());

  Grabbing_ = false;

#ifdef BIAS_HAVE_PTHREADS
  pthread_mutex_unlock(&grabMutex_);
#endif

  return 0;
}

#ifdef BUILD_IMAGE_USHORT
int
VideoSource_DCAM::GrabSingle(BIAS::Camera<unsigned short> &image)
{
#ifdef BIAS_HAVE_PTHREADS
  pthread_mutex_lock(&grabMutex_);
#endif

  BIASDOUT(D_DCAM,"VideoSource_DCAM::GrabSingle("<<SelectedCam_<<")");
  //  assert(! image.IsEmpty());
  if (image.IsEmpty())
    {
      BIASERR("VideoSource_DCAM::GrabSingle(): Given Image is empty, use InitImage()");
      //return -1;
    }

  if (!Active_)
    {
      BIASERR("VideoSource_DCAM::GrabSingle(): VideoSource Object not active, use PreGrab()");
      return -1;
    }
  if (Grabbing_)
    {
      BIASERR("VideoSource_DCAM::GrabSingle(): VideoSource Object is already grabbing()");
      return -1;
    }
  Grabbing_ = true;

  dc1394video_frame_t * frame;
  err = dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_WAIT, &frame);
  if (err != DC1394_SUCCESS)
    {
      BIASERR("VideoSource_DCAM::GrabSingle(): unable to capture from camera:"<< CamModel_);
      Grabbing_ = false;
      return -1;
    }

  unsigned int numbytes = image.GetSize();
  // byte-wise pointer
  unsigned char *idata = (unsigned char *) image.GetImageData();
  unsigned char *buf = (unsigned char *) frame->image;

  for (unsigned int i = 0; i < numbytes; i += 2)
    {
      idata[i] = buf[i + 1];
      idata[i + 1] = buf[i];
      // the significant bits used by point grey are the 16-Shift16_  upper bits
      // cast pixel pointer to unsigned short and apply shift
      *(unsigned short *) (&idata[i]) = (*(unsigned short *) (&idata[i]))
          >> Shift16_;
    }
  image.SetTime(0, frame->timestamp);
  image.UpdateMetaData();

  err = dc1394_capture_enqueue(camera, frame);

  image.InvalidateUID();
  image.SetUID(UUID::GenerateUUID());

  Grabbing_ = false;

#ifdef BIAS_HAVE_PTHREADS
  pthread_mutex_unlock(&grabMutex_);
#endif
  return 0;
}
#endif

void
VideoSource_DCAM::ActivateScorpionTimestamp()
{
  //quadlet_t r12F8 = 0x80000001;//activate only timestamp, read Tech Reference
  // SetCameraControlRegister(IEEE1394Handle_[IEEE1394Card_],
  //           DcamNodes_[SelectedCam_], 0x12f8, r12F8);
}

int
VideoSource_DCAM::PreGrab()
{
  BIASDOUT(D_DCAM,"VideoSource_DCAM::PreGrab("<<SelectedCam_<<")");

  if (!CompleteInitialized_)
    if (InitCam() < 0)
      return -1;

  // dc1394_video_set_one_shot(camera, DC1394_OFF);
  // have the camera start sending us data
  printf("Start transmission\n");
  if (dc1394_video_set_transmission(camera, DC1394_ON) != DC1394_SUCCESS)
    {
      fprintf(stderr, "Unable to start camera iso transmission\n");
      Active_ = false;

    }
  else
    {
      Active_ = true;
    }
  dc1394switch_t isoOn;
  dc1394_video_get_transmission(camera, &isoOn);
  cout << "Iso on: " << isoOn << endl;
  return 0;
}

int
VideoSource_DCAM::PostGrab()
{
  int res = 0;
  if (Active_ == true)
    {
      BIASDOUT(D_DCAM,"VideoSource_DCAM::PostGrab("<<SelectedCam_<<")");
      Active_ = false;
      if (dc1394_video_set_transmission(camera, DC1394_OFF) != DC1394_SUCCESS)
        {
          cout << "Couldn't stop the camera?" << endl;
        }
      dc1394_capture_stop(camera);

    }
  return res;
}

int
VideoSource_DCAM::QueryCam()
{
  BIASDOUT(D_DCAM,"VideoSource_DCAM::QueryCam("<<SelectedCam_<<")");

  // Query the cam for available modes
  err = dc1394_video_get_supported_modes(camera, &CameraModes_);

  if (err != DC1394_SUCCESS)
    {
      BIASDOUT(D_DCAM,"Could not query cam for modes");
      return -1;
    }
  float fr;
  // Query for framerates but not for format 7
  for (unsigned int i = 0; i < CameraModes_.num; i++)
    {
      dc1394video_mode_t mode = CameraModes_.modes[i];
      if (mode < DC1394_VIDEO_MODE_EXIF)
        {
          err = dc1394_video_get_supported_framerates(camera, mode,
              &CameraFramerates_[DC1394_VIDEO_MODE_MAX - mode]);

          //  cout << "Framerates for Mode " <<  mode << ": ";
          for (unsigned int j = 0; j < CameraFramerates_[DC1394_VIDEO_MODE_MAX
              - mode].num; j++)
            {
              dc1394_framerate_as_float(CameraFramerates_[DC1394_VIDEO_MODE_MAX
                  - mode].framerates[j], &fr);
              // cout << fr << " ";
            }
          //      cout << endl;
        }
    }
  // Query for Format 7
  for (unsigned int i = 0; i < CameraModes_.num; i++)
    {
      dc1394video_mode_t mode = CameraModes_.modes[i];
      if (mode > DC1394_VIDEO_MODE_EXIF)
        {
          dc1394_format7_get_max_image_size(camera, mode, &MaxWidth_,
              &MaxHeight_);
          dc1394_format7_get_unit_size(camera, mode, &UnitWidth_, &UnitHeight_);
          dc1394_format7_get_packet_parameters(camera, mode, &MinBpP_, &MaxBpP_);
          //       for(int k = 0; k<8;k++){
          //         if(mode == DC1394_VIDEO_MODE_FORMAT7_0+k){
          //           cout << "Format7 Mode" << k << ": Size = " << MaxWidth_
          //                <<  " x " << MaxHeight_ << endl;
          //           cout << "Format7 Mode" << k << ": Unit = " << UnitWidth_
          //                <<  " x " << UnitHeight_ << endl;
          //           cout << "Format7 Mode" << k << ": Bytes per Packet = "
          //                << MinBpP_ <<  " - " << MaxBpP_ << endl;
          //         }
          //       }
        }
    }
  // get camera features
  dc1394_feature_get_all(camera, &DcamFeatures_);
  return 0;
}

int
VideoSource_DCAM::ShowCapabilities()
{
  /*
   cout <<"Camera: "<<SelectedCam_<<" UID:"
   <<(DcamInfo_.euid_64 & 0x00000FFF)<<endl;

   // Die Ergebnisse des Querys in eine Datei schreiben
   //ofstream fout( "cams.info" );
   // fout << dc1394_print_feature_set(&DcamFeatures_);

   // Allgemeine Kamerainfos (UID, Vendor and Model)
   dc1394_print_camera_info(&DcamInfo_);

   // Firewire B kompatibel
   if(DcamSpeed_ > 2)
   cout <<"Firewire B capable"<< endl;
   else
   cout <<"Firewire A" << endl;

   // Operating Mode der Cam
   unsigned int op_mode_;
   dc1394_get_operation_mode(IEEE1394Handle_[IEEE1394Card_],
   DcamNodes_[SelectedCam_],
   &op_mode_);
   cout << "Operation mode: ";
   if(op_mode_ == 1)
   cout << "DC1394_OPERATION_MODE_1394B" << endl;
   else
   cout << "DC1394_OPERATION_MODE_LEAGACY" << endl;

   //

   // Features der Cam und deren Einstellungen
   // dc1394_print_feature_set(&DcamFeatures_);



   cout <<"Supported Formats: ";
   for (int i=0; i<NUM_FORMATS; i++)
   if (SupportedFormats_[i])
   cout <<"Format"<<i<<" ";
   cout <<endl;

   cout <<"Supported Modes:"<<endl;
   for (int i=0; i<NUM_FORMATS; i++)
   if (SupportedFormats_[i]) {
   cout <<"Format"<<i<<": ";
   for (int j=0; j<NUM_FORMAT1_MODES; j++)
   if (SupportedModes_[i][j])
   cout <<"Mode"<<j<<" ";

   cout <<endl;

   }

   cout <<"Supported Framerates:"<<endl;
   for (int format=0; format < NUM_FORMATS-1; format++) {
   // int fps;
   quadlet_t fps;

   cout <<" Format"<<format<<": ";
   for (int i=0; i<NUM_FORMAT1_MODES; i++){
   if ((fps = SupportedFramerates_[format][i]) >0) {
   cout <<"Mode"<<i<<":  ";
   for (int f=0; f<NUM_FRAMERATES; f++)
   if (fps & (0x1 << (31-f) ))
   cout <<1.875 *(0x1<<f)<<"  ";

   }
   }

   cout <<endl;
   }

   */
  return 0;

}

int
VideoSource_DCAM::SelectDefault()
{
  cout << "VideoSource_DCAM::SelectDefault(" << SelectedCam_ << ")" << endl;
  dc1394color_coding_t colorCoding;
  // search for best mode
  for (int i = CameraModes_.num - 1; i >= 0; i--)
    {
      if (CameraModes_.modes[i] < DC1394_VIDEO_MODE_EXIF)
        {
          DcamMode_ = CameraModes_.modes[i];
          // get color from video mode
          dc1394_get_color_coding_from_video_mode(camera, DcamMode_,
              &colorCoding);
          // dont set mono16 as default for compatibility reasons
          if (colorCoding != DC1394_COLOR_CODING_MONO16)
            {
              break;
            }
        }
    }

  //cout << "Selected Mode " << DcamMode_ << endl;
  // search for best framerate
  DcamFps_
      = CameraFramerates_[DC1394_VIDEO_MODE_MAX - DcamMode_].framerates[CameraFramerates_[DC1394_VIDEO_MODE_MAX
          - DcamMode_].num - 1];

  // get width and height from video mode.
  uint32_t w, h;
  dc1394_get_image_size_from_video_mode(camera, DcamMode_, &w, &h);
  Width_ = (int) w;
  Height_ = (int) h;

  SetColorFromMode_(DcamMode_);

  // default settings for some special cameras
  if (CamModel_ == CAMERA_PTGREY_DRAGONFLY2_COLOR_HIRES)
    {
      cout
          << " Ignoring autodetected mode for Dragonfly2. Setting to format2, mode4, 7.5fps."
          << endl;
      DcamMode_ = DC1394_VIDEO_MODE_1600x1200_RGB8;
      DcamFps_ = DC1394_FRAMERATE_7_5;
      ColorChannels_ = 3;
      Width_ = 1600;
      Height_ = 1200;
      //GetColorFromMode(DcamMode_);
      SetColorFromMode_(DcamMode_);
    }
  if (CamModel_ == CAMERA_PTGREY_GRASSHOPPER_COLOR)
    {
      cout
          << " Ignoring autodetected mode for Grasshopper. Setting to format1, mode3, 15fps."
          << endl;
      cout << " Size 1600x1200" << endl;
      DcamMode_ = DC1394_VIDEO_MODE_1024x768_YUV422;
      DcamFps_ = DC1394_FRAMERATE_30;
      Width_ = 1024;
      Height_ = 768;
      ColorChannels_ = 2;
      SetColorFromMode_(DcamMode_);
    }
  if (CamModel_ == CAMERA_UNIBRAIN_FIREI)
    {
      cout
          << " Ignoring autodetected mode for Fire-i. Setting to 640x480 RGB8, 15 fps."
          << endl;
      DcamMode_ = DC1394_VIDEO_MODE_640x480_RGB8;
      DcamFps_ = DC1394_FRAMERATE_15;
      Width_ = 640;
      Height_ = 480;
      ColorChannels_ = 1;
      SetColorFromMode_(DcamMode_);
    }
  if (CamModel_ == CAMERA_PTGREY_FIREFLY_COLOR)
    {
      cout
          << " Ignoring autodetected mode for FireFLY setting to 640x480, color, 30fps."
          << endl;
      DcamFps_ = DC1394_FRAMERATE_30;
      DcamMode_ = DC1394_VIDEO_MODE_640x480_MONO8;
      Width_ = 640;
      Height_ = 480;
      ColorChannels_ = 1;
      ColorMode_ = ImageBase::CM_Bayer_GBRG;

    }
  if (CamModel_ == CAMERA_PTGREY_FIREFLY_BW)
    {
      cout
          << " \n\nIgnoring autodetected mode for FireFLY setting to mono8, 30fps. "
          << endl;
      DcamFps_ = DC1394_FRAMERATE_30;
      DcamMode_ = DC1394_VIDEO_MODE_640x480_MONO8;
      DcamFps_ = DC1394_FRAMERATE_30;
      Width_ = 640;
      Height_ = 480;
      ColorChannels_ = 1;
      SetColorFromMode_(DcamMode_);

    }
  if (CamModel_ == CAMERA_PTGREY_DRAGONFLY2_COLOR_HIRES)
    {
      cout << " Setting best framerate right for the DragonFly 2.\n";
      FramesPerSecond_ = 7.5; //DEBUG TODO: Dragonfly2
      SetColorFromMode_(DcamMode_);
    }

  if (CamModel_ == CAMERA_KAMERAWERK_DRESDEN_LOGILUX_I5)
    {
      cout << " Setting best framerate right for the KameraWerk Dresden i5\n";
      FramesPerSecond_ = 25;
      maxShutter_ = 400;
      //set correct mode here!!!

      DcamMode_ = DC1394_VIDEO_MODE_1024x768_MONO8;
      SetColorFromMode_(DcamMode_);
    }
  float fr;
  dc1394_framerate_as_float(DcamFps_, &fr);
  BIASDOUT(D_DCAM,"Best Settings for Camera: " << Width_<<"x"<<Height_
      <<" at "<< fr<<"fps"<<" Colormodel: "<<ColorMode_);

  return 0;
}

#define USE_NATIVE_XGA

int
VideoSource_DCAM::UserSizeToMode()
{
  BIASDOUT(D_DCAM,"VideoSource_DCAM::UserSizeToMode("<<SelectedCam_<<"): "<<Width_<<"x"<<Height_<<" BytesPerPixel_: "<<BytesPerPixel_<<" ColorMode: "<<ColorMode_);
  int res = 0;

  if (ForceF7_)
    res = UserSizeToFormat7_();
  else
    {
      if (BytesPerPixel_ == 1.0)
        res = UserSizeToMode_8bit_();
      else if (BytesPerPixel_ == 2.0)
        res = UserSizeToMode_16bit_();
      else
        {
          BIASERR("VideoSource_DCAM::UserSizeToMode(): "<<BytesPerPixel_*8
              <<" -bit not yet impl");
          return -1;
        }
      // -1 means: did not find a mode, try Format7
      if (res == -1)
        res = UserSizeToFormat7_();
    }
  return res;
}

// try to find a matching mode or return -1 to indicate that Format7
// may be good
int
VideoSource_DCAM::UserSizeToMode_8bit_()
{
  int res = 0;

  switch (ColorMode_)
    {
  case ImageBase::CM_UYVY422:
    ColorChannels_ = 2;
    if (Width_ == 1600 && Height_ == 1200)
      {
        DcamMode_ = DC1394_VIDEO_MODE_1600x1200_YUV422;
        //DcamFormat_ = FORMAT_SVGA_NONCOMPRESSED_1;
      }
    else if (Width_ == 1280 && Height_ == 960)
      {
        DcamMode_ = DC1394_VIDEO_MODE_1280x960_YUV422;
        //DcamFormat_ = FORMAT_SVGA_NONCOMPRESSED_1;
      }
    else if (Width_ == 1024 && Height_ == 768)
      {
        DcamMode_ = DC1394_VIDEO_MODE_1024x768_YUV422;
        //DcamFormat_ = FORMAT_SVGA_NONCOMPRESSED_1;
        BIASDOUT(D_DCAM,"Using native XGA");
      }
    else if (Width_ == 800 && Height_ == 600)
      {
        DcamMode_ = DC1394_VIDEO_MODE_800x600_YUV422;
        //DcamFormat_ = FORMAT_SVGA_NONCOMPRESSED_1;
      }
    else if (Width_ == 640 && Height_ == 480)
      {
        DcamMode_ = DC1394_VIDEO_MODE_640x480_YUV422;
        //DcamFormat_ = FORMAT_VGA_NONCOMPRESSED;
      }
    else if (Width_ == 320 && Height_ == 240)
      {
        DcamMode_ = DC1394_VIDEO_MODE_320x240_YUV422;
        //DcamFormat_ = FORMAT_VGA_NONCOMPRESSED;
      }
    else
      res = -1;// Format 7 required,
    break;
  case ImageBase::CM_YUV411:
    ColorChannels_ = 2;
    //     if (Width_ == 1600 && Height_ == 1200) {
    //       DcamMode_ = MODE_1600x1200_YUV411;
    //       DcamFormat_ = FORMAT_SVGA_NONCOMPRESSED_1;
    //     }
    //     else if (Width_ == 1280 && Height_ == 960) {
    //       DcamMode_ = MODE_1280x960_YUV41;
    //       DcamFormat_ = FORMAT_SVGA_NONCOMPRESSED_1;
    //     }
    //     else if (Width_ == 1024 && Height_ == 768) {
    //       DcamMode_ = MODE_1024x768_YUV411;
    //       DcamFormat_ = FORMAT_SVGA_NONCOMPRESSED_1;
    //       BIASDOUT(D_DCAM,"Using native XGA");
    //     }
    //     else if (Width_ == 800 && Height_ == 600) {
    //       DcamMode_ = MODE_800x600_YUV41;
    //       DcamFormat_ = FORMAT_SVGA_NONCOMPRESSED_1;
    //     }
    //     else
    if (Width_ == 640 && Height_ == 480)
      {
        DcamMode_ = DC1394_VIDEO_MODE_640x480_YUV411;
        //DcamFormat_ = FORMAT_VGA_NONCOMPRESSED;
      }
    else
      res = -1;// Format 7 required,
    break;
  case ImageBase::CM_Grey:
  case ImageBase::CM_Bayer_RGGB:
  case ImageBase::CM_Bayer_GBRG:
  case ImageBase::CM_Bayer_GRBG:
  case ImageBase::CM_Bayer_BGGR:
    ColorChannels_ = 1;
    if (Width_ == 1600 && Height_ == 1200)
      {
        DcamMode_ = DC1394_VIDEO_MODE_1600x1200_MONO8;
        cout << "Mode:DC1394_VIDEO_MODE_1600x1200_MONO8" << endl;
      }
    else if (Width_ == 1024 && Height_ == 768)
      {
        DcamMode_ = DC1394_VIDEO_MODE_1024x768_MONO8;
      }
    else if (Width_ == 1280 && Height_ == 960)
      {
        DcamMode_ = DC1394_VIDEO_MODE_1280x960_MONO8;
      }

    else if (Width_ == 640 && Height_ == 480 && CamModel_
        != CAMERA_PTGREY_DRAGONFLY_HIRES)
      {
        DcamMode_ = DC1394_VIDEO_MODE_640x480_MONO8;
        BIASDOUT(D_DCAM,"Mode: "
            <<" 640x480_MONO");
      }
    else
      return -1;
    break;
  case ImageBase::CM_RGB:
    if (Width_ == 640 && Height_ == 480)
      {
        DcamMode_ = DC1394_VIDEO_MODE_640x480_RGB8;
      }
    else
      res = -1;
    break;
  default:
    BIASERR("VideoSource_DCAM::UserSizeToMode(): Unsupported ColorModel_"
        <<ColorMode_)
    ;
    res = -2;
    }

  return res;
}

int
VideoSource_DCAM::UserSizeToMode_16bit_()
{

  int res = 0;
  switch (ColorMode_)
    {
  case ImageBase::CM_Grey:
  case ImageBase::CM_Bayer_RGGB:
  case ImageBase::CM_Bayer_GBRG:
  case ImageBase::CM_Bayer_GRBG:
  case ImageBase::CM_Bayer_BGGR:
    if (Width_ == 640 && Height_ == 480)
      {
        ColorChannels_ = 1;
        DcamMode_ = DC1394_VIDEO_MODE_640x480_MONO16;
        // DcamFormat_ = FORMAT_VGA_NONCOMPRESSED;
        BIASDOUT(D_DCAM,"Mode: "
            <<" 640x480_MONO16");
      }
    else if (Width_ == 1024 && Height_ == 768)
      {
        ColorChannels_ = 1;
        DcamMode_ = DC1394_VIDEO_MODE_1024x768_MONO16;
        BIASDOUT(D_DCAM," Mode: "
            <<" 1024x768_MONO16");
      }
    else if (Width_ == 1280 && Height_ == 960)
      {
        ColorChannels_ = 1;
        DcamMode_ = DC1394_VIDEO_MODE_1280x960_MONO16;
      }
    else if (Width_ == 1600 && Height_ == 1200)
      {
        ColorChannels_ = 1;
        DcamMode_ = DC1394_VIDEO_MODE_1600x1200_MONO16;
      }
    else
      res = -1;
    break;
  default:
    BIASERR("VideoSource_DCAM::UserSizeToMode(): Unsupported ColoModel_ for 16bpp:"<<ColorMode_)
    ;
    res = -2;
    }

  return res;
}

unsigned int
VideoSource_DCAM::CalcBytesPerPacket()
{

  unsigned int BpP = 0;
  unsigned int QuadletsPerPacket;

  int QuadletsPerFrame;
  double TransmissionTimePerFrame;
  double MaxCyclesPerFrame;
  unsigned int CyclesPerFrame;

  if (FramesPerSecond_ == 0.0)
    {
      BIASERR("VideoSource_DCAM::CalcBytesPerPacket(): FramesPerSecond_ is 0!");
      return 0;
    }

  dc1394_format7_get_packet_parameters(camera, DC1394_VIDEO_MODE_FORMAT7_0,
      &MinBpP_, &MaxBpP_);

  BIASDOUT(D_DCAM_F7,"MinBpP: "<<MinBpP_<<" MaxBpP: "<<MaxBpP_);

  QuadletsPerFrame = Width_ * Height_ * ColorChannels_ / 4;
  // time to transmit one frame to reach this fps in [ms]
  float fps = FramesPerSecond_;
  // evil hack to let 15 fps work
  if (fps > 14.9 && fps < 20.0)
    fps += 2.0;
  // hack to get 30 fps work
  if (fps > 29.9 && fps < 35)
    fps += 4.0;
  TransmissionTimePerFrame = 1000.0 / fps;
  // each 125usec one packet is transmitted
  MaxCyclesPerFrame = TransmissionTimePerFrame / 0.125;
  CyclesPerFrame = (int) MaxCyclesPerFrame;

  QuadletsPerPacket = QuadletsPerFrame / CyclesPerFrame;

  while ((QuadletsPerFrame % QuadletsPerPacket) != 0)
    {
      CyclesPerFrame--;
      QuadletsPerPacket = QuadletsPerFrame / CyclesPerFrame;
    }

  BIASDOUT(D_DCAM_F7,"FramesPerSecond: "<<FramesPerSecond_);
  BIASDOUT(D_DCAM_F7,"TransmissionTimePerFrame: "<<TransmissionTimePerFrame);
  BIASDOUT(D_DCAM_F7,"MaxCyclesPerFrame: "<<MaxCyclesPerFrame);
  BIASDOUT(D_DCAM_F7,"CyclesPerFrame: "<<CyclesPerFrame);
  BIASDOUT(D_DCAM_F7,"QuadletsPerFrame: "<<QuadletsPerFrame);
  BIASDOUT(D_DCAM_F7,"QuadletsPerPacket: "<<QuadletsPerPacket);
  BIASDOUT(D_DCAM_F7,"Resulting theoretical fps: "
      <<1000/((float)CyclesPerFrame * 0.125));
  BpP = QuadletsPerPacket * 4;
  if (BpP < MinBpP_)
    BytesPerPacket_ = MinBpP_;
  else if (BpP > MaxBpP_)
    BytesPerPacket_ = MaxBpP_;
  else
    BytesPerPacket_ = BpP;

  return 0;
}

int
VideoSource_DCAM::ApplyBytesPerPacket()
{
  /*
   unsigned int realbpp;

   dc1394_set_format7_byte_per_packet(IEEE1394Handle_[IEEE1394Card_],
   DcamNodes_[SelectedCam_],
   MODE_FORMAT7_0,BytesPerPacket_);
   usleep(10000);
   dc1394_query_format7_byte_per_packet(IEEE1394Handle_[IEEE1394Card_],
   DcamNodes_[SelectedCam_],
   DcamMode_, &realbpp);

   TransmissionTime_ =(int) (((Width_*Height_*ColorChannels_)/realbpp) * 0.125);
   BIASDOUT(D_DCAM_F7,"requested BpP: "<< BytesPerPacket_ <<" got BpP: "<<realbpp
   <<" TransmissionTime_: "<<TransmissionTime_<<" ms")
   BytesPerPacket_ = realbpp;
   */
  BIASERR("VideoSource_DCAM::ApplyBytesPerPacket(): Sorry, not implemented");
  return -1;
}

int
VideoSource_DCAM::InitCam()
{
  BIASDOUT(D_DCAM,"VideoSource_DCAM::InitCam("<<SelectedCam_<<")");

  // Set camera per default to firewire B, if capable
  if (TryFirewireB_)
    {
      if (camera->bmode_capable)
        {

          dc1394_video_set_operation_mode(camera, DC1394_OPERATION_MODE_1394B);
          dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_800);
          BIASDOUT(D_DCAM,"Set cam to Firewire B");

        }
      else
        {
          // set speed to 400
          dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_400);
        }
    }
  else
    {
      dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_400);
      if (CamModel_ == CAMERA_SONY_DFW_X700)
        sleep(1);
    }

  if (!DirectF7_)
    {

      if (Width_ != 0 || Height_ != 0 || UseBinning_)
        {
          // try to get user settings
          if (UserSizeToMode() < 0)
            {
              BIASERR("UserSizeToMode() failed, trying to find default values");
              //return -1;
              SelectDefault();
            }

        }
      else
        {
          // select default settings for cam
          if (UserMode_)
            {
              cout << "\n\tSetting mode from User\n\n" << endl;
              // get width and height from video mode.
              uint32_t w, h;
              dc1394_get_image_size_from_video_mode(camera, DcamMode_, &w, &h);
              Width_ = (int) w;
              Height_ = (int) h;
              SetColorFromMode_(DcamMode_);
              dc1394framerates_t frameRates =
                  CameraFramerates_[DC1394_VIDEO_MODE_MAX - DcamMode_];
              //cout<<"Mode: "<<DcamMode_<<" DC1394_FRAMERATE_NUM:"<<DC1394_FRAMERATE_NUM<<endl;
              //cout<<"Struct says:"<<frameRates.num<<endl;
              DcamFps_
                  = (dc1394framerate_t) (frameRates.framerates[frameRates.num
                      - 1]);
              //         for(int i=0;i<DC1394_FRAMERATE_NUM;i++)
              //           cout<<"frameRates:"<<frameRates.framerates[i]<<",";
              //         cout<<endl;
              cout << "DcamFps_: " << DcamFps_ << endl;
            }
          else
            {
              SelectDefault();
            }
        }
      // set mode
      if (dc1394_video_set_mode(camera, DcamMode_) != DC1394_SUCCESS)
        {
          BIASERR("Unable to set default mode for camera");
          return -1;
        }
      if (CamModel_ == CAMERA_SONY_DFW_X700)
        sleep(1);

      if (DcamMode_ < DC1394_VIDEO_MODE_FORMAT7_MIN)
        {

          // set framerate

          // try to get user framerate
          if (FramesPerSecond_ != 0.0)
            {
              float fps = FramesPerSecond_;
              dc1394framerate_t videoframerate = DC1394_FRAMERATE_MIN;

              // set video frame rate from param file
              if (fps <= 1.875)
                videoframerate = DC1394_FRAMERATE_1_875;
              else if (fps <= 3.75)
                videoframerate = DC1394_FRAMERATE_3_75;
              else if (fps <= 7.5)
                videoframerate = DC1394_FRAMERATE_7_5;
              else if (fps <= 15.0)
                videoframerate = DC1394_FRAMERATE_15;
              else if (fps <= 30.0)
                videoframerate = DC1394_FRAMERATE_30;
              else if (fps <= 60.0)
                videoframerate = DC1394_FRAMERATE_60;
              else if (fps <= 120.0)
                videoframerate = DC1394_FRAMERATE_120;
              else if (fps <= 240.0)
                videoframerate = DC1394_FRAMERATE_240;

              // try to set user framerate
              if (videoframerate > DcamFps_)
                {
                  videoframerate = DcamFps_;
                }
              if (dc1394_video_set_framerate(camera, videoframerate)
                  != DC1394_SUCCESS)
                {
                  BIASERR("Failed to set user frame rate, setting default");
                  dc1394_video_set_framerate(camera, DcamFps_);
                }
            }
          else
            {
              if (dc1394_video_set_framerate(camera, DcamFps_)
                  != DC1394_SUCCESS)
                {
                  BIASERR("Failed to set default framerate");
                  return -1;
                }
              cout << "Set default framerate" << endl;
            }
        }
      else if (DcamMode_ < DC1394_VIDEO_MODE_FORMAT7_MAX)
        {
          // format 7 if autodetected
          // set bytes per packet
          // TODO: Implement autoselcted format 7
          BIASERR("Autoselected Format 7 yet not implemented");
          return -1;
          // set mode
        }

    } //end !DirectF7_
  else
    {
      // set requested format 7 mode
      if (dc1394_video_set_mode(camera, DcamMode_) != DC1394_SUCCESS)
        {
          BIASERR("Failed to set user requested format 7 mode");
          return -1;
        }
      dc1394_format7_set_image_size(camera, DcamMode_, Width_, Height_);
      cout << "Left: " << Left_ << ", Top: " << Top_ << endl;
      // set size and left top
      dc1394_format7_set_image_position(camera, DcamMode_, Left_, Top_);
      dc1394_format7_set_color_coding(camera, DcamMode_, f7ColorCoding_);
      SetColorFromMode_(DcamMode_);

      // set bytes per packet
      uint32_t bpp;
      if (BytesPerPacket_ == 0)
        {
          dc1394_format7_get_recommended_packet_size(camera, DcamMode_, &bpp);
        }
      else
        {
          bpp = BytesPerPacket_;
        }
      BIASDOUT(D_DCAM,"Set Bytes per packet to: " << bpp);
      dc1394_format7_set_packet_size(camera, DcamMode_, bpp);
    }

  // init capture mode of cam
  const int sizeInternCamBuff = NUM_DMA_BUFFERS;

  err = dc1394_capture_setup(camera, sizeInternCamBuff,
                             DC1394_CAPTURE_FLAGS_DEFAULT);
  if (CamModel_ == CAMERA_SONY_DFW_X700)
    sleep(1);

  // try to reset camera
  if (err != DC1394_SUCCESS)
    {
      dc1394_reset_bus(camera);
      err = dc1394_capture_setup(camera, sizeInternCamBuff,
                                 DC1394_CAPTURE_FLAGS_DEFAULT);
    }

  if (err == DC1394_SUCCESS)
    {
      BIASDOUT(D_DCAM,"Initialization successful");
    }
  else
    {
      BIASDOUT(D_DCAM,"Initialization failed");
      return -1;
    }

  // here we have to test, if there is really some pic from cam, or if it is to slow...
  // this is possible because firewire b cams can be put on firewire a bus.

  //dc1394_video_set_transmission(camera, DC1394_ON);
  //cout << "set transmission ON" << endl;
  //dc1394video_frame_t * frame;
  //
  //err = dc1394_capture_dequeue(camera,DC1394_CAPTURE_POLICY_POLL,&frame);
  //cout << "dequeued frame with code: " << err << endl;
  //sleep(5);
  //dc1394_capture_enqueue(camera,frame);
  //cout << "gave frame back" << endl;
  //
  //
  //dc1394_video_set_transmission(camera,DC1394_OFF);
  //cout << "stopped transmission" << endl;
  //
  //if(err != DC1394_SUCCESS){
  //dc1394_capture_stop(camera);
  //cout << "stopped camera" << endl;
  //  cout << "set speed down" << endl;
  //  dc1394_video_set_operation_mode( camera, DC1394_OPERATION_MODE_LEGACY );
  //  dc1394_video_set_iso_speed( camera, (dc1394speed_t)(DC1394_ISO_SPEED_400) );
  //  dc1394_capture_setup(camera, sizeInternCamBuff, DC1394_CAPTURE_FLAGS_DEFAULT);
  //}


  //  dc1394_video_set_transmission( camera, DC1394_ON );
  //  dc1394video_frame_t * frame;
  //  bool capturing = false;
  //  while(!capturing){
  //    // try 10 times to get an image
  //    for(int i = 0; i < 10; i++){
  //      err = dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_POLL, &frame);
  //      //cout << "Errorcode: " << err << endl;
  //      if(err == DC1394_SUCCESS){
  //        capturing = true;
  //        dc1394_video_set_transmission( camera, DC1394_OFF );
  //        i = 10;
  //        //cout << "captured pic successfully" << endl;
  //      }
  //      dc1394_capture_enqueue(camera,frame);
  //
  //      if(i == 9 && err == DC1394_FAILURE){
  //        // try to set speed down
  //        cout << "Setting speed down" << endl;
  //        dc1394_video_set_transmission( camera, DC1394_OFF );
  //        dc1394_capture_stop(camera);
  //        dc1394_video_set_operation_mode( camera, DC1394_OPERATION_MODE_LEGACY );
  //        err = dc1394_video_set_iso_speed( camera, (dc1394speed_t)(DC1394_ISO_SPEED_400) );
  //        dc1394_capture_setup(camera, sizeInternCamBuff, DC1394_CAPTURE_FLAGS_DEFAULT);
  //        dc1394_video_set_transmission( camera, DC1394_ON );
  //        i = 0;
  //      }
  //      //cout << "test" << endl;
  //      usleep(100000);
  //    }
  //  }

  CompleteInitialized_ = true;
  //cout << "did init" << endl;
  return ActivateExternalTrigger_(bExternalTrigger_);
}


void
VideoSource_DCAM::SetExternalTrigger(bool trigger){
    BIAS::VideoSource::SetExternalTrigger(trigger);
    if( CompleteInitialized_){
        ActivateExternalTrigger_(bExternalTrigger_);
    }
}

int
VideoSource_DCAM::AutoMode(dc1394feature_t feature, dc1394feature_mode_t mode)
{
  if (dc1394_feature_set_mode(camera, feature, mode) != DC1394_SUCCESS)
    {
      BIASERR("VideoSource_DCAM::AutoMode(): failed to set feature auto mode");
      return -1;
    }

  return 0;

}
void
VideoSource_DCAM::SetAutoShutter(bool b)
{
  dc1394feature_mode_t mode;
  if (b)
    mode = DC1394_FEATURE_MODE_AUTO;
  else
    mode = DC1394_FEATURE_MODE_MANUAL;

  AutoMode(DC1394_FEATURE_SHUTTER, mode);
}
bool
VideoSource_DCAM::GetAutoShutter()
{
  dc1394feature_mode_t mode;
  if (dc1394_feature_get_mode(camera, DC1394_FEATURE_SHUTTER, &mode)
      == DC1394_SUCCESS)
    {
      if (DC1394_FEATURE_MODE_AUTO == mode)
        return true;
    }
  return false;
}


void
VideoSource_DCAM::
SetAutoBrightness(bool brightness){
    dc1394feature_mode_t mode;
    if (brightness)
        mode = DC1394_FEATURE_MODE_AUTO;
    else
        mode = DC1394_FEATURE_MODE_MANUAL;
    AutoMode(DC1394_FEATURE_BRIGHTNESS, mode);
}

bool
VideoSource_DCAM::
GetAutoBrightness(){
    dc1394feature_mode_t mode;
    if (dc1394_feature_get_mode(camera, DC1394_FEATURE_BRIGHTNESS, &mode)
            == DC1394_SUCCESS)
    {
        if (DC1394_FEATURE_MODE_AUTO == mode)
            return true;
    }
    return false;
}

void
VideoSource_DCAM::SetAutoGain(bool gain)
{
  dc1394feature_mode_t mode;
  if (gain)
    mode = DC1394_FEATURE_MODE_AUTO;
  else
    mode = DC1394_FEATURE_MODE_MANUAL;
  AutoMode(DC1394_FEATURE_GAIN, mode);
}

bool
VideoSource_DCAM::GetAutoGain()
{
    dc1394feature_mode_t mode;
    if (dc1394_feature_get_mode(camera, DC1394_FEATURE_GAIN, &mode)
            == DC1394_SUCCESS)
    {
        if (DC1394_FEATURE_MODE_AUTO == mode)
            return true;
    }
    return false;
}

int
VideoSource_DCAM::OnePushAuto(dc1394feature_t feature)
{
  dc1394error_t res;
  if (CamModel_ == CAMERA_PTGREY_DRAGONFLY_COLOR && feature
      == DC1394_FEATURE_WHITE_BALANCE)
    {
      SoftwareWhiteBalance();
    }
  else
    {
      res = dc1394_feature_set_mode(camera, feature,
          DC1394_FEATURE_MODE_ONE_PUSH_AUTO);

      if (res != DC1394_SUCCESS)
        {
          BIASERR("VideoSource_DCAM::OnePushAuto()");
          return -1;
        }
    }

  return 0;
}

bool
VideoSource_DCAM::OnePushRunning(dc1394feature_t feature)
{

  dc1394error_t res;
  dc1394feature_mode_t mode;
  res = dc1394_feature_get_mode(camera, feature, &mode);
  if (res != DC1394_SUCCESS)
    return -1;

  if (mode == DC1394_FEATURE_MODE_ONE_PUSH_AUTO)
    {
      return true;
    }
  else
    return false;
}

int
VideoSource_DCAM::ActivateExternalTrigger_(bool trigger)
{
  dc1394error_t res;
  if (trigger)
    {
      Trigger_ = DC1394_TRIGGER_MODE_0;
      BIASDOUT(D_DCAM,"Triggermode: 1 (extern)");
      res = dc1394_external_trigger_set_power(camera, DC1394_ON);
    }
  else
    {
      Trigger_ = DC1394_TRIGGER_MODE_3;
      BIASDOUT(D_DCAM,"Triggermode: 3  (intern)");
      // fix for sony not supporting trigger modes correctly
      if (CamModel_ != CAMERA_SONY_DFW_X700) {
          res = dc1394_external_trigger_set_power(camera, DC1394_OFF);
        }
    }

  // fix for sony not supporting trigger modes correctly
  if (CamModel_ != CAMERA_SONY_DFW_X700 || Trigger_ != DC1394_TRIGGER_MODE_3) {
    res = dc1394_external_trigger_set_mode(camera, Trigger_);
    return res;
  } else {
    return 0;
  }
  if (res != DC1394_SUCCESS)
    {
      BIASERR("unable to set camera "<<ID_<<" to trigger mode ");
      return -1;
    }

  return 0;

}

unsigned int
VideoSource_DCAM::GetFeature(dc1394feature_t feature)
{

  dc1394bool_t isPresent;
  dc1394_feature_is_present(camera, feature, &isPresent);
  unsigned int value;
  if (isPresent)
    {
      dc1394_feature_get_value(camera, feature, &value);
    }
  else
    {
      BIASERR("Feature  not supported by camera "<<ID_);BIASASSERT(false);
      return -1;
    }

  return value;
}

int
VideoSource_DCAM::SetFeature(dc1394feature_t feature, unsigned int value)
{
  dc1394bool_t isPresent;
  dc1394_feature_is_present(camera, feature, &isPresent);

  if (isPresent)
    {
        dc1394feature_mode_t mode = DC1394_FEATURE_MODE_MANUAL;
        AutoMode(feature, mode);
      dc1394_feature_set_value(camera, feature, value);
    }
  else
    {
      BIASERR("Feature  not supported by camera "<<ID_);
      return -1;
    }

  return 0;
}

int
VideoSource_DCAM::SetLeftTop(unsigned int left, unsigned int top)
{
  if (left <= (MaxWidth_ - Width_) && top <= (MaxHeight_ - Height_))
    {
      Top_ = top;
      Left_ = left;
      UserTopLeft_ = true;
    }
  else
    {
      BIASERR("VideoSource_DCAM::SetLeftTop() values too large:"<<left<<"x"<<top);
      return -1;
    }

  return 0;
}

// exptime is given in milliseconds (one thousand of a second)
int
VideoSource_DCAM::SetShutter(float exptime)
{
  dc1394feature_t feature = DC1394_FEATURE_SHUTTER;
  int value = 0;
  switch (CamModel_)
    {
  case CAMERA_SONY_DFW_X700:
    if ((exptime <= 16.05120063) && (exptime >= 0.13376))
      value = 2049 - int(round(exptime * 28636363.0 / (1197.0 * 800.0 * 2.0)));
    else if ((exptime <= 0.13376) && (exptime > 0.067))
      {
        value = 2048;
      }
    else if ((exptime <= 0.067) && (exptime >= 0.00012))
      {
        value = (int) (2848.4 - round(28636363.0 * exptime / (1197.0 * 2.0)));
      }
    else if ((exptime <= 0.00012) && (exptime >= 0.00004))
      {
        value = 2848;
      }
    else
      {
        BIASERR("Exposuretime out of bounds: "<<exptime);
        return -1;
      }
    break;
  case CAMERA_SONY_DFW_V500:
    if (exptime <= 5.0 && exptime >= (1.0 / 30))
      value = 0x800 - (int) (30 * exptime);
    else if (exptime < (1.0 / 30) && exptime >= (1.0 / 10000.0))
      value = (int) (2573.6 - 15734.3 * exptime);
    else
      {
        BIASERR("Exposuretime out of bounds: "<<exptime);
        return -1;
      }
    break;
  case CAMERA_PTGREY_DRAGONFLY_BW:
  case CAMERA_PTGREY_SCORPION_COLOR_1600:
  case CAMERA_PTGREY_DRAGONFLY_HIRES:
  case CAMERA_PTGREY_DRAGONFLY_COLOR:
  case CAMERA_PTGREY_DRAGONFLY2_COLOR_HIRES:
  case CAMERA_PTGREY_FIREFLY_BW:
  case CAMERA_PTGREY_FIREFLY_COLOR:
  case CAMERA_PTGREY_GRASSHOPPER_COLOR:
  case CAMERA_PTGREY_FLEA2_BW:
  case CAMERA_PTGREY_BUMBLEBEE_XB3:
  case CAMERA_PTGREY_BUMBLEBEE_XB2:
     dc1394_feature_set_absolute_control(camera, feature, DC1394_ON);
    //these are microseconds
    dc1394_feature_set_absolute_value(camera, feature, exptime);
    //cout<<"`olute shutter value:"<<exptime<<endl;
    return 0;
    break;
  case CAMERA_UNIBRAIN_FIREI:
    // map [1,99] ms to range [0,7]
    value = rint((1000.0*exptime) / 99.0*7.0);
    break;
  case CAMERA_KAMERAWERK_DRESDEN_LOGILUX_I5:
    value = rint(exptime*1000.0);
    break;
  default:
    BIASERR("Sorry your Camera Model:"<<CamModel_<<" is not supported.");
    value = -1;
  }

  if (value > 0)
    return SetFeature(DC1394_FEATURE_SHUTTER, value);
  else
    return -1;

  return 0;
}

float
VideoSource_DCAM::GetShutter()
{
  float exptime = 0.0;
  int shutter = GetFeature(DC1394_FEATURE_SHUTTER);

  switch (CamModel_)
    {
  // see technical ,manual. p. 27 (JW)
  case CAMERA_SONY_DFW_X700:
    if (shutter < 2048)
      exptime = ((float) (2048 - shutter + 1) * (1197.0 * 800.0 * 2.0)
          / (28.636363 * 1000000.0));
    else
    // OK, linear dependency to intensity (apetersen, jw 11/2004)
    if (shutter < 2848)
      exptime = ((2848.4 - float(shutter)) * (1197.0 * 2.0) / (28.636363
          * 1000000.0));
    else
      exptime = 50.0 / 1000000.0;
    break;
  case CAMERA_SONY_DFW_V500:
    if (shutter < 0x800)
      exptime = ((float) (shutter - 2048) / 30.0);
    else
      exptime = ((float) (shutter - 2573.6) / -15734.3);
    break;
  case CAMERA_PTGREY_DRAGONFLY_BW:
  case CAMERA_PTGREY_SCORPION_COLOR_1600:
  case CAMERA_PTGREY_DRAGONFLY_HIRES:
  case CAMERA_PTGREY_DRAGONFLY_COLOR:
  case CAMERA_PTGREY_DRAGONFLY2_COLOR_HIRES:
  case CAMERA_PTGREY_FIREFLY_BW:
  case CAMERA_PTGREY_FIREFLY_COLOR:
  case CAMERA_PTGREY_GRASSHOPPER_COLOR:
  case CAMERA_PTGREY_FLEA2_BW:
  case CAMERA_PTGREY_BUMBLEBEE_XB3:
  case CAMERA_PTGREY_BUMBLEBEE_XB2:
  default:
    dc1394_feature_get_absolute_value(camera, DC1394_FEATURE_SHUTTER, &exptime);
    break;
  }

  return exptime;
}

int
VideoSource_DCAM::SetGain(float gain) // gain is in dB
{
  dc1394feature_t feature = DC1394_FEATURE_GAIN;

  int res = 0;
  switch (CamModel_)
    {
  case CAMERA_SONY_DFW_X700:
  {
    int min = 0x800;
    int max = 0x8b4;
    int value = min + (int) (gain * (float) (max - min));
    res = SetFeature(feature, value);
    break;
  }
  case CAMERA_SONY_DFW_V500:
  {
    int min = 0x00;
    int max = 0x12;
    int value = min + (int) (gain * (float) (max - min));
    res = SetFeature(feature, value);
    break;
  }
  case CAMERA_UNIBRAIN_FIREI:
  {
    int value = gain * 255.0 / 30.0;
    SetFeature(feature, value);
    break;
  }
  case CAMERA_PTGREY_DRAGONFLY_BW:
  case CAMERA_PTGREY_SCORPION_COLOR_1600:
  case CAMERA_PTGREY_DRAGONFLY_HIRES:
  case CAMERA_PTGREY_DRAGONFLY_COLOR:
  case CAMERA_PTGREY_DRAGONFLY2_COLOR_HIRES:
  case CAMERA_PTGREY_FIREFLY_BW:
  case CAMERA_PTGREY_FIREFLY_COLOR:
  case CAMERA_PTGREY_GRASSHOPPER_COLOR:
  case CAMERA_PTGREY_FLEA2_BW:
  case CAMERA_PTGREY_BUMBLEBEE_XB3:
  case CAMERA_PTGREY_BUMBLEBEE_XB2:
  default:
    dc1394_feature_set_absolute_control(camera, feature, DC1394_ON);
    //cout<<"Setting gain:"<<gain<<endl;
    res = (int)dc1394_feature_set_absolute_value(camera, feature, gain);
    break;
  }
  return res;
}

float
VideoSource_DCAM::GetGain()
{
  float gain = 0.0; // gain is in dB

  switch (CamModel_)
    {
  case CAMERA_SONY_DFW_X700:
        {
            int min = 0x800;
            int max = 0x8b4;
            int value = GetFeature(DC1394_FEATURE_GAIN);
            cout << "Value in GetGain from GetFeature(...) :" << value << endl;
            // translate gain to dB
            gain = (float) (value - min) / (float) (max - min);
        }
    break;
  case CAMERA_SONY_DFW_V500:
    {
        int min = 0x00;
        int max = 0x12;
            int value = GetFeature(DC1394_FEATURE_GAIN);
            cout << "Value in GetGain from GetFeature(...) :" << value << endl;
            // translate gain to dB
            gain = (float) (value - min) / (float) (max - min);
    }
    break;
  case CAMERA_UNIBRAIN_FIREI:
        gain = GetFeature(DC1394_FEATURE_GAIN);
        break;
  case CAMERA_PTGREY_DRAGONFLY_BW:
  case CAMERA_PTGREY_SCORPION_COLOR_1600:
  case CAMERA_PTGREY_DRAGONFLY_HIRES:
  case CAMERA_PTGREY_DRAGONFLY_COLOR:
  case CAMERA_PTGREY_DRAGONFLY2_COLOR_HIRES:
  case CAMERA_PTGREY_FIREFLY_BW:
  case CAMERA_PTGREY_FIREFLY_COLOR:
  case CAMERA_PTGREY_GRASSHOPPER_COLOR:
  case CAMERA_PTGREY_FLEA2_BW:
  case CAMERA_PTGREY_BUMBLEBEE_XB3:
  case CAMERA_PTGREY_BUMBLEBEE_XB2:
  default:
        {
      //dc1394error_t res =
      dc1394_feature_get_absolute_value(camera,DC1394_FEATURE_GAIN, &gain);
            //cout<<"GetGain()"<<gain<<endl;
            break;
        }
  }
  return gain;
}


int
VideoSource_DCAM::
SetBrightness(float brightness){
    dc1394feature_t feature = DC1394_FEATURE_BRIGHTNESS;
  dc1394_feature_set_absolute_control(camera, feature, DC1394_ON);
 // cout<<"Setting brightness:"<<brightness<<endl;
  dc1394error_t res = dc1394_feature_set_absolute_value(camera, feature, brightness);
  return (int)res;
}

float
VideoSource_DCAM::
GetBrightness(){
    float brightness = 0.0; //
    dc1394_feature_get_absolute_value(camera,DC1394_FEATURE_BRIGHTNESS, &brightness);
    //cout<<"Getting brightness:"<<brightness<<endl;
    return brightness;
}

int
VideoSource_DCAM::SetGammaMode(int g)
{
  int res;
  res = SetFeature(DC1394_FEATURE_GAMMA, g); //+128;
  if (res < 0) return res;
  else return 0;
}

int
VideoSource_DCAM::GetGammaMode()
{
  int value;
  value = GetFeature(DC1394_FEATURE_GAMMA);
  return value; // -128; why 128 ??
}

int
VideoSource_DCAM::SetWhiteBalance(float rvalue, float bvalue)
{
  //rvalue and bvalue are in range -0.5 to 0.5
    //cout<<"Setting whiteBalance:"<<endl;
  int ibval = 0, irval = 0;
  switch (CamModel_)
    {
  case CAMERA_SONY_DFW_X700:
  case CAMERA_SONY_DFW_V500:
    // the values for sony cameras are from 0x00 to 0xFF,
    // scale to 0-255 in integer (cmenk)
    ibval = (int) rint((bvalue + 0.5f ) * 255.0f);
    irval = (int) rint((rvalue + 0.5f ) * 255.0f);
    if (ibval > 255)
      ibval = 255;
    if (irval > 255)
      irval = 255;
    if (ibval < 0)
      ibval = 0;
    if (irval < 0)
      irval = 0;
    break;
  case CAMERA_PTGREY_DRAGONFLY_COLOR:
  case CAMERA_PTGREY_DRAGONFLY2_COLOR_HIRES:
    ibval = (unsigned int) rint(bvalue*32) + 32;
    irval = (unsigned int) rint(rvalue*32) + 32;
    if (ibval > 63)
      ibval = 63;
    if (irval > 63)
      irval = 63;
    if (ibval < 0)
      ibval = 0;
    if (irval < 0)
      irval = 0;
    //cerr << irval <<", "<<ibval<<endl;
    break;
  case CAMERA_PTGREY_SCORPION_COLOR_1600:
    ibval = (unsigned int) rint(bvalue*63) + 63;
    irval = (unsigned int) rint(rvalue*63) + 63;
    if (ibval > 127)
      ibval = 127;
    if (irval > 127)
      irval = 127;
    if (ibval < 0)
      ibval = 0;
    if (irval < 0)
      irval = 0;
    //cerr << irval <<", "<<ibval<<endl;
    break;
  case CAMERA_PTGREY_GRASSHOPPER_COLOR://IEEE1394
  default:
    ibval = (unsigned int) rint(bvalue*512) + 512;
    irval = (unsigned int) rint(rvalue*512) + 512;
    if (ibval > 1023)
      ibval = 1023;
    if (irval > 1023)
      irval = 1023;
    if (ibval < 0)
      ibval = 0;
    if (irval < 0)
        irval = 0;
    //cerr << irval <<", "<<ibval<<endl;
    break;
    }
  if (dc1394_feature_whitebalance_set_value(camera, ibval, irval)== DC1394_SUCCESS)
    return 0;
  else{
    BIASWARN("Could not set white balance, feature not supported by either camera or lib.");
    return -2;
  }
}

int
VideoSource_DCAM::SetCamera(CameraParameterSet camparam)
{
  dc1394feature_mode_t mode;
  int res = 0;

  BIASDOUT(D_DCAM,"Entering SetCamera()");

  if (camparam.AutoShutterChanged)
    {
      if (camparam.AutoShutter)
        mode = DC1394_FEATURE_MODE_AUTO;
      else
        mode = DC1394_FEATURE_MODE_MANUAL;

      res = AutoMode(DC1394_FEATURE_SHUTTER, mode);
      if (res < 0)
        return res;
    }
  if (camparam.AutoGainChanged)
    {
      if (camparam.AutoGain)
        mode = DC1394_FEATURE_MODE_AUTO;
      else
        mode = DC1394_FEATURE_MODE_MANUAL;

      res = AutoMode(DC1394_FEATURE_GAIN, mode);
      if (res < 0)
        return res;
    }
  if (camparam.AutoWhiteBalanceChanged)
    {
      if (camparam.AutoWhiteBalance)
        mode = DC1394_FEATURE_MODE_AUTO;
      else
        mode = DC1394_FEATURE_MODE_MANUAL;

      res = AutoMode(DC1394_FEATURE_WHITE_BALANCE, mode);
      if (res < 0)
        return res;
    }

  if (camparam.ShutterChanged)
    {
      res = SetShutter(camparam.Shutter);
      if (res < 0)
        return res;
    }
  if (camparam.GainChanged)
    {
      res = SetGain(camparam.Gain);
      if (res < 0)
        return res;
    }
  if (camparam.WhiteBalanceChanged)
    {
      res = SetFeature(DC1394_FEATURE_WHITE_BALANCE, camparam.WhiteBalance);
      if (res < 0)
        return res;
    }
  if (camparam.SharpenChanged)
    {
      res = SetFeature(DC1394_FEATURE_SHARPNESS, camparam.Sharpen);
      if (res < 0)
        return res;
    }
  if (camparam.GammaModeChanged)
    {
      res = SetGammaMode(camparam.GammaMode);
      if (res < 0)
        return res;
    }
  if (camparam.OpticalFilterChanged)
    {
      // double the call, to cope with ignorant cams
      res = SetFeature(DC1394_FEATURE_OPTICAL_FILTER, camparam.OpticalFilter);
      res = SetFeature(DC1394_FEATURE_OPTICAL_FILTER, camparam.OpticalFilter);
      if (res < 0)
        return res;
    }
  if (camparam.WhiteBalanceOnePush)
    {
      res = OnePushAuto(DC1394_FEATURE_WHITE_BALANCE);
      if (res < 0)
        return res;
    }

  return res;
}

CameraModel
VideoSource_DCAM::GetModelForEuid(const u_int64_t euid)
{
  unsigned int vendor = euid >> 40;
  unsigned int model = (euid >> 12) & 0xFF;
  unsigned int model_lo = (euid) & 0xFFF;
  BIASDOUT(D_DCAM,"EUID:"<<hex<<euid<<" vendorid: "<<vendor<<" modelid: "<<model<<dec);
  cout << "EUID:" << hex << euid << " vendorid: " << vendor << " modelid: "
      << model << dec << endl;

  switch (vendor)
    {
  // Sony
  case 0x080046:
    {
      BIASDOUT(D_DCAM,"Vendor: Sony");
      switch (model)
        {
      case 0x20:
        // BytesPerPixel_ = 1.0;
        // ColorMode_ = ImageBase::CM_UYVY422;
        return CAMERA_SONY_DFW_V500;
      case 0x60:
        // BytesPerPixel_ = 1.0;
        // ColorMode_ = ImageBase::CM_UYVY422;
        return CAMERA_SONY_DFW_X700;
      default:
        return CAMERA_UNKNOWN;
        }
    }
  case 0x00b09d: // PtGey
    {
      BIASDOUT(D_DCAM,"Vendor: PointGrey Research");
      //cout<<"Model is: "<<model<<endl;
      switch (model)
        {
      case 0xcc:
        BIASDOUT(D_DCAM,"Model: Dragonfly BW LowRes")
        ;
        // ColorMode_ = ImageBase::CM_Grey;
        // Shift16_ = 6; // 16 bits - 10 significant bits
        return CAMERA_PTGREY_DRAGONFLY_BW;
      case 0x4c:
        BIASDOUT(D_DCAM,"Model: Dragonfly Color LowRes")
        ;
        //  ColorMode_ = ImageBase::CM_Bayer_RGGB;
        // Shift16_ = 6; // 16 bits - 10 significant bits
        return CAMERA_PTGREY_DRAGONFLY_COLOR;
      case 0xff:
      case 0xfe:
        BIASDOUT(D_DCAM,"Model: Dragonfly B&W HiRes")
        ;
        // ColorMode_ = ImageBase::CM_Grey;
        Shift16_ = 6; // 16 bits - 10 significant bits
        return CAMERA_PTGREY_DRAGONFLY_HIRES;
      case 0xf5:
      case 0x28:
        BIASDOUT(D_DCAM,"Model: Scorpion Color 1600")
        ;
        //  ColorMode_ = ImageBase::CM_Bayer_GBRG;
        // ok, RGGB seems to be right, but did it changed ? friso
        //   ColorMode_ = ImageBase::CM_Bayer_RGGB;
        // Shift16_ = 4; // 16 bits - 12 significant bits

        return CAMERA_PTGREY_SCORPION_COLOR_1600;
      case 0x18:
        BIASDOUT(D_DCAM,"Model: FireFly Color")
        ;
        //    ColorMode_ = ImageBase::CM_Bayer_GBRG;
        return CAMERA_PTGREY_FIREFLY_COLOR;
      case 0x16:
        BIASDOUT(D_DCAM,"Model: FireFly BW") ;
        //ColorMode_ = ImageBase::CM_Grey;
        return CAMERA_PTGREY_FIREFLY_BW;
      case 0xfb:
        if (model_lo == 0x355)
          {
            BIASDOUT(D_DCAM,"Model: GrassHopper Color");
            //           ColorChannels_ = 3;
            //           ColorMode_ = ImageBase::CM_RGB;
            //    ColorChannels_ = 2;
            //         ColorMode_ = ImageBase::CM_UYVY422;
            return CAMERA_PTGREY_GRASSHOPPER_COLOR;
          }
        else
          {
            BIASDOUT(D_DCAM,"Model: DragonFly2 HIRES Color");
            //          ColorChannels_ = 3;
            //          ColorMode_ = ImageBase::CM_RGB;
            return CAMERA_PTGREY_DRAGONFLY2_COLOR_HIRES;
          }
      case 0x7:
      case 0xb2:
      case 0xc1:
        //     ColorChannels_ = 3;
        //         ColorMode_ = ImageBase::CM_Bayer_RGGB ;
        //     cout<<"VS: PTGH:"<<endl;
        //         BIASDOUT(D_DCAM,"Model: PtGrey GrassHopper Color");
        return CAMERA_PTGREY_GRASSHOPPER_COLOR;
      case 0x9:
        ColorChannels_ = 3;
        //        ColorMode_ = ImageBase::CM_RGB;
        BIASDOUT(D_DCAM,"Model: PtGrey FLEA2 BW")
        ;
        return CAMERA_PTGREY_FLEA2_BW;
      case 0xcf:
        ColorChannels_ = 3;
        //        ColorMode_ = ImageBase::CM_Bayer_GBRG;
        BIASDOUT(D_DCAM,"Model: PtGrey Bumblebee XB3")
        ;
        return CAMERA_PTGREY_BUMBLEBEE_XB3;
      case 0x14:
        ColorChannels_ = 2;
        //        ColorMode_ = ImageBase::CM_Bayer_GBRG;
        BIASDOUT(D_DCAM,"Model: PtGrey Bumblebee XB2")
        ;
        return CAMERA_PTGREY_BUMBLEBEE_XB2;
      default:
        BIASDOUT(D_DCAM,"Model: Unknown:"<<model)
        ;
        return CAMERA_UNKNOWN;
        }
    }
  case 0x081443:
    {// UniBrain
      BIASDOUT(D_DCAM,"Vendor: Unibrain");

      switch (model)
        {
      case 0x37:
      case 0x30:
        BIASDOUT(D_DCAM,"Model: Fire-i")
        ;
        //      ColorMode_ = ImageBase::CM_RGB;
        //  ColorChannels_ = 3;
        return CAMERA_UNIBRAIN_FIREI;
      default:
        cout << "Unknown modelid: 0x" << hex << model << endl;
        }
    }
  case 0x97e:
    {
      BIASDOUT(D_DCAM,"Vendor: NET Gmbh");
      switch (model)
        {
      case 0x0:
        return CAMERA_NET_FO323SC;
        }
    }
    break;
  case 0xb02a:
    {
      switch (model)
        {
        case 0x20:
          return CAMERA_KAMERAWERK_DRESDEN_LOGILUX_I5;
        }
    }
    break;
    // unknown vendorid
  default:
    return CAMERA_UNKNOWN;
    }

  return CAMERA_UNKNOWN;

}
/*
 void VideoSource_DCAM::PrintFormatAndMode_()
 {
 //   cout <<"Internal Format: "<<DcamFormat_<<" Mode: "<< DcamMode_<<endl;
 int f = DcamFormat_ - FORMAT_VGA_NONCOMPRESSED;
 int m=0;
 switch (f) {
 case 0: m = DcamMode_ - MODE_FORMAT0_MIN; break;
 case 1: m = DcamMode_ - MODE_FORMAT1_MIN; break;
 case 2: m = DcamMode_ - MODE_FORMAT2_MIN; break;
 case 7: m = DcamMode_ - MODE_FORMAT7_MIN; break;
 }
 cout <<"Format: "<<f<<" Mode: "<<m;

 }
 */
int
VideoSource_DCAM::UserSizeToFormat7_()
{

  cout << "Width: " << Width_ << "UnitWidth: " << UnitWidth_ << endl;
  if ((unsigned int) Width_ % UnitWidth_ > 0)
    {
      BIASERR("VideoSource_DCAM::UserSizeToMode(): width of "<<Width_
          <<" not multiple of: "<<UnitWidth_);
      return -1;
    }
  if ((unsigned int) Height_ % UnitHeight_ > 0)
    {
      BIASERR("VideoSource_DCAM::UserSizeToMode(): height of "<<Height_
          <<" not multiple of: "<<UnitHeight_);
      return -1;
    }
  if (!UseBinning_)
    {
      DcamMode_ = DC1394_VIDEO_MODE_FORMAT7_0;
      //DcamFormat_ = FORMAT_SCALABLE_IMAGE_SIZE;
      if (!UserTopLeft_)
        {
          Left_ = (MaxWidth_ - Width_) / 2;
          Top_ = (MaxHeight_ - Height_) / 2;
        }
      BIASDOUT(D_DCAM_F7,"Using format7: "<<Width_<<"x"<<Height_<<"+"<<Left_
          <<"+"<<Top_);
    }
  else
    { // Binning for PtGrey Dragonfly
      BIASDOUT(D_DCAM_F7,"Using format7 Mode 1 (Binning): "<<Width_<<"x"<<Height_
          <<"+"<<Left_<<"+"<<Top_);
      DcamMode_ = DC1394_VIDEO_MODE_FORMAT7_1;
      // DcamFormat_ = FORMAT_SCALABLE_IMAGE_SIZE;
      ColorChannels_ = 1;
    }

  return 0;
}

int
VideoSource_DCAM::SetColorFromMode_(dc1394video_mode_t videoMode)
{
  dc1394color_coding_t colorCoding;
  dc1394color_filter_t colorFilter; //Bayer Pattern
  if (!DirectF7_)
    {
      dc1394_get_color_coding_from_video_mode(camera, videoMode, &colorCoding);
    }
  else
    {
      colorCoding = f7ColorCoding_;
      dc1394error_t res = dc1394_format7_get_color_filter(camera, videoMode, &colorFilter);
      if (res != DC1394_SUCCESS) {
//        if (res == DC1394_FUNCTION_NOT_SUPPORTED) {
//          known problem with dragonfly low res color camera, fkellner 07/11
//        }
        BIASWARN("Camera did not report a valid color filter, assuming RGGB");
        colorFilter = DC1394_COLOR_FILTER_RGGB;
      }
    }

  // cout << "Color Coding: " << colorCoding << endl;
  // select BIAS Colormodel
  switch (colorCoding)
    {
  case DC1394_COLOR_CODING_MONO8:
    ColorMode_ = ImageBase::CM_Grey;
    ColorChannels_ = 1;
    break;

  case DC1394_COLOR_CODING_YUV411:
    ColorMode_ = ImageBase::CM_YUV411;
    ColorChannels_ = 1;
    break;

  case DC1394_COLOR_CODING_YUV422:
    ColorChannels_ = 2;
    ColorMode_ = ImageBase::CM_UYVY422;
    break;

  case DC1394_COLOR_CODING_YUV444:
    ColorChannels_ = 1;
    ColorMode_ = ImageBase::CM_YUV444;
    break;

  case DC1394_COLOR_CODING_RGB8:
    ColorChannels_ = 3;
    ColorMode_ = ImageBase::CM_RGB;
    break;

  case DC1394_COLOR_CODING_RGB16:
    ColorChannels_ = 3;
    BytesPerPixel_ = 2.0;
    ColorMode_ = ImageBase::CM_RGB;
    break;

  case DC1394_COLOR_CODING_MONO16:
    ColorChannels_ = 1;
    ColorMode_ = ImageBase::CM_Grey;
    BytesPerPixel_ = 2.0;
    break;

  case DC1394_COLOR_CODING_RAW8:
     if(colorFilter == DC1394_COLOR_FILTER_RGGB)
         ColorMode_ = ImageBase::CM_Bayer_RGGB;
     else if(colorFilter == DC1394_COLOR_FILTER_GBRG)
         ColorMode_ = ImageBase::CM_Bayer_GBRG;
     else if(colorFilter == DC1394_COLOR_FILTER_GRBG)
         ColorMode_ = ImageBase::CM_Bayer_GRBG;
     else if(colorFilter == DC1394_COLOR_FILTER_BGGR)
         ColorMode_ = ImageBase::CM_Bayer_BGGR;
      ColorChannels_ = 1;
      break;

  case DC1394_COLOR_CODING_RAW16:
     if(colorFilter == DC1394_COLOR_FILTER_RGGB)
         ColorMode_ = ImageBase::CM_Bayer_RGGB;
     else if(colorFilter == DC1394_COLOR_FILTER_GBRG)
         ColorMode_ = ImageBase::CM_Bayer_GBRG;
     else if(colorFilter == DC1394_COLOR_FILTER_GRBG)
         ColorMode_ = ImageBase::CM_Bayer_GRBG;
     else if(colorFilter == DC1394_COLOR_FILTER_BGGR)
         ColorMode_ = ImageBase::CM_Bayer_BGGR;
     ColorChannels_ = 1;
     BytesPerPixel_ = 2.0;
      break;

  default:
    ColorChannels_ = 1;
    ColorMode_ = ImageBase::CM_Grey;
    }

  //
  //DC1394_COLOR_CODING_MONO16S,
  // DC1394_COLOR_CODING_RGB16S,
  return 0;
}

std::string VideoSource_DCAM::
VideoModeToString(dc1394video_mode_t mode){
  string s;
  switch(mode){
  case DC1394_VIDEO_MODE_160x120_YUV444:
    s = "160 x 120, YUV444";
    break;
  case DC1394_VIDEO_MODE_320x240_YUV422:
    s = "320 x 240, YUV422";
    break;
  case DC1394_VIDEO_MODE_640x480_YUV411:
    s = "640 x 480, YUV411";
    break;
  case DC1394_VIDEO_MODE_640x480_YUV422:
    s = "640 x 480, YUV422";
    break;
  case   DC1394_VIDEO_MODE_640x480_RGB8:
    s = "640 x 480, RGB";
    break;
  case      DC1394_VIDEO_MODE_640x480_MONO8:
    s = "640 x 480, Mono8";
    break;
  case      DC1394_VIDEO_MODE_640x480_MONO16:
    s = "640 x 480, Mono16";
    break;
  case DC1394_VIDEO_MODE_800x600_YUV422:
    s = "800 x 600, YUV422";
    break;
  case    DC1394_VIDEO_MODE_800x600_RGB8:
    s = "800 x 600, RGB";
    break;
  case    DC1394_VIDEO_MODE_800x600_MONO8:
    s = "800 x 600, Mono8";
    break;
  case DC1394_VIDEO_MODE_800x600_MONO16:
    s = "800 x 600, Mono16";
    break;
  case DC1394_VIDEO_MODE_1024x768_YUV422:
    s = "1024 x 768, YUV442";
    break;
  case DC1394_VIDEO_MODE_1024x768_RGB8:
    s = "1024 x 768, RGB";
    break;
  case DC1394_VIDEO_MODE_1024x768_MONO8:
    s = "1024 x 768, Mono8";
    break;
  case DC1394_VIDEO_MODE_1024x768_MONO16:
    s = "1024 x 768, Mono16";
    break;
  case DC1394_VIDEO_MODE_1280x960_YUV422:
    s = "1280 x 960, YUV422";
    break;
  case DC1394_VIDEO_MODE_1280x960_RGB8:
    s = "1280 x 960, RGB";
    break;
  case DC1394_VIDEO_MODE_1280x960_MONO8:
    s = "1280 x 960, Mono8";
    break;
  case DC1394_VIDEO_MODE_1280x960_MONO16:
    s = "1280 x 960, Mono16";
    break;
  case DC1394_VIDEO_MODE_1600x1200_YUV422:
    s = "1600 x 1200, YUV422";
    break;
  case DC1394_VIDEO_MODE_1600x1200_RGB8:
    s = "1600 x 1200, RGB";
    break;
  case DC1394_VIDEO_MODE_1600x1200_MONO8:
    s = "1600 x 1200, Mono8";
    break;
  case DC1394_VIDEO_MODE_1600x1200_MONO16:
    s = "1600 x 1200, Mono16";
    break;
  case DC1394_VIDEO_MODE_FORMAT7_0:
    s = "Format7 0";
    break;
  case DC1394_VIDEO_MODE_FORMAT7_1:
    s = "Format7 1";
    break;
  case DC1394_VIDEO_MODE_FORMAT7_2:
    s = "Format7 2";
    break;
  case DC1394_VIDEO_MODE_FORMAT7_3:
    s = "Format7 3";
    break;
  case DC1394_VIDEO_MODE_FORMAT7_4:
    s = "Format7 4";
    break;
  case DC1394_VIDEO_MODE_FORMAT7_5:
    s = "Format7 5";
    break;
  case DC1394_VIDEO_MODE_FORMAT7_6:
    s = "Format7 6";
    break;
  case DC1394_VIDEO_MODE_FORMAT7_7:
    s = "Format7 7";
    break;
  default:
    s = "unknown";
  }

  return s;
}