v4lcontrol.h

#ifndef CVD_V4LCONTROL_H
#define CVD_V4LCONTROL_H

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

#include <linux/videodev2.h>

#include <cvd/exceptions.h>

namespace CVD
{

namespace Exceptions
{
    namespace V4LControl
    {
        struct All : public CVD::Exceptions::All
        {
            using CVD::Exceptions::All::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