cvd/Linux/v4lcontrol.h

#ifndef CVD_V4LCONTROL_H
#define CVD_V4LCONTROL_H

#include <string>
#include <map>
#include <vector>

#include <linux/videodev2.h>

#include <cvd/exceptions.h>

namespace CVD {

namespace Exceptions
{
    namespace V4LControl
    {
    struct All: public CVD::Exceptions::All
    {
    };
    struct DeviceOpen: public All {DeviceOpen(std::string dev); 
    };

    struct ParameterNotSupported: public All {
        ParameterNotSupported(std::string);  
        ParameterNotSupported(unsigned int); 
    };

    struct GetValue: public All {GetValue(std::string); 
    };

    struct SetValue: public All {SetValue(std::string); 
    };

    struct QueryParameters: public All {QueryParameters(std::string); 
    };

    }
}


class V4LControl {
public:
    V4LControl( int fd, bool report = true );
    V4LControl( const std::string & name, bool report = true );


    void exposure( int );
    int  exposure(void);

    void autoexposure(bool);
    bool autoexposure();

    void gain( double );
    double gain(void);

    void autogain(bool);
    bool autogain(void);

    void brightness(double);
    double brightness(void);

    void contrast(double);
    double contrast(void);

    void saturation(double);
    double saturation(void);


    unsigned int getId( const std::string & name ) const;
    std::string getName( unsigned int id ) const;
    std::vector<unsigned int> supportedParameters(void) const;
    std::vector<std::string> supportedParameterNames(void) const;

    inline bool isSupported( const std::string & name ) const {
        return (controlNames.find(name) != controlNames.end());
    }
    inline void set( const std::string & name, int value ){
        set(getId(name), value);
    }
    inline int get( const std::string & name ){
        return get(getId(name));
    }
    inline int type( const std::string & name ){
        return type(getId(name));
    }
    inline std::map<unsigned int, std::string> menuValues( const std::string & name ){
        return menuValues(getId(name));
    }
    inline int defaultValue( const std::string & name ){
        return defaultValue(getId(name));
    }
    inline int min( const std::string & name ){
        return min(getId(name));
    }
    inline int max( const std::string & name ){
        return max(getId(name));
    }
    inline int step( const std::string & name ){
        return step(getId(name));
    }

    inline bool isSupported( unsigned int id ) const {
        return (controlData.find(id) != controlData.end());
    }
    void set( unsigned int id, int value);
    int get( unsigned int id );
    int type( unsigned int id );
    std::map<unsigned int, std::string> menuValues( unsigned int id ) const ;
    int defaultValue( unsigned int id ) const;
    int min( unsigned int id ) const;
    int max( unsigned int id ) const;
    int step( unsigned int id ) const;


    int getQueryStruct( v4l2_queryctrl & query ) const;
    void getMenuStruct( unsigned int id, std::vector<v4l2_querymenu> & menu ) const;
    int setControlStruct( v4l2_control & value );
    int getControlStruct( v4l2_control & value ) const;

    inline int getFile(void) const { return device; }

    inline const std::string & getDevice(void) const { return deviceName; }

    inline void setReportErrors( bool report ) { reportErrors = report; }
    inline bool getReportErrors(void) const { return reportErrors; }

protected:
    int device;
    std::string deviceName;
    struct v4l2_control control;
    bool reportErrors;

    void queryControls(void);

    std::map<std::string, unsigned int> controlNames;
    std::map<unsigned int, v4l2_queryctrl> controlData;
    std::map<unsigned int, std::vector<v4l2_querymenu> >  menuData;
};

} // namespace CVD

#endif