/home/fwph/code/wurde/rde/utils/WURDE1394Camera.cpp

Go to the documentation of this file.

#include <WURDECam.H>
#include <WURDE1394Camera.H>
#include <Logger.H>
#include <signal.h>
#include <dc1394/dc1394_conversions.h>
#include <dc1394/dc1394_control.h>

using namespace std;
using namespace WURDE;
using namespace WURDEVision;

WURDE1394Camera::WURDE1394CameraFinder WURDE1394Camera::s_finder;

void WURDE1394Camera::WURDE1394CameraFinder::init(){

}

dc1394camera_t *WURDE1394Camera::WURDE1394CameraFinder::getCameraByID(u_int64_t id){
        //      WURDE1394Camera *retval=NULL;
        dc1394camera_t *retval=NULL;
        dc1394camera_t **cameras=NULL;
        
        unsigned int numCameras, err=dc1394_find_cameras(&cameras, &numCameras);
        
        if (err!=DC1394_SUCCESS) {
                fprintf( stderr, "Unable to look for cameras\n\n"
                         "Please check \n"
                         "  - if the kernel modules `ieee1394',`raw1394' and `ohci1394' are loaded \n"
                         "  - if you have read/write access to /dev/raw1394\n\n");
                exit(1);
        }
        
        if (numCameras<1) {
                fprintf(stderr, "no cameras found :(\n");
                exit(1);
        }
        g_debug("Looking for the camera..");
        for(unsigned int i=0;i<numCameras;i++){
                cout << cameras[i]->euid_64 << " looking for " << id << endl;
                if(cameras[i]->euid_64==id){
                        g_debug("Found the cam");
                        retval=cameras[i];
                        m_cameras[id]=retval;
                        //                      retval=new WURDE1394Camera(cameras[i]);
                }else{
                        g_debug("Not this camera.");
                        dc1394_free_camera(cameras[i]);
                }
        }
        
        return retval;
        
}

/**************************************************************************************/

WURDE1394Camera::WURDE1394Camera(std::string name, std::map<std::string,std::string> camOptions) :
        WURDECamera(name,camOptions){
        m_camera=NULL;
        
        //sensible defaults
        m_mode=DC1394_VIDEO_MODE_320x240_YUV422;
        m_framerate=DC1394_FRAMERATE_30;
        m_speed=DC1394_ISO_SPEED_400;
        
        m_imBuffer=NULL;
        m_init=false;
        //      _robotVision_global_cameraList.push_back(this);
        if(m_options.find("id")!=m_options.end()){
                m_id=strtoull(m_options["id"].c_str(),NULL,0);
                m_camera=s_finder.getCameraByID(m_id);          
        }else{
                g_logerror << "Initializing a firewire camera called " << m_name << " but have no id number to find it with!" << endl;
        }
        if(!m_camera){
                g_logerror << "Unable to obtain firewire camera " << m_name << " with id: " << camOptions["id"] << endl;
                m_haveCam=false;
        }else{
                m_haveCam=true;
        }
       
        m_haveYUV24=false;
        m_haveYUV422=false;
        m_haveGray=false;
        m_haveRGB=false;

        m_imageYUV24.second=NULL;
        m_imageYUV422.second=NULL;
        m_imageRGB.second=NULL;
        m_imageGray.second=NULL;
}

bool WURDE1394Camera::init(){
       
       if(!m_init){
              dc1394_video_set_iso_speed(m_camera, m_speed);
              dc1394_video_set_mode(m_camera, m_mode);
              dc1394_video_set_framerate(m_camera, m_framerate);
              
              if(m_options.find("brightness")!=m_options.end()){
                     setBrightness (strtol(m_options["brightness"].c_str(),NULL,10));
              }

              if(m_options.find("exposure")!=m_options.end()){
                     setExposure (strtol(m_options["exposure"].c_str(),NULL,10));
              }

              if(m_options.find("sharpness")!=m_options.end()){
                     setSharpness (strtol(m_options["sharpness"].c_str(),NULL,10));
              }

              if(m_options.find("hue")!=m_options.end()){
                     setHue (strtol(m_options["hue"].c_str(),NULL,10));
              }

              if(m_options.find("saturation")!=m_options.end()){
                     setSaturation (strtol(m_options["saturation"].c_str(),NULL,10));
              }

              if(m_options.find("gamma")!=m_options.end()){
                     setGamma (strtol(m_options["gamma"].c_str(),NULL,10));
              }

              if(m_options.find("shutter")!=m_options.end()){
                     setShutter (strtol(m_options["shutter"].c_str(),NULL,10));
              }

              if(m_options.find("gain")!=m_options.end()){
                     setGain (strtol(m_options["gain"].c_str(),NULL,10));
              }

              if(m_options.find("iris")!=m_options.end()){
                     setIris (strtol(m_options["iris"].c_str(),NULL,10));
              }

              if(m_options.find("focus")!=m_options.end()){
                     setFocus (strtol(m_options["focus"].c_str(),NULL,10));
              }

              if(m_options.find("zoom")!=m_options.end()){
                     setZoom (strtol(m_options["zoom"].c_str(),NULL,10));      
              }

              if(m_options.find("autoiris")!=m_options.end()){
                     if(m_options["autoiris"]=="true"){
                            setAutoIris(true);
                     }else{
                            setAutoIris(false);
                     }
              }


       }
       m_init=true;
       return true;
}

bool WURDE1394Camera::startCapture(){

       init();

       if (dc1394_capture_setup_dma(m_camera,NUM_DMA_BUFFERS,1)!=DC1394_SUCCESS) {
               g_logwarn << "Camera " << m_name << " not responding... Attempting to reset." << endl;
               stopCapture();
               if (dc1394_capture_setup_dma(m_camera,NUM_DMA_BUFFERS,1)!=DC1394_SUCCESS) {
                       g_error("Unable to setup the camera, check modes");
                       return false;
               }
       }


       if (dc1394_video_set_transmission(m_camera, DC1394_ON) !=DC1394_SUCCESS) {
              g_error("Unable to start transmission");
              return false;
       }
 
       dc1394switch_t status = DC1394_OFF;

       int i = 0;
       while( status == DC1394_OFF && i++ < 5 ) {
              usleep(50000);
              if (dc1394_video_get_transmission(m_camera, &status)!=DC1394_SUCCESS) {
                     g_error("Unable to get transmission status");
                     return false;
              }
       }

       if( i == 5 ) {
              g_error("Camera isn't turning on...");
              return false;
       }
       
       return true;
}

void WURDE1394Camera::stopCapture(){

       if (dc1394_video_set_transmission(m_camera, DC1394_OFF) !=DC1394_SUCCESS) {
              //              g_error("Unable to stop transmission");
       }

       if (dc1394_capture_stop(m_camera) !=DC1394_SUCCESS) {
              //              g_error("Unable to stop camera");
       }
       /*
       std::list<RobotVision::WURDE1394Camera *>::iterator iter;
       for(iter=_robotVision_global_cameraList.begin();
           iter!=_robotVision_global_cameraList.end();
           iter++){
              if((*iter)==this){
                     _robotVision_global_cameraList.erase(iter);
                     break;
              }
       }
       */
}

WURDEImage WURDE1394Camera::captureYUV24(){
        // Returning an image that has 8 bpp, 3 channels (y,u,v)
        // Known users of this format: 
        //   + CMVision
        g_wurdeCamErrno=ERROR_NOERROR;
       g_debug("Capturing YUV24..");
       if(m_haveYUV24){
              g_debug("Already have one. Returning.");
              return m_imageYUV24;
       }

       if(!m_haveFrame||!m_imBuffer){
              g_debug("Capturing new frame.");
              if(dc1394_capture_dma (&m_camera, 1, DC1394_VIDEO1394_WAIT)!=DC1394_SUCCESS){
                   g_error("Unable to capture a frame from the camera");
                   m_imageYUV24.second=NULL;
                   
                   return m_imageYUV24;
              }
              m_timestamp.now();
              m_imBuffer=dc1394_capture_get_dma_buffer(m_camera);
              char buffer[1024];
              sprintf(buffer,"new timestamp: %ld, %ld",m_timestamp.getSeconds(),m_timestamp.getUSeconds());
              g_debug(buffer);

              if(m_imBuffer){         
                     m_haveFrame=true;
              }else{

                     g_warn("Didn't get a frame this time");
                     m_imageYUV24.second=NULL;
                     g_wurdeCamErrno=ERROR_IMAGE_NOT_AVAILABLE;              
                     return m_imageYUV24;
              }

       }

       m_imageYUV24.first=m_timestamp;

       if(!m_haveYUV24){
              g_debug("Converting....");
              switch(m_mode){
              case DC1394_VIDEO_MODE_640x480_YUV411:
                     if(!m_imageYUV24.second){
                            m_imageYUV24.second=cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 3);
                     }
                     convert_yuv411_to_yuv24(m_imageYUV24.second, (unsigned char*) m_imBuffer);
                     break;
              case DC1394_VIDEO_MODE_640x480_YUV422:
                     if(!m_imageYUV24.second){
                            m_imageYUV24.second=cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 3);
                     }
                     convert_yuv422_to_yuv24(m_imageYUV24.second, (unsigned char*) m_imBuffer);
                     break;
              case DC1394_VIDEO_MODE_320x240_YUV422:
                     if(!m_imageYUV24.second){
                            m_imageYUV24.second=cvCreateImage(cvSize(320, 240), IPL_DEPTH_8U, 3);
                     }
                     convert_yuv422_to_yuv24(m_imageYUV24.second, (unsigned char*) m_imBuffer);
                     break;
              case DC1394_VIDEO_MODE_160x120_YUV444:                 
              default:
                     g_error("An unsupported (by this library) mode was requested");
                     g_wurdeCamErrno=ERROR_UNSUPPORTED_IMAGE_TYPE;
                     m_imageYUV24.second=NULL;
                     return m_imageYUV24;
                     break;
              }
       }

       m_haveYUV24=true;

       return m_imageYUV24;
}

WURDEImage WURDE1394Camera::captureGray(){
        g_wurdeCamErrno=ERROR_NOERROR;
       if(m_haveGray){
              return m_imageGray;
       }
       
       if(!m_haveFrame||!m_imBuffer){
              if(dc1394_capture_dma(&m_camera, 1, DC1394_VIDEO1394_WAIT)!=DC1394_SUCCESS){
                     g_error("Unable to capture a frame from the camera");
                     return m_imageGray;
              }
              m_timestamp.now();
              m_imBuffer=dc1394_capture_get_dma_buffer(m_camera);

              if(m_imBuffer){         
                     m_haveFrame=true;
              }else{
                      g_wurdeCamErrno=ERROR_IMAGE_NOT_AVAILABLE;
                     g_warn("Didn't get a frame this time");
                     return m_imageGray;
              }
       }

       m_imageGray.first=m_timestamp;

       if(!m_haveGray){
              switch(m_mode){
              case DC1394_VIDEO_MODE_640x480_YUV411:
                     if(!m_imageGray.second){
                            m_imageGray.second=cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 1);
                     }
                     convert_yuv411_to_gray(m_imageGray.second, m_imBuffer);

                     break;
              case DC1394_VIDEO_MODE_640x480_YUV422:
                     if(!m_imageGray.second){
                            m_imageGray.second=cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 1);
                     }  
                     convert_yuv422_to_gray(m_imageGray.second, m_imBuffer);
                     
                     break;
              case DC1394_VIDEO_MODE_320x240_YUV422:
                     if(!m_imageGray.second){
                            m_imageGray.second=cvCreateImage(cvSize(320, 240), IPL_DEPTH_8U, 1);
                     }
                     convert_yuv422_to_gray(m_imageGray.second, m_imBuffer);

                     break;
              case DC1394_VIDEO_MODE_160x120_YUV444:                 
                     if(!m_imageGray.second){
                            m_imageGray.second=cvCreateImage(cvSize(160, 120), IPL_DEPTH_8U, 1);
                     }
                     dc1394_convert_to_MONO8(m_imBuffer,(unsigned char *)m_imageGray.second->imageData,160,120,DC1394_BYTE_ORDER_UYVY,DC1394_COLOR_CODING_YUV444,8);
                     break;
              default:
                      g_wurdeCamErrno=ERROR_UNSUPPORTED_IMAGE_TYPE;
                     g_error("An unsupported (by this library) mode/image combination was requested");
                     return m_imageGray;
                     break;
              }
       }
       
       m_haveGray=true;
       return m_imageGray;
}

WURDEImage WURDE1394Camera::captureYUV422(){
        g_wurdeCamErrno=ERROR_NOERROR;
        //#warning No conversion from YUV411 to YUV422       
       if(m_haveYUV422){
              return m_imageYUV422;
       }

       if(!m_haveFrame||!m_imBuffer){
              if(dc1394_capture_dma(&m_camera, 1, DC1394_VIDEO1394_WAIT)!=DC1394_SUCCESS){
                     g_error("Unable to capture a frame from the camera");
                     return m_imageYUV422;
              }
              m_timestamp.now();
              m_imBuffer=dc1394_capture_get_dma_buffer(m_camera);

              if(m_imBuffer){         
                     m_haveFrame=true;
              }else{
                      g_wurdeCamErrno=ERROR_IMAGE_NOT_AVAILABLE;
                     g_warn("Didn't get a frame this time");
                     return m_imageYUV422;
              }
       }
        
       m_imageYUV422.first=m_timestamp;

       if(!m_haveYUV422){
              switch(m_mode){
              case DC1394_VIDEO_MODE_640x480_YUV411:
                     /*              if(!m_imageYUV24){
                            m_imageYUV24=cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 3);
                     }
                     convert_yuv411_to_yuv24(m_imageYUV24, (unsigned char*) m_imBuffer);
                     */
                     g_error("YUV411 capture to YUV422 image conversion not currently supported");
                     return m_imageYUV422;
                     break;
              case DC1394_VIDEO_MODE_640x480_YUV422:
                     if(!m_imageYUV422.second){
                            m_imageYUV422.second=cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 2);
                     }
                     memcpy(m_imageYUV422.second->imageData,m_imBuffer,640*480*2);
                     break;
              case DC1394_VIDEO_MODE_320x240_YUV422:
                     if(!m_imageYUV422.second){
                            m_imageYUV422.second=cvCreateImage(cvSize(320, 240), IPL_DEPTH_8U, 2);
                     }
                     memcpy(m_imageYUV422.second->imageData,m_imBuffer,320*240*2);
                     break;
              case DC1394_VIDEO_MODE_160x120_YUV444:                 
              default:
                      g_wurdeCamErrno=ERROR_UNSUPPORTED_IMAGE_TYPE;
                     g_error("An unsupported (by this library) mode was requested");
                     return m_imageYUV422;
                     break;
              }
       }
       
       m_haveYUV422=true;
       return m_imageYUV422;
}

WURDEImage WURDE1394Camera::captureRGB(){
        g_wurdeCamErrno=ERROR_NOERROR;
       if(m_haveRGB){
              return m_imageRGB;
       }
       
       if(!m_haveFrame||!m_imBuffer){
              if(dc1394_capture_dma(&m_camera, 1, DC1394_VIDEO1394_WAIT)!=DC1394_SUCCESS){
                     g_error("Unable to capture a frame from the camera");
                     return m_imageRGB;
              }
              m_timestamp.now();
              m_imBuffer=dc1394_capture_get_dma_buffer(m_camera);

              if(m_imBuffer){         
                     m_haveFrame=true;
              }else{
                      g_wurdeCamErrno=ERROR_IMAGE_NOT_AVAILABLE;
                     g_warn("Didn't get a frame this time");
                     return m_imageRGB;
              }
       }
       
       m_imageRGB.first=m_timestamp;

       if(!m_haveRGB){
              switch(m_mode){
              case DC1394_VIDEO_MODE_640x480_YUV411:
                     if(!m_imageRGB.second){
                            m_imageRGB.second=cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 3);
                     }
                     dc1394_convert_to_RGB8(m_imBuffer,(unsigned char *)m_imageRGB.second->imageData,640,480,DC1394_BYTE_ORDER_UYVY,DC1394_COLOR_CODING_YUV411,16);
                     break;
              case DC1394_VIDEO_MODE_640x480_YUV422:
                     if(!m_imageRGB.second){
                            m_imageRGB.second=cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 3);
                     }                
                     dc1394_convert_to_RGB8(m_imBuffer,(unsigned char *)m_imageRGB.second->imageData,640,480,DC1394_BYTE_ORDER_UYVY,DC1394_COLOR_CODING_YUV422,16);

                     break;
              case DC1394_VIDEO_MODE_320x240_YUV422:
                     if(!m_imageRGB.second){
                            m_imageRGB.second=cvCreateImage(cvSize(320, 240), IPL_DEPTH_8U, 3);
                     }
                     dc1394_convert_to_RGB8(m_imBuffer,(unsigned char *)m_imageRGB.second->imageData,320,240,DC1394_BYTE_ORDER_UYVY,DC1394_COLOR_CODING_YUV422,16);
                     break;
              case DC1394_VIDEO_MODE_160x120_YUV444:                 
                     if(!m_imageRGB.second){
                            m_imageRGB.second=cvCreateImage(cvSize(160, 120), IPL_DEPTH_8U, 3);
                     }
                     dc1394_convert_to_RGB8(m_imBuffer,(unsigned char *)m_imageRGB.second->imageData,160,120,DC1394_BYTE_ORDER_UYVY,DC1394_COLOR_CODING_YUV444,16);
                     break;
              default:
                      g_wurdeCamErrno=ERROR_UNSUPPORTED_IMAGE_TYPE;
                     g_error("An unsupported (by this library) mode/image combination was requested");
                     return m_imageRGB;
                     break;
              }
       }
       
       m_haveRGB=true;
       return m_imageRGB;
}


void WURDE1394Camera::resetFrame(){
       if(m_haveFrame){
              g_debug("Releasing buffer");
              if(dc1394_capture_dma_done_with_buffer(m_camera)!=DC1394_SUCCESS){
                     g_error("Error releasing the DMA buffer!");
              }
       }
       m_haveFrame=false;
       m_haveYUV422=false;
       m_haveYUV24=false;
       m_haveGray=false;
       m_haveRGB=false;
       m_imBuffer=NULL;
}

void WURDE1394Camera::setCameraDefaults(){
        setBrightness (1024);
        setExposure (128);
        setSharpness (128);
        //       setWhiteBalance (128,128);
        setHue (128);
        setSaturation (128);
        setGamma (128);
        setShutter (2048);
        setGain (0);
        setIris (2048);
        setFocus (256);
        setZoom (0);      
        setAutoIris(true);
        
}

unsigned int WURDE1394Camera::getBrightness(){
        unsigned int value;
        
        if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_BRIGHTNESS, &value)!=DC1394_SUCCESS){
                g_error("Unable to get camera brightness.");
                return 0;
        }
        
        return value;
        
}

unsigned int WURDE1394Camera::getExposure(){
        unsigned int value;
        
        if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_EXPOSURE, &value)!=DC1394_SUCCESS){
                g_error("Unable to get camera exposure.");
                return 0;
        }
        
        return value;
}

unsigned int WURDE1394Camera::getSharpness(){
        unsigned int value;
        
        if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_SHARPNESS, &value)!=DC1394_SUCCESS){
                g_error("Unable to get camera sharpness.");
                return 0;
        }
        
        return value;
}

unsigned int WURDE1394Camera::getHue(){
        unsigned int value;
        
        if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_HUE, &value)!=DC1394_SUCCESS){
                g_error("Unable to get camera hue.");
                return 0;
        }
        
        return value;
}

unsigned int WURDE1394Camera::getSaturation(){
        unsigned int value;
        
        if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_SATURATION, &value)!=DC1394_SUCCESS){
                g_error("Unable to get camera saturation.");
                return 0;
        }
        
        return value;
}

unsigned int WURDE1394Camera::getGamma(){
        unsigned int value;
        
        if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_GAMMA, &value)!=DC1394_SUCCESS){
                g_error("Unable to get camera gamma.");
                return 0;
        }
        
        return value;
}

unsigned int WURDE1394Camera::getShutter(){
        unsigned int value;
        
        if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_SHUTTER, &value)!=DC1394_SUCCESS){
                g_error("Unable to get camera shutter.");
                return 0;
        }
        
        return value;
}

unsigned int WURDE1394Camera::getGain(){
        unsigned int value;
        
        if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_GAIN, &value)!=DC1394_SUCCESS){
                g_error("Unable to get camera gain.");
                return 0;
        }
        
        return value;
}

unsigned int WURDE1394Camera::getIris(){
        unsigned int value;
        
        if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_IRIS, &value)!=DC1394_SUCCESS){
                g_error("Unable to get camera iris.");
                return 0;
        }
        
        return value;
}

unsigned int WURDE1394Camera::getFocus(){
        unsigned int value;
        
       if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_FOCUS, &value)!=DC1394_SUCCESS){
              g_error("Unable to get camera focus.");
              return 0;
       }

       return value;
}

unsigned int WURDE1394Camera::getTriggerDelay(){
       unsigned int value;

       if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_TRIGGER_DELAY, &value)!=DC1394_SUCCESS){
              g_error("Unable to get camera trigger delay.");
              return 0;
       }

       return value;
}

unsigned int WURDE1394Camera::getZoom(){
       unsigned int value;

       if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_ZOOM, &value)!=DC1394_SUCCESS){
              g_error("Unable to get camera zoom.");
              return 0;
       }

       return value;
}

unsigned int WURDE1394Camera::getPan(){
       unsigned int value;

       if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_PAN, &value)!=DC1394_SUCCESS){
              g_error("Unable to get camera pan.");
              return 0;
       }

       return value;
}

unsigned int WURDE1394Camera::getTilt(){
       unsigned int value;

       if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_TILT, &value)!=DC1394_SUCCESS){
              g_error("Unable to get camera tilt.");
              return 0;
       }

       return value;
}

unsigned int WURDE1394Camera::getOpticalFilter(){
       unsigned int value;

       if(dc1394_feature_get_value(m_camera, DC1394_FEATURE_OPTICAL_FILTER, &value)!=DC1394_SUCCESS){
              g_error("Unable to get camera optical filter.");
              return 0;
       }

       return value;
}


/**********************/

bool WURDE1394Camera::setBrightness(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_BRIGHTNESS, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera brightness.");
              return false;
       }

       return true;
}

bool WURDE1394Camera::setExposure(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_EXPOSURE, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera exposure.");
              return false;
       }

       return true;
}
bool WURDE1394Camera::setSharpness(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_SHARPNESS, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera sharpness.");
              return false;
       }

       return true;
}

bool WURDE1394Camera::setHue(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_HUE, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera hue.");
              return false;
       }

       return true;
}

bool WURDE1394Camera::setSaturation(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_SATURATION, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera saturation.");
              return false;
       }

       return true;
}

bool WURDE1394Camera::setGamma(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_GAMMA, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera gamma.");
              return false;
       }

       return true;
}

bool WURDE1394Camera::setShutter(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_SHUTTER, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera shutter.");
              return false;
       }

       return true;
}

bool WURDE1394Camera::setGain(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_GAIN, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera gain.");
              return false;
       }

       return true;
}

bool WURDE1394Camera::setIris(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_IRIS, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera iris.");
              return false;
       }

       return true;
}

bool WURDE1394Camera::setAutoIris(bool value){
       if(value){
              if(dc1394_feature_set_mode(m_camera, DC1394_FEATURE_IRIS, DC1394_FEATURE_MODE_AUTO)!=DC1394_SUCCESS){
                     g_error("Unable to set auto camera iris.");
                     return false;
              }
       }else{
              if(dc1394_feature_set_mode(m_camera, DC1394_FEATURE_IRIS, DC1394_FEATURE_MODE_MANUAL)!=DC1394_SUCCESS){
                     g_error("Unable to set auto camera iris.");
                     return false;
              }
       }

       return true;
}

bool WURDE1394Camera::setFocus(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_FOCUS, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera focus.");
              return false;
       }

       return true;
}

bool WURDE1394Camera::setTriggerDelay(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_TRIGGER_DELAY, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera trigger delay.");
              return false;
       }

       return true;
}

bool WURDE1394Camera::setZoom(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_ZOOM, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera zoom.");
              return false;
       }

       return true;
}


bool WURDE1394Camera::setPan(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_PAN, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera pan.");
              return false;
       }

       return true;
}

bool WURDE1394Camera::setTilt(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_TILT, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera tilt.");
              return false;
       }

       return true;
}

bool WURDE1394Camera::setOpticalFilter(unsigned int value){
       if(dc1394_feature_set_value(m_camera, DC1394_FEATURE_OPTICAL_FILTER, value)!=DC1394_SUCCESS){
              g_error("Unable to set camera optical filter.");
              return false;
       }

       return true;
}

---