dvbuffer3.h

// -*- c++ -*-

#ifndef __DVBUFFER_3_H
#define __DVBUFFER_3_H
#include <cvd/byte.h>
#include <cvd/colourspaces.h>
#include <cvd/rgb.h>
#include <cvd/videobuffer.h>
#include <inttypes.h>

namespace CVD
{
namespace Exceptions
{
    namespace DVBuffer3
    {
        struct All : public CVD::Exceptions::VideoBuffer::All
        {
            All(std::string sWhat)
                : CVD::Exceptions::VideoBuffer::All("DVBuffer3: " + sWhat)
            {
            }
        };
    }
}

namespace DV3
{
    enum DV3Feature
    {
        BRIGHTNESS,
        EXPOSURE,
        SHARPNESS,
        WHITE_BALANCE,
        HUE,
        SATURATION,
        GAMMA,
        SHUTTER,
        GAIN,
        IRIS,
        FOCUS,
        ZOOM,
        PAN,
        TILT,
        FRAME_RATE
    };

    enum DV3ColourSpace
    {
        MONO8,
        MONO16,
        MONO16S,
        RGB8,
        RGB16,
        RGB16S,
        YUV411,
        YUV422,
        YUV444,
        RAW8,
        RAW16
    };

    enum DV3ColourFilter
    {
        UNDEFINED = -1,
        RGGB = 0,
        GBRG = 1,
        GRBG = 2,
        BGGR = 3
    };

#ifndef DOXYGEN_IGNORE_INTERNAL
    // Translation helper classes to go from CVD-types to the above
    template <class C>
    struct CSConvert
    {
        static const DV3ColourSpace space = C::Error__type_not_valid_for_camera;
    };
    template <>
    struct CSConvert<byte>
    {
        static const DV3ColourSpace space = MONO8;
    };
    template <>
    struct CSConvert<short unsigned int>
    {
        static const DV3ColourSpace space = MONO16;
    };
    template <>
    struct CSConvert<yuv411>
    {
        static const DV3ColourSpace space = YUV411;
    };
    template <>
    struct CSConvert<yuv422>
    {
        static const DV3ColourSpace space = YUV422;
    };
    template <>
    struct CSConvert<Rgb<byte>>
    {
        static const DV3ColourSpace space = RGB8;
    };
    template <>
    struct CSConvert<bayer_bggr>
    {
        static const DV3ColourSpace space = RAW8;
    };
    template <>
    struct CSConvert<bayer_gbrg>
    {
        static const DV3ColourSpace space = RAW8;
    };
    template <>
    struct CSConvert<bayer_grbg>
    {
        static const DV3ColourSpace space = RAW8;
    };
    template <>
    struct CSConvert<bayer_rggb>
    {
        static const DV3ColourSpace space = RAW8;
    };
    template <>
    struct CSConvert<bayer_bggr16be>
    {
        static const DV3ColourSpace space = RAW16;
    };
    template <>
    struct CSConvert<bayer_gbrg16be>
    {
        static const DV3ColourSpace space = RAW16;
    };
    template <>
    struct CSConvert<bayer_grbg16be>
    {
        static const DV3ColourSpace space = RAW16;
    };
    template <>
    struct CSConvert<bayer_rggb16be>
    {
        static const DV3ColourSpace space = RAW16;
    };

    template <class C>
    struct CSFilter
    {
        static const DV3ColourFilter filter = UNDEFINED;
    };
    template <>
    struct CSFilter<bayer_bggr>
    {
        static const DV3ColourFilter filter = BGGR;
    };
    template <>
    struct CSFilter<bayer_gbrg>
    {
        static const DV3ColourFilter filter = GBRG;
    };
    template <>
    struct CSFilter<bayer_grbg>
    {
        static const DV3ColourFilter filter = GRBG;
    };
    template <>
    struct CSFilter<bayer_rggb>
    {
        static const DV3ColourFilter filter = RGGB;
    };
    template <>
    struct CSFilter<bayer_bggr16be>
    {
        static const DV3ColourFilter filter = BGGR;
    };
    template <>
    struct CSFilter<bayer_gbrg16be>
    {
        static const DV3ColourFilter filter = GBRG;
    };
    template <>
    struct CSFilter<bayer_grbg16be>
    {
        static const DV3ColourFilter filter = GRBG;
    };
    template <>
    struct CSFilter<bayer_rggb16be>
    {
        static const DV3ColourFilter filter = RGGB;
    };

    struct LibDCParams;
#endif

    class RawDVBuffer3 : public virtual RawVideoBuffer
    {
        public:
        RawDVBuffer3(DV3ColourSpace colourspace,
            int nCamNumber = 0,
            uint64_t cam_guid = -1,
            int cam_unit = -1,
            bool verbose = 0,
            bool bus_reset = 0,
            ImageRef irSize = ImageRef(-1, -1),
            float fFrameRate = -1.0,
            ImageRef irOffset = ImageRef(-1, -1),
            int format7_mode = -1);

        ~RawDVBuffer3();
        static void stopAllTransmissions(void);
        inline ImageRef size() { return mirSize; }
        inline ImageRef offset() { return mirOffset; }
        inline double frame_rate() { return mdFramerate; }
        inline DV3ColourFilter colour_filter() { return mColourfilter; }

        VideoFrame<byte>* get_frame();
        void put_frame(VideoFrame<byte>* f);
        bool frame_pending();

        void set_feature_value(DV3Feature nFeature, unsigned int nValue);
        unsigned int get_feature_value(DV3Feature nFeature);
        std::pair<unsigned int, unsigned int> get_feature_min_max(DV3Feature nFeature);
        void auto_on_off(DV3Feature nFeature, bool bValue);
        void power_on_off(DV3Feature nFeature, bool bValue);

        private:
        ImageRef mirSize;
        ImageRef mirOffset;
        double mdFramerate;
        DV3ColourFilter mColourfilter;
        LibDCParams* mpLDCP;
    };

}

template <class pixel_T>
class DVBuffer3 : public VideoBuffer<pixel_T>, public DV3::RawDVBuffer3
{
    public:
    DVBuffer3(unsigned int nCamNumber = 0,
        ImageRef irSize = ImageRef(-1, -1),
        float fFPS = -1.0,
        ImageRef irOffset = ImageRef(-1, -1),
        bool verbose = 0,
        bool bus_reset = 0,
        int format7_mode = -1)
        : VideoBuffer<pixel_T>(VideoBufferType::Live)
        , RawDVBuffer3(DV3::CSConvert<pixel_T>::space, nCamNumber, 0, -1, verbose, bus_reset, irSize, fFPS, irOffset, format7_mode)
    {
        if(DV3::CSFilter<pixel_T>::filter != DV3::UNDEFINED && colour_filter() != DV3::CSFilter<pixel_T>::filter)
            throw(Exceptions::DVBuffer3::All("wrong colour filter expected"));
    }

    virtual ~DVBuffer3() { }
    double frame_rate() { return RawDVBuffer3::frame_rate(); }
    ImageRef size() { return RawDVBuffer3::size(); }
    virtual VideoFrame<pixel_T>* get_frame()
    {
        return reinterpret_cast<VideoFrame<pixel_T>*>(RawDVBuffer3::get_frame());
    }
    virtual void put_frame(VideoFrame<pixel_T>* f)
    {
        RawDVBuffer3::put_frame(reinterpret_cast<VideoFrame<byte>*>(f));
    }
    virtual bool frame_pending() { return RawDVBuffer3::frame_pending(); }
    virtual void seek_to(double) { }
};

}

#endif