cam_usb.h

Go to the documentation of this file.

/*
 * \file    cam_usb.h
 *  
 * \brief   USB-Camera driver using 4vl2 and GStreamer.
 *
 * \details Based on the Rock-CameraInterface. Can be used
 *          for the Gumstix Camera as well.
 *          
 *          German Research Center for Artificial Intelligence\n
 *          Project: Rimres
 *
 * \date    23.11.11
 *
 * \author  Stefan.Haase@dfki.de
 */

#ifndef _CAM_USB_CONFIG_H_
#define _CAM_USB_CONFIG_H_

#include <sys/time.h>

#include "camera_interface/CamInterface.h"

#include "cam_gst.h"
#include "cam_config.h"

namespace camera 
{

    enum CAM_USB_MODE {
        CAM_USB_NONE,
        CAM_USB_V4L2,
        CAM_USB_GST
    };

    static const std::string ModeTxt[] = { "CAM_USB_NONE", "CAM_USB_V4L2", "CAM_USB_GST" };
class CamUsb : public CamInterface {

 public: // STATICS
    static const uint32_t CAM_ID = 0;

 public: // CAM USB
    CamUsb(std::string const& device);

    ~CamUsb();

    void fastInit(int width, int height);
    
    virtual int listCameras(std::vector<CamInfo> &cam_infos)const;

    virtual bool open(const CamInfo &cam,const AccessMode mode=Master);

    bool isOpen()const;

    virtual const CamInfo* getCameraInfo()const;

    virtual bool close();

    virtual bool grab(const GrabMode mode = SingleFrame, const int buffer_len=1);              

    virtual bool retrieveFrame(base::samples::frame::Frame &frame,const int timeout=1000);

    bool storeFrame(base::samples::frame::Frame& frame, std::string const& file_name);

    virtual bool isFrameAvailable();

    virtual int skipFrames();

    virtual bool setIpSettings(const CamInfo &cam, const IPSettings &ip_settings)const;

    virtual bool setAttrib(const int_attrib::CamAttrib attrib, const int value);

    virtual bool setAttrib(const double_attrib::CamAttrib attrib, const double value);

    virtual bool setAttrib(const str_attrib::CamAttrib attrib,const std::string value) {
        throw std::runtime_error("setAttrib str_attrib is not yet implemented for the camera interface!");
        return 0;
    }

    virtual bool setAttrib(const enum_attrib::CamAttrib attrib);

    virtual bool isAttribAvail(const int_attrib::CamAttrib attrib);

    virtual bool isAttribAvail(const double_attrib::CamAttrib attrib);

    virtual bool isAttribAvail(const str_attrib::CamAttrib attrib) {
        throw std::runtime_error("isAttribAvail str_attrib is not yet implemented for the camera interface!");
        return 0;
    }
                
    virtual bool isAttribAvail(const enum_attrib::CamAttrib attrib);

    virtual int getAttrib(const int_attrib::CamAttrib attrib);

    virtual double getAttrib(const double_attrib::CamAttrib attrib);

    virtual std::string getAttrib(const str_attrib::CamAttrib attrib) {
        throw std::runtime_error("getAttrib str_attrib is not yet implemented for the camera interface!");
        return 0;
    }

    virtual bool isAttribSet(const enum_attrib::CamAttrib attrib);

    bool isV4L2AttribAvail(const int control_id, std::string name = "");

    int getV4L2Attrib(const int control_id);

    bool setV4L2Attrib(const int control_id, const int value);

    bool setFrameSettings(const base::samples::frame::frame_size_t size,
                                const base::samples::frame::frame_mode_t mode,
                                const uint8_t color_depth,
                                const bool resize_frames = true);
    
    /*
    virtual bool setFrameSettings(const base::samples::frame::Frame &frame,
                                const bool resize_frames = true);
    */

    virtual bool getFrameSettings(base::samples::frame::frame_size_t &size,
                                    base::samples::frame::frame_mode_t &mode,
                                    uint8_t &color_depth);

    virtual bool triggerFrame();

    virtual bool setToDefault();
    
    bool printCameraInformations();

    //virtual bool setFrameToCameraFrameSettings(base::samples::frame::Frame &frame);

    virtual bool setCallbackFcn(void (*pcallback_function)(const void* p),void *p) {

        if(!pcallback_function)
            throw std::runtime_error ("You can not set the callback function to null!!! "
            "Otherwise CamUsb::callUserCallbackFcn would not be thread safe.");

        mpCallbackFunction = pcallback_function;
        mpPassThroughPointer = p;

        return true;
    }

    virtual void synchronizeWithSystemTime(uint32_t time_interval)
    {
    throw std::runtime_error("This camerea does not support synchronizeWithSystemTime. "
                       "The timestamp of the camera frame will be invalid.");
    };

    virtual void saveConfiguration(uint8_t index) {
        throw std::runtime_error("This camerea does not support saveConfiguration.");
    }

    virtual void loadConfiguration(uint8_t index) {
        throw std::runtime_error("This camerea does not support loadConfiguration.");
    }

    virtual void getRange(const double_attrib::CamAttrib attrib,double &dmin,double &dmax) {
        throw std::runtime_error("This camerea does not support getRange for double_attrib.");
    }

    virtual void getRange(const int_attrib::CamAttrib attrib,int &imin,int &imax);

    virtual int getFileDescriptor() const;

    inline enum CAM_USB_MODE getCamMode() {
        return mCamMode;
    }
    
    double calculateFPS() {
        if(act_grab_mode_ == Stop) {
            return 0;
        }
        timeval stop_time_grabbing;
        gettimeofday(&stop_time_grabbing, 0);
        double sec = stop_time_grabbing.tv_sec - mStartTimeGrabbing.tv_sec;
        if(sec == 0)
            return 0;
        else
            return mReceivedFrameCounter / sec;
    }

 private:
    CamUsb(){};

    enum CAM_USB_MODE mCamMode;

    void changeCameraMode(enum CAM_USB_MODE cam_usb_mode);

    CamGst* mCamGst;
    CamConfig* mCamConfig;
    std::string mDevice;

    // Pipeline has been created and is running. No further configuration possible.
    bool mIsOpen; 

    struct CamInfo mCamInfo; 

    std::map<int_attrib::CamAttrib, int> mMapAttrsCtrlsInt;

    // Framerate set on the camera internally. If available it will set to > 0 during startup.
    // Will be set if the pipeline is not running and the fps of the camera is requested.
    float mFps;
    int mBpp;
    timeval mStartTimeGrabbing;
    int mReceivedFrameCounter;
    
    // FD driven image receiving (?).
    void (*mpCallbackFunction)(const void* p);
    void* mpPassThroughPointer;

    void createAttrsCtrlMaps(CamConfig* cam_config);
};

} // end namespace camera

#endif