peak_afl_icontroller.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_afl/peak_afl.h>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_skip_frames.hpp>
 
#include <peak_common/detail/peak_common_defines.hpp>
#include <peak_common/exceptions/peak_common_exceptions.hpp>
#include <peak_common/serialization/peak_common_iarchive.hpp>
#include <peak_common/serialization/peak_common_iserializable.hpp>
 
namespace peak
{
namespace pipeline
{
namespace modules
{
namespace autofeature
{

enum class ControllerType
{
    Focus,
    Brightness,
    WhiteBalance,
};

enum class ControllerMode
{
    Off,
    Continuous,
    Once
};

PEAK_COMMON_NO_DISCARD inline std::string ToString(ControllerType mode)
{
    if (mode == ControllerType::Focus)
    {
        return "Focus";
    }
    if (mode == ControllerType::Brightness)
    {
        return "Brightness";
    }
    if (mode == ControllerType::WhiteBalance)
    {
        return "WhiteBalance";
    }
    throw peak::common::InvalidParameterException("The given controller type is unknown!");
}
 
inline std::ostream& operator<<(std::ostream& os, ControllerType mode)
{
    return os << ToString(mode);
}

PEAK_COMMON_NO_DISCARD inline std::string ToString(ControllerMode mode)
{
    if (mode == ControllerMode::Off)
    {
        return "Off";
    }
    if (mode == ControllerMode::Continuous)
    {
        return "Continuous";
    }
    if (mode == ControllerMode::Once)
    {
        return "Once";
    }
    throw peak::common::InvalidParameterException("The given controller mode is unknown!");
}
 
inline std::ostream& operator<<(std::ostream& os, ControllerMode mode)
{
    return os << ToString(mode);
}
 
namespace detail
{
 
PEAK_COMMON_NO_DISCARD inline ControllerMode ToControllerMode(const std::string& mode)
{
    if (mode == "Off")
    {
        return ControllerMode::Off;
    }
    if (mode == "Continuous")
    {
        return ControllerMode::Continuous;
    }
    if (mode == "Once")
    {
        return ControllerMode::Once;
    }
    throw peak::common::InvalidParameterException("The given controller mode " + mode + " is unknown!");
}
 
PEAK_COMMON_NO_DISCARD inline peak_afl_controller_automode ToCType(ControllerMode controllerMode)
{
    switch (controllerMode)
    {
    case ControllerMode::Off:
        return PEAK_AFL_CONTROLLER_AUTOMODE_OFF;
    case ControllerMode::Continuous:
        return PEAK_AFL_CONTROLLER_AUTOMODE_CONTINUOUS;
    case ControllerMode::Once:
        return PEAK_AFL_CONTROLLER_AUTOMODE_ONCE;
    default:
        throw peak::common::InvalidParameterException("Unknown controller mode type");
    }
}
 
PEAK_COMMON_NO_DISCARD inline ControllerMode ToControllerMode(peak_afl_controller_automode controllerMode)
{
    switch (controllerMode)
    {
    case PEAK_AFL_CONTROLLER_AUTOMODE_OFF:
        return ControllerMode::Off;
    case PEAK_AFL_CONTROLLER_AUTOMODE_CONTINUOUS:
        return ControllerMode::Continuous;
    case PEAK_AFL_CONTROLLER_AUTOMODE_ONCE:
        return ControllerMode::Once;
    default:
        throw peak::common::InvalidParameterException("Unknown controller mode type");
    }
}
 
PEAK_COMMON_NO_DISCARD inline peak_afl_controllerType ToCType(ControllerType controllerType)
{
    switch (controllerType)
    {
    case ControllerType::Focus:
        return PEAK_AFL_CONTROLLER_TYPE_AUTOFOCUS;
    case ControllerType::Brightness:
        return PEAK_AFL_CONTROLLER_TYPE_BRIGHTNESS;
    case ControllerType::WhiteBalance:
        return PEAK_AFL_CONTROLLER_TYPE_WHITE_BALANCE;
    default:
        throw peak::common::InvalidParameterException("Unknown controller type");
    }
}

class IController : public peak::common::serialization::ISerializable
{
public:
    using FinishedCallback = std::function<void()>;
    using FinishedCallbackHandle = FinishedCallback*;
 
    explicit IController(peak::afl::Manager& manager)
        : m_manager{ manager }
    {}

    virtual ~IController() = default;

    IController(const IController&) = delete;
    IController& operator=(const IController&) = delete;

    IController(IController&&) = delete;
    IController& operator=(IController&&) = delete;

    PEAK_COMMON_NO_DISCARD virtual std::string GetName() const = 0;

    PEAK_COMMON_NO_DISCARD virtual ControllerType GetType() const = 0;

    virtual void SetMode(ControllerMode mode) = 0;

    PEAK_COMMON_NO_DISCARD virtual ControllerMode GetMode() const = 0;

    PEAK_COMMON_NO_DISCARD virtual bool IsRunning() const = 0;

    virtual void ResetToDefault() = 0;
 
protected:
    PEAK_COMMON_NO_DISCARD peak::afl::Manager& GetManager()
    {
        return m_manager;
    }
 
private:
    peak::afl::Manager& m_manager;
};
 
} // namespace detail
} // namespace autofeature
} // namespace modules
} // namespace pipeline 
} // namespace peak