VideoSource_DCAM_CMU.cpp

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

Copyright (C) 2003-2009    (see file CONTACT 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 <Base/Common/BIASpragmaStart.hh>
#include <wtypes.h>
#include <1394Camera.h>
#include <Base/Debug/TimeMeasure.hh>

#include "VideoSource_DCAM.hh"
#include <Base/Image/ImageConvert.hh>
using namespace BIAS;

using namespace std;

int BIAS::ScanBus(vector<CameraInfo> &camInfos) {

  C1394Camera infocam;
  VideoSource_DCAM camdummy;
  int ncams = 0;
  infocam.RefreshCameraList();
  ncams = infocam.GetNumberCameras();

  camInfos.clear();
  for(int i = 0; i < ncams; i++){
    CameraInfo camInfo;

    int select = infocam.SelectCamera(i);

    if(select == CAM_SUCCESS){
      infocam.InitCamera(1);
      cout << "camera max speed: " << infocam.GetMaxSpeed() << endl;
      camInfo.camid = i+1;
      // get vendor and model of camera
      char *vendorChr = new char[256];
      char *modelChr = new char[256];
      int vendorLen = 256;
      int modelLen = 256;

      infocam.GetCameraVendor(vendorChr,vendorLen);
      infocam.GetCameraName(modelChr,modelLen);

      string vendor(vendorChr);
      string model(modelChr);
      delete vendorChr;
      delete modelChr;

      camInfo.model = model;
      camInfo.vendor = vendor;

      cout << model << endl;

      // info about firewire
      if(infocam.Has1394b())
        camInfo.b_capable = true;
      else
        camInfo.b_capable = false;

      if(model == "Scorpion")
        camInfo.b_capable = false;

      // find available modes

      vector<BIAS::dc1394video_mode_t> modesVector;
      vector<vector<float> > framesVector;
      int Format_ =0;
      int Mode_ = 0;
      float FPS_ = 0.0;
      // Get best Mode for Camera
      for (int i=0; i<8; i++)
      {
        if (infocam.HasVideoFormat(i))
        {
          if(i < 3){
            for (int j=0; j<6; j++)                 // ToDo: No 16-Bits Modes allowed.
            {
              if (infocam.HasVideoMode(i,j))
              {
                modesVector.push_back(camdummy.FormatAndModeToEnum(i,j));
                Format_ = i;
                Mode_   = j;

                // add available framerates
                vector<float> innerFramesVector;
                for (int k=0; k<8; k++)
                {
                  if(infocam.HasVideoFrameRate(Format_,Mode_,k)) {
                    float fr = 0.0;
                    switch (k) {
    case 0:
      fr = 1.875;
      break;

    case 1:
      fr = 3.75;
      break;

    case 2:
      fr = 7.5;
      break;

    case 3:
      fr = 15;
      break;

    case 4:
      fr = 30;
      break;

    case 5:
      fr = 60;
      break;

    case 6:
      fr = 120;
      break;

    case 7:
      fr = 240;
      break;

    default:
      break;
                    }
                    innerFramesVector.push_back(fr);
                  }
                }
                framesVector.push_back(innerFramesVector);
              }
            }
          }else{  // mode is format 7
            for(int j = 0; j < 8; j++){
              if (infocam.HasVideoMode(i,j)){

                //cout << "Format 7 Mode found" << endl;

                infocam.SetVideoFormat(i);
                infocam.SetVideoMode(j);
                C1394CameraControlSize* cs = infocam.GetCameraControlSize();
                unsigned short minbpp,maxbpp,widthMax,heightMax,wUnit,hUnit,bpprec,bppcur;

                cs->GetBytesPerPacketRange(&minbpp,&maxbpp);
                cs->GetSizeLimits(&widthMax,&heightMax);
                cs->GetSizeUnits(&wUnit,&hUnit);
                cs->GetBytesPerPacket(&bppcur,&bpprec);

                cout << "Min Bpp:" << minbpp << " MaxBpp: " << maxbpp << endl;

                modesVector.push_back(camdummy.FormatAndModeToEnum(i,j));
                camInfo.f7_modes.push_back(camdummy.FormatAndModeToEnum(i,j));
                camInfo.f7_MinBpP.push_back(minbpp);
                camInfo.f7_MaxBpP.push_back(maxbpp);
                camInfo.f7_maxHeight.push_back(heightMax);
                camInfo.f7_maxWidth.push_back(widthMax);
                camInfo.f7_unitHeight.push_back(hUnit);
                camInfo.f7_unitWidth.push_back(wUnit);
                camInfo.f7_bestBpP.push_back(bpprec);
              }
            }
          }
        }
      }

      // Select best Framerate for selected format and mode
      for (int k=0; k<8; k++)
      {
        if(infocam.HasVideoFrameRate(Format_,Mode_,k)) {
          float fr = 0.0;
          switch (k) {
    case 0:
      fr = 1.875;
      break;

    case 1:
      fr = 3.75;
      break;

    case 2:
      fr = 7.5;
      break;

    case 3:
      fr = 15;
      break;

    case 4:
      fr = 30;
      break;

    case 5:
      fr = 60;
      break;

    case 6:
      fr = 120;
      break;

    case 7:
      fr = 240;
      break;

    default:
      break;
          }
          FPS_ = fr;
        }
      }



      camInfo.videoModes = modesVector;
      camInfo.bestMode = camdummy.FormatAndModeToEnum(Format_,Mode_);
      camInfo.bestFramerate = FPS_;
      camInfo.framerates = framesVector;
      camInfos.push_back(camInfo);


    }

  }

  return ncams;
}

// tested with Scorpion, Dragonfly

VideoSource_DCAM::VideoSource_DCAM(int card): VideoSource()
{
  ForceF7_ = false;
  DirectF7_ = false;
  UserTopLeft_ = false;
  UseBinning_ = false;
  UserMode_ = false;
  ColorMode_ = ImageBase::CM_UYVY422;
  DcamFps_ = 3;
  Width_ = 0;
  Height_ = 0;
  Left_ = 0;
  Top_ = 0;
  BytesPerPacket_ = 0;
  ColorChannels_ = 0;
  TryFirewireB_ = true;
  IsControllable_ = true;
}

VideoSource_DCAM::~VideoSource_DCAM()
{
}

int VideoSource_DCAM::OpenDevice(int camid)
{
  if(camid != 0)
    camid = camid-1;
  // check if a camera is connected.
  int num = camera.RefreshCameraList();
  //int res = camera.CheckLink();
  // = camera.GetNumberCameras();
  cout << "I Found " << num << " Cameras" << endl;


  if (num > 0)
  {
    //BIASDOUT(D_DCAM,"A Camera was found and selected.");
    //SelectedCam_=camera.GetNode();
    //cout << "Selected Cam: " << SelectedCam_ << endl;
  }
  else
  {
    BIASERR("No Camera was found.");
  }


  BIASDOUT(D_DCAM,"VideoSource_DCAM::OpenDevice("<<camid<<")");

  int select = camera.SelectCamera(camid);

  // is there a camera with id: camid?
  if (select == CAM_SUCCESS)
  {
    SelectedCam_ = camid;
    BIASDOUT(D_DCAM,"VideoSource_DCAM::OpenDevice("<<camid<<") successful");
  } else {
    BIASERR("No Device found");
    return -1;
  }

  BIASDOUT(D_DCAM,"Setting up camera "<<SelectedCam_<<"");

  // QueryCam(); is done by the camera

  imageintern_=new BIAS::Image<unsigned char>();
  imageintern_->Init(640,480,1);
  return InitCam();

}

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

int VideoSource_DCAM::CloseDevice()
{
  if(Active_){
    PostGrab();
  }
  //camera.~C1394Camera();
  return 0;
}
/*
int VideoSource_DCAM::UsePort(int channel)
{
BIASWARN("Not yet implemented for DCAM_CMU!!!");
return -1;
}
*/


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

int VideoSource_DCAM::ActivateExternalTrigger_(bool on)
{
  camera.GetCameraControl(::FEATURE_TRIGGER_MODE)->Inquire();
  if (camera.GetCameraControl(::FEATURE_TRIGGER_MODE)->HasPresence()) {
    camera.GetCameraControl(::FEATURE_TRIGGER_MODE)->SetOnOff(on);
    camera.GetCameraControl(::FEATURE_TRIGGER_MODE)->Status();
    if (!camera.GetCameraControl(::FEATURE_TRIGGER_MODE)->StatusOnOff()) {
      BIASERR("Trigger refuses to be switched on.");
    }
    return 0;
  } else {
    BIASERR("No trigger mode available for this camera");
    return -1;
  }
}


int VideoSource_DCAM::InitCam()
{

  if(camera.InitCamera()==CAM_SUCCESS)
  {
    cout<< "camera inited successfully" << endl;
    BIASDOUT(D_DCAM,"VideoSource_DCAM::InitCamera() successful");
  }
  else
  {
    BIASERR("VideoSource_DCAM::InitCamera() failed");
    return -1;
  }

  if(TryFirewireB_){
    if(camera.Has1394b()){
      int res = camera.Set1394b(true);
      cout << "Status Set1394b: " << res << endl;
      BIASDOUT(D_DCAM,"VideoSource_DCAM::InitCamera(): set cam successful to 1394b");
      cout << "Firewire Status: " << camera.Status1394b() << endl;
      cout << "CAM Max Speed: " << camera.GetMaxSpeed() << endl;
    }
  }

  // Look up camera Model and Vendor
  LARGE_INTEGER camModel;
  camModel.QuadPart = 0;
  camera.GetCameraUniqueID(&camModel);
  //DBG? following call overrides user color settings, why?
  if (CamModel_>100) CamModel_ = GetModelForEuid(camModel);

  if(!DirectF7_){

    if (Width_ != 0 || Height_ != 0) // UseBinning_ not implemented.
    {
      // try to set user definitions
      if ( UserSizeToMode() < 0)
      {
        BIASERR("UserSizeToMode() failed");
        return -1;
      }
    }
    else
    {

      // Select best mode, format and framerate for camera.
      SelectDefault();

    }
  }

  // set camera to parameters.
  if (camera.SetVideoFormat(DcamFormat_) == CAM_SUCCESS &&
    camera.SetVideoMode(DcamMode_)       == CAM_SUCCESS)
  {


    if (DcamFormat_ != 7)
    {
      // higher value -> higher framerate
      // 2=7.5fps, 3=15fps, ...
      float fps = FramesPerSecond_;
      if (FramesPerSecond_ != 0.0)
      {
        int videoframerate = 7;

        // set video frame rate, for more details see CMU driver manual
        if (fps <= 1.875)
          videoframerate = 0;
        else if (fps <= 3.75)
          videoframerate = 1;
        else if (fps <= 7.5)
          videoframerate = 2;
        else if (fps <= 15.0)
          videoframerate = 3;
        else if (fps <= 30.0)
          videoframerate = 4;
        else if (fps <= 60.0)
          videoframerate = 5;
        else if (fps <= 120.0)
          videoframerate = 6;
        else if (fps <= 240.0)
          videoframerate = 7;

        // try to set user video frame rate, else set default
        if (camera.SetVideoFrameRate(videoframerate)!= CAM_SUCCESS)
        {
          BIASERR("Failed to set user frame rate, setting default.");
          camera.SetVideoFrameRate(DcamFps_);
        }
      }
      else
        camera.SetVideoFrameRate(DcamFps_);
    }
    else
    {
      //choose colorcode from DCColorMode:
      COLOR_CODE cc;
      switch(f7ColorCoding_){
        case DC1394_COLOR_CODING_YUV411:
          cc = COLOR_CODE_YUV411;
          break;
        case DC1394_COLOR_CODING_YUV422:
          cc = COLOR_CODE_YUV422;
          break;
        case DC1394_COLOR_CODING_YUV444:
          cc = COLOR_CODE_YUV444;
          break;
        case DC1394_COLOR_CODING_RAW8:
          cc = COLOR_CODE_RAW8;
          break;
        case DC1394_COLOR_CODING_RGB8:
          cc = COLOR_CODE_RGB8;
          break;
        case DC1394_COLOR_CODING_RAW16:
          cc = COLOR_CODE_RAW16;
          break;
        case DC1394_COLOR_CODING_MONO16:
          cc = COLOR_CODE_Y16;
          break;
        default: cc = COLOR_CODE_Y8;
          break;

      }
      SetColorFromMode_();
      camera.GetCameraControlSize()->SetSize((unsigned short)Width_,
        (unsigned short)Height_);

      // Maximum bpp is selected.
      if (BytesPerPacket_ == 0)
      {
        CalcBytesPerPacket();
      }

      camera.GetCameraControlSize()->SetPos((unsigned short)Left_,
        (unsigned short)Top_);


      camera.GetCameraControlSize()->SetColorCode(cc);


      camera.GetCameraControlSize()->
        SetBytesPerPacket((unsigned short)BytesPerPacket_);
    }


    // setTopLeft
    if(UserTopLeft_){
      int res = camera.GetCameraControlSize()->SetPos((unsigned short)Left_,(unsigned short)Top_);
      if(res != CAM_SUCCESS){ BIASERR("Setting Top Left failed.") ;}
    }
    
    CompleteInitialized_ = true;        
    
    //hack for pointgreys FFMTC and FFMTM
    char buffer[1024];
    camera.GetCameraName(buffer,sizeof(buffer));
    std::string name (buffer);
    if (name=="Firefly MV FFMV-03MTC"){
      ColorMode_ = ImageBase::CM_Bayer_GBRG;
      camera.Set1394b(false);
      return true;
    }
    else if (name=="Firefly MV FFMV-03MTM"){
      ColorMode_ = ImageBase::CM_Grey;
      camera.Set1394b(false);
      return true;
    }
    else {
      //SetExternalTrigger(bExternalTrigger_);      
      return true;
    }
  }

  // Initialization failed.
  BIASERR("Can not set DCAM Camera to requested parameters.");
  return -1;
}

int VideoSource_DCAM::GrabSingle(Camera <unsigned char> &image)
{
  //cout << "In der normalen DCAM" << endl;
  BIASDOUT(D_DCAM,"VideoSource_DCAM::GrabSingle("<<SelectedCam_<<")");

  // try to capture image.
  int res = camera.AcquireImage();

  if (res == CAM_SUCCESS)
  {
    BIASDOUT(D_DCAM,"VideoSource_DCAM::CaptureImage successful");
    image.SetUID(BIAS::UUID::GenerateUUID());
    image.CopyIn_NoInit(camera.GetRawData(NULL));

  }
  else
  {
    BIASERR("VideoSource_DCAM::CaptureImage failed");
    return -1;
  }

  return 0;
}
int VideoSource_DCAM::GrabSingleAndConvert( BIAS::Image <unsigned char> *dest , enum ImageBase::EColorModel targetColorModel )
{ 

  camera.AcquireImage();
  if (dest->GetStorageType()==ImageBase::ST_unsignedchar){

    imageintern_->SetColorModel(targetColorModel); 
    imageintern_->CopyIn_NoInit(camera.GetRawData(NULL));
    dest->SetUID(BIAS::UUID::GenerateUUID());

    //unsigned char * olla=imageintern_->GetImageData();


   // ImageConvert::
 //     BayerToRGBSimple( imageintern_->GetImageData() ,  dest->GetImageData (),dest->GetWidth(),dest->GetHeight(),ImageBase::CM_Bayer_GBRG);}
 ImageConvert:: BayerToRGB(*imageintern_  ,  *dest,  BAYER_DEMOSAIC_METHOD_SIMPLE,   false);


  }
  else {

    BIASDOUT(D_DCAM,"VideoSource_DCAM::GrabSingleAndConvert only implemented for ST_unsignedchar ");
  }
  return 0;
}

int VideoSource_DCAM::GrabSingleAndConvertForGrey( BIAS::Image <unsigned char> *dest)
{ 

  camera.AcquireImage();
  dest->ClearDataPointer();
  dest->InitWithForeignData(dest->GetWidth(),dest->GetHeight(),dest->GetDepth(),camera.GetRawData(NULL));
  dest->SetColorModel(ImageBase::CM_Grey); 
  dest->SetUID(BIAS::UUID::GenerateUUID());

  return 0;
}

int VideoSource_DCAM::QueryCam()
{
  // is done automatically by the camera after initialisation
  return 0;
}


int  VideoSource_DCAM::SetFormat7(int mode, int bpp, dc1394color_coding_t colorCoding)
{
  // TODO: color coding will not be used in InitCamera, which makes this function useless
  BIASDOUT(D_DCAM,"VideoSource_DCAM::SetFormat7 Format7 Color Coding will be overwritten with RGB8 on windows machines.");
  f7ColorCoding_ = colorCoding;
  DcamFormat_ = 7;
  DcamMode_ = mode;
  BytesPerPacket_ = bpp;
  DirectF7_ = true;
  return 0;
}

int VideoSource_DCAM::ShowCapabilities()
{
  cout <<"Camera: "<<SelectedCam_<<endl;
  camera.RefreshControlRegisters();

  cout <<"Supported Formats: ";
  for (int i=0; i<8; i++)
  {
    if (camera.HasVideoFormat(i))
    {
      cout <<"Format"<<i<<" ";
    }
  }
  cout <<endl;

  // Get supported modes for available formats.
  cout <<"Suported Modes:"<<endl;
  for (int i=0; i<8; i++)
  {
    if (camera.HasVideoFormat(i))
    {
      cout <<"Format"<<i<<": ";
      for (int j=0; j<8; j++)
      {
        if (camera.HasVideoMode(i,j))
        {
          cout <<"Mode: "<<j<<"; ";
        }
        cout <<endl;
      }
    }
  }

  // Only for Formats 0..2 is a framerate meaningful
  cout <<"Supported Framerates:"<<endl;
  for (int format=0; format < 3; format++)
  {
    cout <<" Format"<<format<<": ";
    for (int mode=0; mode<8; mode++)
    {
      if (camera.HasVideoMode(format,mode))
      {
        cout <<"Mode "<<mode<<":  ";
        for (int f=0; f<8; f++)
        {
          if (camera.HasVideoFrameRate(format,mode,f))
          {
            cout <<1.875 * double(0x1<<f)<<";  ";
          }
        }
      }
    }
    cout <<endl;
  }

  return 0;
}

#define USE_NATIVE_XGA

int VideoSource_DCAM::UserSizeToMode()
{
  BIASDOUT(D_DCAM,"VideoSource_DCAM::UserSizeToMode("<<SelectedCam_<<"): "
    <<Width_<<"x"<<Height_<<" BytesPerPixel_: "<<BytesPerPixel_
    <<" ColorMode "<<ColorMode_);
  cout <<"BztesPerPixel" << BytesPerPixel_ << endl;

  if (BytesPerPixel_ == 1.0)
  {
    if (ColorMode_ == ImageBase::CM_UYVY422) {
      ColorChannels_ = 2;
      if (!ForceF7_) {
        if (Width_ == 1600 && Height_ == 1200)
        {
          DcamFormat_ = 2;
          DcamMode_   = 3;
        }
        else if (Width_ == 1280 && Height_ == 960)
        {
          DcamFormat_ = 2;
          DcamMode_   = 0;
        }
        else if (Width_ == 1024 && Height_ == 768)
        {
          DcamFormat_ = 1;
          DcamMode_   = 3;
        }
        else if (Width_ == 800 && Height_ == 600)
        {
          DcamFormat_ = 1;
          DcamMode_   = 0;
        }
        else if (Width_ == 640 && Height_ == 480)
        {
          DcamFormat_ = 0;
          DcamMode_   = 3;
        }
        else if (Width_ == 320 && Height_ == 240)
        {
          DcamFormat_ = 0;
          DcamMode_   = 1;
        }
        else  // Format 7 required
        {
          if (UserSizeToFormat7_() < 0)
          {
            BIASERR("VideoSource_DCAM::UserSizeToFormat7_(): failed");
            return -1;
          }
        }
      }
      else
      {
        if (UserSizeToFormat7_() < 0)
        {
          BIASERR("VideoSource_DCAM::UserSizeToFormat7_(): failed");
          return -1;
        }
      }
    }
    else if (ColorMode_ == ImageBase::CM_Grey ||ColorMode_ == ImageBase::CM_Bayer_RGGB
      || ColorMode_ == ImageBase::CM_Bayer_GBRG
      || ColorMode_ == ImageBase::CM_Bayer_GRBG
      || ColorMode_ == ImageBase::CM_Bayer_BGGR )
    {
      ColorChannels_ = 1;
      if (!ForceF7_ ) {
        if (Width_ == 1600 && Height_ == 1200)
        {
          DcamFormat_ = 2;
          DcamMode_   = 5;
        }
        else if (Width_ == 1280 && Height_ == 960)
        {
          DcamFormat_ = 2;
          DcamMode_   = 2;
        }
        else if (Width_ == 1024 && Height_ == 768)
        {
          DcamFormat_ = 1;
          DcamMode_   = 5;
        }
        else if (Width_ == 640 && Height_ == 480 && CamModel_!=CAMERA_PTGREY_DRAGONFLY_HIRES)
        {
          DcamFormat_ = 0;
          DcamMode_   = 5;
        }
        else
        {
          if (UserSizeToFormat7_() < 0)
          {
            BIASERR("VideoSource_DCAM::UserSizeToFormat7_(): failed");
            return -1;
          }
        }
      }
      else
      {
        if (UserSizeToFormat7_() < 0)
        {
          BIASERR("VideoSource_DCAM::UserSizeToFormat7_(): failed");
          return -1;
        }
      }
    }
    else
    {
      BIASERR("VideoSource_DCAM::UserSizeToMode(): Unsupported ColorModel_"
        <<ColorMode_);
      return -1;
    }
  }
  else
  {
    BIASDOUT(D_DCAM,"VideoSource_DCAM::UserSizeToMode(): 16 Bit not implemented.");
    return -1;
  }
  return 0;
}
void VideoSource_DCAM::SetCameraModel( CameraModel model){
  CamModel_=model;
}

int VideoSource_DCAM::UserSizeToFormat7_()
{

  // Set Camera to Format7 to inquire unitwidth and height.
  camera.SetVideoFormat(7);
  camera.SetVideoMode(0);

  unsigned short* tmpWidth = new unsigned short;
  unsigned short* tmpHeight = new unsigned short;
  camera.GetCameraControlSize()->GetSizeUnits(tmpWidth,tmpHeight);
  UnitWidth_  = *tmpWidth;
  UnitHeight_ = *tmpHeight;

  camera.GetCameraControlSize()->GetSizeLimits(tmpWidth,tmpHeight);
  MaxWidth_  = *tmpWidth;
  MaxHeight_ = *tmpHeight;

  delete tmpWidth;
  delete tmpHeight;

  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_   = 0;
    DcamFormat_ = 7;

    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, not implemented yet.
    BIASDOUT(D_DCAM_F7,"Using format7 Mode 1 (Binning): "<<Width_<<"x"<<Height_
      <<"+"<<Left_<<"+"<<Top_);

    DcamMode_      = 1;
    DcamFormat_    = 7;
    ColorChannels_ = 1;
  }

  return 0;
}

int VideoSource_DCAM::SelectDefault()
{

  if(!UserMode_){
    // Get best Mode for Camera
    for (int i=0; i<3; i++)
    {
      if (camera.HasVideoFormat(i))
      {
        for (int j=0; j<6; j++)                 // ToDo: No 16-Bits Modes allowed.
        {
          if (camera.HasVideoMode(i,j))
          {
            DcamFormat_ = i;
            DcamMode_   = j;
          }
        }
      }
    }

    // Select best Framerate for selected format and mode
    for (int k=0; k<8; k++)
    {
      if(camera.HasVideoFrameRate(DcamFormat_,DcamMode_,k)) {
        DcamFps_ = k;
      }
    }

  }
  switch (DcamFormat_) {
  case 0:  // Format 0
    switch (DcamMode_) {
  case 0:  // Mode 0
    ColorChannels_ = 2;
    Width_ = 160; Height_ = 120; ColorMode_ = ImageBase::CM_YUV444;
    break;
  case 1:  // F0 Mode 1
    ColorChannels_ = 2;
    Width_ = 320; Height_ = 240; ColorMode_ = ImageBase::CM_UYVY422;
    break;
  case 2:  // F0 Mode 2
    ColorChannels_ = 2;
    Width_ = 640; Height_ = 480; ColorMode_ = ImageBase::CM_YUV411;
    break;
  case 3:  // F0 Mode 3
    ColorChannels_ = 2;
    Width_ = 640; Height_ = 480; ColorMode_ = ImageBase::CM_UYVY422;
    break;
  case 4:  // F0 Mode 4
    ColorChannels_ = 3;
    Width_ = 640; Height_ = 480; ColorMode_ = ImageBase::CM_RGB;
    break;
  case 5:  // F0 Mode 5
    ColorChannels_ = 1;
    Width_ = 640; Height_ = 480;  
    break;
  case 6:     // F0 Mode 6
    ColorChannels_ = 1;
    Width_ = 640; Height_ = 480;
    break;
    }

    break;
  case 1:   // Format 1
    switch (DcamMode_) {
  case 0: // F1 Mode 0
    ColorChannels_ = 2;
    Width_ = 800; Height_ = 600;  ColorMode_ = ImageBase::CM_UYVY422;
    break;
  case 1: // F1 Mode 1
    ColorChannels_ = 3;
    Width_ = 800; Height_ = 600;  ColorMode_ = ImageBase::CM_RGB;
    break;
  case 2: // F1 Mode 2
    ColorChannels_ = 1;
    Width_ = 800; Height_ = 600;
    break;
  case 3:   // F1 Mode 3
    ColorChannels_ = 2;
    Width_ = 1024; Height_ = 768;  ColorMode_ = ImageBase::CM_UYVY422;
    break;
  case 4: // F1 Mode 4
    ColorChannels_ = 3;
    Width_ = 1024; Height_ = 768;  ColorMode_ = ImageBase::CM_RGB;
    break;
  case 5: // F1 Mode 5
    ColorChannels_ = 1;
    Width_ = 1024; Height_ = 768;
    break;
  case 6: // F1 Mode 6
    ColorChannels_ = 1;
    Width_ = 800; Height_ = 600;
    break;
  case 7: // F1 Mode
    Width_ = 1024; Height_ = 768;
    ColorChannels_ = 1;
    BytesPerPixel_ = 2.0;
    break;
    }

    break;
  case 2: // Format 2
    switch (DcamMode_) {
  case 0:
    ColorChannels_ = 2;
    Width_ = 1280; Height_ = 960;  ColorMode_ = ImageBase::CM_UYVY422;
    break;
  case 1:
    ColorChannels_ = 3;
    Width_ = 1280; Height_ = 960;  ColorMode_ = ImageBase::CM_RGB;
    break;
  case 2:
    ColorChannels_ = 1;
    Width_ = 1280; Height_ = 960;
    break;
  case 3:
    ColorChannels_ = 2;
    Width_ = 1600; Height_ = 1200;  ColorMode_ = ImageBase::CM_UYVY422;
    break;
  case 4:
    ColorChannels_ = 3;
    Width_ = 1600; Height_ = 1200;  ColorMode_ = ImageBase::CM_RGB;
    break;
  case 5:
    ColorChannels_ = 1;
    Width_ = 1600; Height_ = 1200;  ColorMode_ = ImageBase::CM_Grey;
    break;
  case 6:
    ColorChannels_ = 1;
    Width_ = 1280; Height_ = 960;
    break;
  case 7:
    ColorChannels_ = 1;
    Width_ = 1600; Height_ = 1200;
    break;
    }
    break;
  }

  return 0;
}

#ifdef BUILD_IMAGE_USHORT
int VideoSource_DCAM::GrabSingle(BIAS::Camera <unsigned short> &image)
{
  return 0;
}
#endif

CameraModel VideoSource_DCAM::GetModelForEuid(LARGE_INTEGER /*euid*/)
{
  // Look up for Model and Vendor!!!
  char *vendorChr = new char[256];
  char *modelChr = new char[256];
  int vendorLen = 256;
  int modelLen = 256;

  camera.GetCameraVendor(vendorChr,vendorLen);
  camera.GetCameraName(modelChr,modelLen);

  string vendor(vendorChr);
  string model(modelChr);
  delete vendorChr;
  delete modelChr;
  ColorMode_ = ImageBase::CM_Grey;  // Default Colormodel
  if (vendor.find("Point Grey Research") != string::npos)
  {
    if (model.find("Dragonfly") != string::npos)
    {
      unsigned long r1040;
      camera.ReadQuadlet(0x1040, &r1040);
      // little endian Red: 52 Green: 47 Blue: 42 Monochrome 59

      switch(r1040)
      {
      case 0x52474742 :
        ColorMode_ = ImageBase::CM_Bayer_RGGB;
        break;

      case 0x47425247 :
        ColorMode_ = ImageBase::CM_Bayer_GBRG;
        break;

      case 0x47524247 :
        ColorMode_ = ImageBase::CM_Bayer_GRBG;
        break;

      case 0x42474752 :
        ColorMode_ = ImageBase::CM_Bayer_BGGR;
        break;

      case 0x59595959 :
        ColorMode_ = ImageBase::CM_Grey;
        return CAMERA_PTGREY_DRAGONFLY_HIRES;
        break;

      default :
        BIASERR("Error, unknown PtGrey color model!!!");
        return CAMERA_UNKNOWN;
        break;
      }
      return CAMERA_PTGREY_DRAGONFLY_COLOR;

    }else if(model.find("Scorpion") != string::npos){
      ColorMode_ = ImageBase::CM_Bayer_RGGB;
      return CAMERA_PTGREY_SCORPION_COLOR_1600;
    }else if(model.find("Flea2 FL2-08S2M") != string::npos){
      ColorMode_ = ImageBase::CM_Grey;
      return CAMERA_PTGREY_FLEA2_BW;
    }
    else if(model.find("Grasshopper GRAS-20S4C") != string::npos){
      //ColorMode_ = ImageBase::CM_YUYV422;
      return CAMERA_PTGREY_GRASSHOPPER_COLOR;
    }   else if(model.find("Bumblebee XB3 BBX3-13S2C") != string::npos){
      ColorMode_ = ImageBase::CM_Bayer_GBRG;
      BIASDOUT(D_DCAM,"Model: PtGrey Bumblebee XB3");
      return CAMERA_PTGREY_BUMBLEBEE_XB3;
    }
  }

  if ((vendor.find("SONY") != string::npos) &&
    (model.find("DFW-X700  v1.02B") != string::npos)) {
      ColorMode_ = ImageBase::CM_UYVY422;//why?
      return CAMERA_SONY_DFW_X700;
  }

  // other camera
  return CAMERA_UNKNOWN;
}

void VideoSource_DCAM::ActivateScorpionTimestamp()
{
}

int VideoSource_DCAM::PreGrab()
{
  if (Grabbing_)
  {
    BIASERR("Camera is already grabbing.");
    return 0;
  }

  Grabbing_ = true;

  // Start Image Capturing
  int res = camera.StartImageAcquisition();
  if (res == CAM_SUCCESS)
  {
    BIASDOUT(D_DCAM,"VideoSource_DCAM::StartImageCapture successful");
    Active_ = true;
  }
  else if (res == CAM_ERROR_INSUFFICIENT_RESOURCES) {
    BIASERR("VideoSource_DCAM::StartImageCapture failed (insufficient ressources), cam: " << SelectedCam_ << " result: " << res);
    Grabbing_ = false;
  }
  else
  {
    BIASERR("VideoSource_DCAM::StartImageCapture failed, cam: " << SelectedCam_ << " result: " << res);
    Grabbing_ = false;
  }
  return res;
}

int VideoSource_DCAM::PostGrab()
{
  // Stop Grabbing
  if(Active_ == true){
    camera.StopImageAcquisition();
    Grabbing_=false;
    Active_ = false;
  }
  return 0;
}

unsigned int VideoSource_DCAM::CalcBytesPerPacket()
{
  unsigned short bpPacket;
  camera.GetCameraControlSize()->GetBytesPerPacket(&bpPacket);
  BytesPerPacket_ = bpPacket;
  return 0;
}

int  VideoSource_DCAM::ApplyBytesPerPacket()
{
  return 0;
}
/*
int VideoSource_DCAM::StopIso()
{
return 0;
}

int VideoSource_DCAM::StartIso()
{
return 0;
}
*/
float VideoSource_DCAM::GetShutter()
{
  camera.GetCameraControl(::FEATURE_SHUTTER)->Inquire();
  float shutter = -1;
  //if cam doesn't support absolute settings for shutter, it has to be
  //calculated from register data (long) -- TODO
  if (camera.GetCameraControl(::FEATURE_SHUTTER)->HasAbsControl())
    camera.GetCameraControl(::FEATURE_SHUTTER)->GetValueAbsolute(&shutter);
  else
    BIASERR("Cam doesn't support absolute values for shutter!!! FIXME");
  return shutter;
}

float VideoSource_DCAM::GetGain()
{
  camera.GetCameraControl(::FEATURE_GAIN)->Inquire();
  float gain = -1;
  //if cam doesn't support absolute settings for gain, it has to be
  //calculated from register data (long) -- TODO
  if (camera.GetCameraControl(::FEATURE_GAIN)->HasAbsControl())
    camera.GetCameraControl(::FEATURE_GAIN)->GetValueAbsolute(&gain);
  else
    BIASERR("Cam doesn't support absolute values for shutter!!! FIXME");
  return gain;
}
/*
void VideoSource_DCAM::PrintFormatAndMode_()
{
BIASDOUT(D_DCAM,"Format: "<<DcamFormat_<<" Mode: "<<DcamMode_<<" ");
}
*/
int VideoSource_DCAM::SetGain(float gain)
{
  if (camera.GetCameraControl(::FEATURE_GAIN)->Inquire() != CAM_SUCCESS) {
    BIASERR("Error getting settings for feature gain!!!");
    return -1;
  }

  //try to set gain via absolute value
  if (camera.GetCameraControl(::FEATURE_GAIN)->HasAbsControl()) {
    float min,max;
    camera.GetCameraControl(::FEATURE_GAIN)->GetRangeAbsolute(&min,&max);
    if ((gain < min)||(gain > max)) {
      BIASERR("Gain " << gain << " is out of range [" << min << ":" << max << "]");
      return -1;
    }
    if (!camera.GetCameraControl(::FEATURE_GAIN)->HasManualMode()) {
      BIASERR("Gain is not controlled manually!!!");
      return -1;
    }
    if (camera.GetCameraControl(::FEATURE_GAIN)->SetAutoMode(false)
      != CAM_SUCCESS) {
        BIASERR("Error setting gain to manual mode!!!");
        return -1;
    }
    if (camera.GetCameraControl(::FEATURE_GAIN)->SetAbsControl(true)
      != CAM_SUCCESS) {
        BIASERR("Error setting gain to manual mode!!!");
        return -1;
    }
    if (camera.GetCameraControl(::FEATURE_GAIN)->SetValueAbsolute(gain)
      != CAM_SUCCESS) {
        BIASERR("Error setting gain with SetValueAbsolute!!!");
        return -1;
    }
    return 0;
  }

  //if SetValueAbsolute is not supported calc register value
  switch(CamModel_)
  {
  case CAMERA_PTGREY_DRAGONFLY_COLOR:
    // Calculation from Technical Reference Manual for 640x480 Dragonfly
    unsigned short maxH,maxV;
    camera.GetCameraControlSize()->GetSizeLimits(&maxH,&maxV);
    if (maxV == 640)
    {
      if(gain < 512)
      {
        gain = -6,0404 + (20*log(658+gain)*(658-gain));
      }
      else
      {
        gain = -6,0404 + (0,0354*gain);
      }
    }
    // The camera is the 1024x768 Dragonfly
    else
    {
      if(gain < 512)
      {
        gain = -9,40 + (20*log(658+gain)*(658-gain));
      }
      else
      {
        gain = 9,40 + (0,0354*gain);
      }
    }
    break;

    // see manual for more information, range is 0x800 to 0x8B4
  case CAMERA_SONY_DFW_X700:
    gain = gain * 8.0f + 0x800;
    if (gain > 2228.0f) gain = 2228.0f;
    if (gain < 2048.0f) gain = 2048.0f;
    break;

  default :
    BIASERR("VideoSource_DCAM::SetGain: Not implemented for this camera.");
    return -1;
    break;
  }

  // check if gain value can be set
  unsigned short min,max;
  camera.GetCameraControl(::FEATURE_GAIN)->GetRange(&min,&max);
  if (((int)gain < min) || ((int)gain > max))
  {
    BIASERR("Value for gain out of range.")
      return -1;
  }
  else if (!camera.GetCameraControl(::FEATURE_GAIN)->HasManualMode())
  {
    BIASERR("Feature is not set to be controlled manually.")
      return -1;
  }
  else
  {
    if (camera.GetCameraControl(::FEATURE_GAIN)->SetValue((unsigned short)gain)
      != CAM_SUCCESS) {
        BIASERR("Error setting gain with CamControl->SetValue!!!");
        return -1;
    }
  }
  return 0;
}

int VideoSource_DCAM::SetWhiteBalance(float rvalue,float bvalue)
{
  // the range of the values is -0.5 to 0.5, so scale to 0-255
  rvalue = (rvalue + 0.5f) * 127.0f;
  bvalue = (bvalue + 0.5f) * 127.0f;

  // set min or max for values out of range
  if ( rvalue > 127.0f ) rvalue = 127.0;
  if ( bvalue > 127.0f ) bvalue = 127.0;
  if ( rvalue < 0.0f ) rvalue = 0.0;
  if ( bvalue < 0.0f ) bvalue = 0.0;

  camera.GetCameraControl(::FEATURE_WHITE_BALANCE)->Inquire();

  unsigned short min,max;
  camera.GetCameraControl(::FEATURE_WHITE_BALANCE)->GetRange(&min,&max);
  // check if whiteBalance values can be set.
  if (!camera.GetCameraControl(::FEATURE_WHITE_BALANCE)->HasManualMode())
  {
    BIASERR("White balance is not set to be controlled manually.")
      return -1;
  }
  else
  {
    if (rvalue > 0.5f)
      rvalue = 0.5f;
    if (bvalue < -0.5f)
      bvalue = -0.5f;
    // the range of the values is -0.5 to 0.5, so scale to min - max
    rvalue = (rvalue + 0.5f) * (float (max) - float(min)) + float(min);
    bvalue = (bvalue + 0.5f) * (float (max) - float(min)) + float(min);

    // conversion from float to int, maybe value must be computed.
    if (camera.GetCameraControl(::FEATURE_WHITE_BALANCE)
      ->SetValue((unsigned short)rvalue, (unsigned short)bvalue) != CAM_SUCCESS) {
        BIASERR("Error setting white balance with CamControl->SetValue!!!");
        return -1;
    }
  }

  return 0;
}

int VideoSource_DCAM::OnePushAuto(dc1394feature_t feature)
{
  //!!!ATTENTION BIAS::FEATURE... may differ from ::FEATURE... (from CMU)!!!
  int res = 0;

  switch(feature)
  {//?????????? MAYBE AutoMode must be activated for OnePush-mode ??????????????
  case DC1394_FEATURE_BRIGHTNESS:
    res = camera.GetCameraControl(::FEATURE_BRIGHTNESS)->SetOnePush(true);
    break;
  case DC1394_FEATURE_EXPOSURE:
    res = camera.GetCameraControl(::FEATURE_AUTO_EXPOSURE)->SetOnePush(true);
    break;
  case DC1394_FEATURE_SHARPNESS :
    res = camera.GetCameraControl(::FEATURE_SHARPNESS)->SetOnePush(true);
    break;
  case DC1394_FEATURE_WHITE_BALANCE :
    res = camera.GetCameraControl(::FEATURE_WHITE_BALANCE)->SetOnePush(true);
    break;
  case DC1394_FEATURE_HUE:
    res = camera.GetCameraControl(::FEATURE_HUE)->SetOnePush(true);
    break;
  case DC1394_FEATURE_SATURATION:
    res = camera.GetCameraControl(::FEATURE_SATURATION)->SetOnePush(true);
    break;
  case DC1394_FEATURE_GAMMA:
    res = camera.GetCameraControl(::FEATURE_GAMMA)->SetOnePush(true);
    break;
  case DC1394_FEATURE_SHUTTER:
    res = camera.GetCameraControl(::FEATURE_SHUTTER)->SetOnePush(true);
    break;
  case DC1394_FEATURE_GAIN:
    res = camera.GetCameraControl(::FEATURE_GAIN)->SetOnePush(true);
    break;
  case DC1394_FEATURE_IRIS:
    res = camera.GetCameraControl(::FEATURE_IRIS)->SetOnePush(true);
    break;
  case DC1394_FEATURE_FOCUS:
    res = camera.GetCameraControl(::FEATURE_FOCUS)->SetOnePush(true);
    break;
  case DC1394_FEATURE_TRIGGER:
    break;
  case DC1394_FEATURE_ZOOM:
    res = camera.GetCameraControl(::FEATURE_ZOOM)->SetOnePush(true);
    break;
  case DC1394_FEATURE_PAN:
    break;
  case DC1394_FEATURE_TILT:
    break;
  case DC1394_FEATURE_OPTICAL_FILTER:
    break;
  default:
    BIASERR("VideoSource_DCAM::SetAutoMode(): Unkown Feature");
    return -1;
  }

  if (res != CAM_SUCCESS)
  {
    BIASERR("Failed to set OnePush!!!")
      return -1;
  }

  return 0;
}

int VideoSource_DCAM::SetShutter(float exptime)
{
  //if SetValueAbsolute is not supported calc register value
  switch(CamModel_)
  {
    // see manual for more information, range is 0x7E2 to 0xB20
  case CAMERA_SONY_DFW_X700:
    exptime = 2848.0f - exptime * 10000.0f;
    if (exptime > 2848.0f) exptime = 2848.0f;
    if (exptime < 2100.0f) exptime = 2100.0f;
    if (camera.GetCameraControl(::FEATURE_SHUTTER)->SetValue((unsigned short)exptime) == CAM_SUCCESS)
      return 0;
    break;
  }

  if (camera.GetCameraControl(::FEATURE_SHUTTER)->Inquire() != CAM_SUCCESS) {
    BIASERR("Error reading shutter settings!!!");
    return -1;
  }

  //try to set gain via absolute value
  if (camera.GetCameraControl(::FEATURE_SHUTTER)->HasAbsControl()) {
    float min,max;
    camera.GetCameraControl(::FEATURE_SHUTTER)->GetRangeAbsolute(&min,&max);
    cout<<"Min: "<<min<<" Max: "<<max<<endl;
    if ((exptime < min)||(exptime > max)) {
      BIASERR("Shutter " << exptime << " is out of range [" << min << ":" << max << "]");
      return -1;
    }
    if (!camera.GetCameraControl(::FEATURE_SHUTTER)->HasManualMode()) {
      BIASERR("Shutter is may not be controlled manually!!!");
      return -1;
    }
    if (camera.GetCameraControl(::FEATURE_SHUTTER)->SetAutoMode(false)
      != CAM_SUCCESS) {
        BIASERR("Error setting shutter to manual mode!!!");
        return -1;
    }
    if (camera.GetCameraControl(::FEATURE_SHUTTER)->SetAbsControl(true)
      != CAM_SUCCESS) {
        BIASERR("Error setting shutter to AbsControl-mode!!!");
        return -1;
    }
    int res = camera.GetCameraControl(::FEATURE_SHUTTER)->SetValueAbsolute(exptime);
    if (res != CAM_SUCCESS) {
      BIASERR("Error setting shutter with SetValueAbsolute, returns "<<res<<" !!!");
      return -1;
    }
    return 0;
  }

  BIASERR("Error: setting shutter with SetValueAbsolute not supported!!!");
  return -1;
}

int VideoSource_DCAM::SetLeftTop(unsigned int left, unsigned int top)
{
  int res;

  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;
  }

  // try to set defined position, if cam is initialized.
  if(CompleteInitialized_){
    res = camera.GetCameraControlSize()->SetPos((unsigned short)left,
      (unsigned short)top);

    if (res == CAM_SUCCESS)
    {
      BIASDOUT(D_DCAM,"VideoSource_DCAM::SetLeftTop: successful");
      return 0;
    }
    else
    {
      BIASERR("VideoSource_DCAM::SetLeftTop: failed");
      return -1;
    }
  }
  return 0;
}

unsigned int VideoSource_DCAM::GetFeature(dc1394feature_t feature)
{
  unsigned short value = 0;

  switch(feature)
  {
  case DC1394_FEATURE_BRIGHTNESS:
    camera.GetCameraControl(::FEATURE_BRIGHTNESS)->Inquire();
    camera.GetCameraControl(::FEATURE_BRIGHTNESS)->GetValue(&value);
    break;
  case DC1394_FEATURE_EXPOSURE:
    BIASERR("Can't get exposure, get FEATURE_SHUTTER instead!!!");
    break;
  case DC1394_FEATURE_SHARPNESS :
    camera.GetCameraControl(::FEATURE_SHARPNESS)->Inquire();
    camera.GetCameraControl(::FEATURE_SHARPNESS)->GetValue(&value);
    break;
  case DC1394_FEATURE_WHITE_BALANCE :
    camera.GetCameraControl(::FEATURE_WHITE_BALANCE)->Inquire();
    camera.GetCameraControl(::FEATURE_WHITE_BALANCE)->GetValue(&value);
    break;
  case DC1394_FEATURE_HUE:
    camera.GetCameraControl(::FEATURE_HUE)->Inquire();
    camera.GetCameraControl(::FEATURE_HUE)->GetValue(&value);
    break;
  case DC1394_FEATURE_SATURATION:
    camera.GetCameraControl(::FEATURE_SATURATION)->Inquire();
    camera.GetCameraControl(::FEATURE_SATURATION)->GetValue(&value);
    break;
  case DC1394_FEATURE_GAMMA:
    camera.GetCameraControl(::FEATURE_GAMMA)->Inquire();
    camera.GetCameraControl(::FEATURE_GAMMA)->GetValue(&value);
    break;
  case DC1394_FEATURE_SHUTTER:
    camera.GetCameraControl(::FEATURE_SHUTTER)->Inquire();
    camera.GetCameraControl(::FEATURE_SHUTTER)->GetValue(&value);
    break;
  case DC1394_FEATURE_GAIN:
    camera.GetCameraControl(::FEATURE_GAIN)->Inquire();
    camera.GetCameraControl(::FEATURE_GAIN)->GetValue(&value);
    break;
  case DC1394_FEATURE_IRIS:
    camera.GetCameraControl(::FEATURE_IRIS)->Inquire();
    camera.GetCameraControl(::FEATURE_IRIS)->GetValue(&value);
    break;
  case DC1394_FEATURE_FOCUS:
    camera.GetCameraControl(::FEATURE_FOCUS)->Inquire();
    camera.GetCameraControl(::FEATURE_FOCUS)->GetValue(&value);
    break;
  case DC1394_FEATURE_TRIGGER:
    break;
  case DC1394_FEATURE_ZOOM:
    camera.GetCameraControl(::FEATURE_ZOOM)->Inquire();
    camera.GetCameraControl(::FEATURE_ZOOM)->GetValue(&value);
    break;
  case DC1394_FEATURE_PAN:
    break;
  case DC1394_FEATURE_TILT:
    break;
  case DC1394_FEATURE_OPTICAL_FILTER:
    break;
  default:
    BIASERR("VideoSource_DCAM::GetFeature(): Unkown Feature");
    break;
  }
  return value;
}


int VideoSource_DCAM::SetFeature(dc1394feature_t feature, unsigned int value)
{
  int res = -1;
  unsigned short sValue = (unsigned short) value;

  switch(feature)
  {
  case DC1394_FEATURE_BRIGHTNESS:
    res = camera.GetCameraControl(::FEATURE_BRIGHTNESS)->SetValue(sValue);
    break;
  case DC1394_FEATURE_EXPOSURE:
    BIASERR("Can't set exposure, use FEATURE_SHUTTER instead!!!");
    return -1;
    break;
  case DC1394_FEATURE_SHARPNESS :
    res = camera.GetCameraControl(::FEATURE_SHARPNESS)->SetValue(sValue);
    break;
  case DC1394_FEATURE_WHITE_BALANCE :
    res = camera.GetCameraControl(::FEATURE_WHITE_BALANCE)->SetValue(sValue);
    break;
  case DC1394_FEATURE_HUE:
    res = camera.GetCameraControl(::FEATURE_HUE)->SetValue(sValue);
    break;
  case DC1394_FEATURE_SATURATION:
    res = camera.GetCameraControl(::FEATURE_SATURATION)->SetValue(sValue);
    break;
  case DC1394_FEATURE_GAMMA:
    res = camera.GetCameraControl(::FEATURE_GAMMA)->SetValue(sValue);
    break;
  case DC1394_FEATURE_SHUTTER:
    res = camera.GetCameraControl(::FEATURE_SHUTTER)->SetValue(sValue);
    break;
  case DC1394_FEATURE_GAIN:
    res = camera.GetCameraControl(::FEATURE_GAIN)->SetValue(sValue);
    break;
  case DC1394_FEATURE_IRIS:
    res = camera.GetCameraControl(::FEATURE_IRIS)->SetValue(sValue);
    break;
  case DC1394_FEATURE_FOCUS:
    res = camera.GetCameraControl(::FEATURE_FOCUS)->SetValue(sValue);
    break;
  case DC1394_FEATURE_TRIGGER:
    break;
  case DC1394_FEATURE_ZOOM:
    res = camera.GetCameraControl(::FEATURE_ZOOM)->SetValue(sValue);
    break;
  case DC1394_FEATURE_PAN:
    break;
  case DC1394_FEATURE_TILT:
    break;
  case DC1394_FEATURE_OPTICAL_FILTER:
    break;
  default:
    BIASERR("VideoSource_DCAM::SetFeature(): Unkown Feature");
    return -1;
  }

  if (res != CAM_SUCCESS) {
    BIASERR("Error setting feature "<<feature<<", SetValue returned "<<res);
    return -1;
  }

  return 0;
}

int VideoSource_DCAM::AutoMode(dc1394feature_t feature, dc1394feature_mode_t mode)
{
  int res = 0;
  bool on =false;
  if(mode == DC1394_FEATURE_MODE_AUTO)
    on = true;
  switch(feature)
  {
  case DC1394_FEATURE_BRIGHTNESS:
    res = camera.GetCameraControl(::FEATURE_BRIGHTNESS)->SetAutoMode(on);
    break;
  case DC1394_FEATURE_EXPOSURE:
    res = camera.GetCameraControl(::FEATURE_AUTO_EXPOSURE)->SetAutoMode(on);
    break;
  case DC1394_FEATURE_SHARPNESS :
    res = camera.GetCameraControl(::FEATURE_SHARPNESS)->SetAutoMode(on);
    break;
  case DC1394_FEATURE_WHITE_BALANCE :
    res = camera.GetCameraControl(::FEATURE_WHITE_BALANCE)->SetAutoMode(on);
    break;
  case DC1394_FEATURE_HUE:
    res = camera.GetCameraControl(::FEATURE_HUE)->SetAutoMode(on);
    break;
  case DC1394_FEATURE_SATURATION:
    res = camera.GetCameraControl(::FEATURE_SATURATION)->SetAutoMode(on);
    break;
  case DC1394_FEATURE_GAMMA:
    res = camera.GetCameraControl(::FEATURE_GAMMA)->SetAutoMode(on);
    break;
  case DC1394_FEATURE_SHUTTER:
    res = camera.GetCameraControl(::FEATURE_SHUTTER)->SetAutoMode(on);
    break;
  case DC1394_FEATURE_GAIN:
    res = camera.GetCameraControl(::FEATURE_GAIN)->SetAutoMode(on);
    break;
  case DC1394_FEATURE_IRIS:
    res = camera.GetCameraControl(::FEATURE_IRIS)->SetAutoMode(on);
    break;
  case DC1394_FEATURE_FOCUS:
    res = camera.GetCameraControl(::FEATURE_FOCUS)->SetAutoMode(on);
    break;
  case DC1394_FEATURE_TRIGGER:
    break;
  case DC1394_FEATURE_ZOOM:
    res = camera.GetCameraControl(::FEATURE_ZOOM)->SetAutoMode(on);
    break;
  case DC1394_FEATURE_PAN:
    break;
  case DC1394_FEATURE_TILT:
    break;
  case DC1394_FEATURE_OPTICAL_FILTER:
    break;
  default:
    BIASERR("VideoSource_DCAM::SetAutoMode(): Unkown Feature");
    return -1;
  }

  if (res != CAM_SUCCESS) {
    BIASERR("Error setting AutoMode for feature "<<feature
      <<", SetAutoMode("<<on<<") returned "<<res<<" !!!");
    return -1;
  }

  return 0;
}



void VideoSource_DCAM::SetAutoShutter(bool b)
{
  if (camera.GetCameraControl(::FEATURE_SHUTTER)->SetAutoMode(b)
    != CAM_SUCCESS) {
      BIASERR("Error setting shutter to auto mode!!!");
  }
}

bool VideoSource_DCAM::GetAutoShutter()
{
  return camera.GetCameraControl(::FEATURE_SHUTTER)->HasAutoMode();
}

void VideoSource_DCAM::SetAutoGain(bool b)
{
  if (camera.GetCameraControl(::FEATURE_GAIN)->SetAutoMode(b)
    != CAM_SUCCESS) {
      BIASERR("Error setting gain to auto mode!!!");
  }
}

bool VideoSource_DCAM::GetAutoGain()
{
  return camera.GetCameraControl(::FEATURE_GAIN)->HasAutoMode();
}

void  VideoSource_DCAM::SetAutoBrightness(bool b){
   if (camera.GetCameraControl(::FEATURE_BRIGHTNESS)->SetAutoMode(b)
    != CAM_SUCCESS) {
      BIASERR("Error setting brigthness to auto mode!!!");
  }
}

bool  VideoSource_DCAM::GetAutoBrightness(){
  return camera.GetCameraControl(::FEATURE_BRIGHTNESS)->HasAutoMode();
}

int VideoSource_DCAM::SetBrightness(float brightness){
  //try to set gain via absolute value
  if (camera.GetCameraControl(::FEATURE_BRIGHTNESS)->HasAbsControl()) {
    float min=0.0,max=0.0;
    camera.GetCameraControl(::FEATURE_BRIGHTNESS)->GetRangeAbsolute(&min,&max);
    if ((brightness < min)||(brightness > max)) {
      BIASERR("Brightness " << brightness << " is out of range [" << min << ":" << max << "]");
      return -1;
    }
    if (!camera.GetCameraControl(::FEATURE_BRIGHTNESS)->HasManualMode()) {
      BIASERR("Gain is not controlled manually!!!");
      return -1;
    }
    if (camera.GetCameraControl(::FEATURE_BRIGHTNESS)->SetAutoMode(false)
      != CAM_SUCCESS) {
        BIASERR("Error setting gain to manual mode!!!");
        return -1;
    }
    if (camera.GetCameraControl(::FEATURE_BRIGHTNESS)->SetAbsControl(true)
      != CAM_SUCCESS) {
        BIASERR("Error setting gain to manual mode!!!");
        return -1;
    }
    if (camera.GetCameraControl(::FEATURE_BRIGHTNESS)->SetValueAbsolute(brightness)
      != CAM_SUCCESS) {
        BIASERR("Error setting gain with SetValueAbsolute!!!");
        return -1;
    }
    return 0;
  }else{
    //here you should set the register values as for gain
    BIASERR("Setting Brightness absolute is not supported, setting register value is not finished.");
    return -1;
  }
}

float VideoSource_DCAM::GetBrightness(){
  camera.GetCameraControl(::FEATURE_BRIGHTNESS)->Inquire();
  float brightness = -1;
  //if cam doesn't support absolute settings for gain, it has to be
  //calculated from register data (long) -- TODO
  if (camera.GetCameraControl(::FEATURE_BRIGHTNESS)->HasAbsControl())
    camera.GetCameraControl(::FEATURE_BRIGHTNESS)->GetValueAbsolute(&brightness);
  else
    BIASERR("Cam doesn't support absolute values for shutter!!! FIXME");
  return brightness;
}

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

void VideoSource_DCAM::SetModeAndFramerate(BIAS::dc1394video_mode_t mode, float framerate){

  string s;

  switch(mode){
    case DC1394_VIDEO_MODE_160x120_YUV444:
      DcamFormat_ = 0;
      DcamMode_ = 0;
      break;
    case DC1394_VIDEO_MODE_320x240_YUV422:
      DcamFormat_ = 0;
      DcamMode_ = 1;
      break;
    case DC1394_VIDEO_MODE_640x480_YUV411:
      DcamFormat_ = 0;
      DcamMode_ = 2;
      break;
    case DC1394_VIDEO_MODE_640x480_YUV422:
      DcamFormat_ = 0;
      DcamMode_ = 3;
      break;
    case   DC1394_VIDEO_MODE_640x480_RGB8:
      DcamFormat_ = 0;
      DcamMode_ = 4;
      break;
    case      DC1394_VIDEO_MODE_640x480_MONO8:
      DcamFormat_ = 0;
      DcamMode_ = 5;
      break;
    case      DC1394_VIDEO_MODE_640x480_MONO16:
      DcamFormat_ = 0;
      DcamMode_ = 6;
      break;
    case DC1394_VIDEO_MODE_800x600_YUV422:
      DcamFormat_ = 1;
      DcamMode_ = 0;
      break;
    case    DC1394_VIDEO_MODE_800x600_RGB8:
      DcamFormat_ = 1;
      DcamMode_ = 1;
      break;
    case    DC1394_VIDEO_MODE_800x600_MONO8:
      DcamFormat_ = 1;
      DcamMode_ = 2;
      break;
    case DC1394_VIDEO_MODE_800x600_MONO16:
      DcamFormat_ = 1;
      DcamMode_ = 6;
      break;
    case DC1394_VIDEO_MODE_1024x768_YUV422:
      DcamFormat_ = 1;
      DcamMode_ = 3;
      break;
    case DC1394_VIDEO_MODE_1024x768_RGB8:
      DcamFormat_ = 1;
      DcamMode_ = 4;
      break;
    case DC1394_VIDEO_MODE_1024x768_MONO8:
      DcamFormat_ = 1;
      DcamMode_ = 5;
      break;
    case DC1394_VIDEO_MODE_1024x768_MONO16:
      DcamFormat_ = 1;
      DcamMode_ = 7;
      break;

    case DC1394_VIDEO_MODE_1280x960_YUV422:
      DcamFormat_ = 2;
      DcamMode_ = 0;
      break;
    case DC1394_VIDEO_MODE_1280x960_RGB8:
      DcamFormat_ = 2;
      DcamMode_ = 1;
      break;
    case DC1394_VIDEO_MODE_1280x960_MONO8:
      DcamFormat_ = 2;
      DcamMode_ = 2;
      break;
    case DC1394_VIDEO_MODE_1280x960_MONO16:
      DcamFormat_ = 2;
      DcamMode_ = 6;
      break;
    case DC1394_VIDEO_MODE_1600x1200_YUV422:
      DcamFormat_ = 2;
      DcamMode_ = 3;
      break;
    case DC1394_VIDEO_MODE_1600x1200_RGB8:
      DcamFormat_ = 2;
      DcamMode_ = 4;
      break;
    case DC1394_VIDEO_MODE_1600x1200_MONO8:
      DcamFormat_ = 2;
      DcamMode_ = 5;
      break;
    case DC1394_VIDEO_MODE_1600x1200_MONO16:
      DcamFormat_ = 2;
      DcamMode_ = 7;
      break;

    case DC1394_VIDEO_MODE_FORMAT7_0:
      DcamFormat_ = 7;
      DcamMode_ = 0;
      break;
    case DC1394_VIDEO_MODE_FORMAT7_1:
      DcamFormat_ = 7;
      DcamMode_ = 1;
      break;
    case DC1394_VIDEO_MODE_FORMAT7_2:
      DcamFormat_ = 7;
      DcamMode_ = 2;
      break;
    case DC1394_VIDEO_MODE_FORMAT7_3:
      DcamFormat_ = 7;
      DcamMode_ = 3;
      break;
    case DC1394_VIDEO_MODE_FORMAT7_4:
      DcamFormat_ = 7;
      DcamMode_ = 4;
      break;
    case DC1394_VIDEO_MODE_FORMAT7_5:
      DcamFormat_ = 7;
      DcamMode_ = 5;
      break;
    case DC1394_VIDEO_MODE_FORMAT7_6:
      DcamFormat_ = 7;
      DcamMode_ = 6;
      break;
    case DC1394_VIDEO_MODE_FORMAT7_7:
      DcamFormat_ = 7;
      DcamMode_ = 7;
      break;
    default:
      s = " ";
  }
  SetFPS(framerate);
  UserMode_ = true;
}

void VideoSource_DCAM::GetBytesPerPacketForFormat7(int camid, dc1394video_mode_t mode, int width, int height, unsigned int& bppmin, unsigned int& bppmax){
  if(camid != 0)
    camid = camid-1;

  C1394Camera camera;

  int num = camera.RefreshCameraList();
  int select = camera.SelectCamera(camid);
  camera.InitCamera();
  camera.SetVideoFormat(7);
  camera.SetVideoMode((int)(mode - DC1394_VIDEO_MODE_FORMAT7_MIN));
  C1394CameraControlSize* cs = camera.GetCameraControlSize();
  cs->SetPos(0,0);
  cs->SetSize((unsigned short)width,(unsigned short)height);
  unsigned short bmin,bmax;
  cs->GetBytesPerPacketRange(&bmin,&bmax);
  bppmin = bmin;
  bppmax = bmax;

}

dc1394video_mode_t VideoSource_DCAM::FormatAndModeToEnum(int Format, int Mode){
  dc1394video_mode_t modeOut = DC1394_VIDEO_MODE_640x480_MONO8;

  switch(Format){
  case 0:{

    switch (Mode){
  case 0:
    modeOut = DC1394_VIDEO_MODE_160x120_YUV444;
    break;

  case 1:
    modeOut = DC1394_VIDEO_MODE_320x240_YUV422;
    break;

  case 2:
    modeOut = DC1394_VIDEO_MODE_640x480_YUV411;
    break;

  case 3:
    modeOut = DC1394_VIDEO_MODE_640x480_YUV422;
    break;

  case 4:
    modeOut = DC1394_VIDEO_MODE_640x480_RGB8;
    break;

  case 5:
    modeOut = DC1394_VIDEO_MODE_640x480_MONO8;
    break;

  case 6:
    modeOut = DC1394_VIDEO_MODE_640x480_MONO16;
    break;
    }
         }
         break;

  case 1:{
    switch(Mode){
  case 0:
    modeOut = DC1394_VIDEO_MODE_800x600_YUV422;
    break;

  case 1:
    modeOut = DC1394_VIDEO_MODE_800x600_RGB8;
    break;

  case 2:
    modeOut = DC1394_VIDEO_MODE_800x600_MONO8;
    break;

  case 3:
    modeOut = DC1394_VIDEO_MODE_1024x768_YUV422;
    break;

  case 4:
    modeOut = DC1394_VIDEO_MODE_1024x768_RGB8;
    break;

  case 5:
    modeOut = DC1394_VIDEO_MODE_1024x768_MONO8;
    break;

  case 6:
    modeOut = DC1394_VIDEO_MODE_800x600_MONO16;
    break;

  case 7:
    modeOut = DC1394_VIDEO_MODE_1024x768_MONO16;
    break;
    }

         }
         break;

  case 2:{
    switch(Mode){
  case 0:
    modeOut = DC1394_VIDEO_MODE_1280x960_YUV422;
    break;

  case 1:
    modeOut = DC1394_VIDEO_MODE_1280x960_RGB8;
    break;

  case 2:
    modeOut = DC1394_VIDEO_MODE_1280x960_MONO8;
    break;

  case 3:
    modeOut = DC1394_VIDEO_MODE_1600x1200_YUV422;
    break;

  case 4:
    modeOut = DC1394_VIDEO_MODE_1600x1200_RGB8;
    break;

  case 5:
    modeOut = DC1394_VIDEO_MODE_1600x1200_MONO8;
    break;

  case 6:
    modeOut = DC1394_VIDEO_MODE_1280x960_MONO16;
    break;

  case 7:
    modeOut = DC1394_VIDEO_MODE_1600x1200_MONO16;
    break;
    }
         }
         break;

  case 7:{
    switch(Mode){
  case 0:
    modeOut = DC1394_VIDEO_MODE_FORMAT7_0;
    break;
  case 1:
    modeOut = DC1394_VIDEO_MODE_FORMAT7_1;
    break;
  case 2:
    modeOut = DC1394_VIDEO_MODE_FORMAT7_2;
    break;
  case 3:
    modeOut = DC1394_VIDEO_MODE_FORMAT7_3;
    break;
  case 4:
    modeOut = DC1394_VIDEO_MODE_FORMAT7_4;
    break;
  case 5:
    modeOut = DC1394_VIDEO_MODE_FORMAT7_5;
    break;
  case 6:
    modeOut = DC1394_VIDEO_MODE_FORMAT7_6;
    break;
  case 7:
    modeOut = DC1394_VIDEO_MODE_FORMAT7_7;
    break;
      }
    }
  }
  return modeOut;
}

int VideoSource_DCAM::SetColorFromMode_()
{
  switch(f7ColorCoding_){
    case DC1394_COLOR_CODING_RAW8:
      ColorMode_ = ImageBase::CM_Bayer_RGGB;
      //cout<<"SCFM: mono8 RGGB:"<<endl;
      //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_MONO16:
      ColorChannels_ = 1;
      ColorMode_ = ImageBase::CM_Grey;
      BytesPerPixel_ = 2.0;
      break;

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

  // DC1394_COLOR_CODING_RGB16,
  //DC1394_COLOR_CODING_MONO16S,
  // DC1394_COLOR_CODING_RGB16S,
  //DC1394_COLOR_CODING_RAW8,
  //DC1394_COLOR_CODING_RAW16
  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;
}

#include <Base/Common/BIASpragmaEnd.hh>