cvd/Linux/dvbuffer3.h

/*                       
    This file is part of the CVD Library.

    Copyright (C) 2005 The Authors

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 
    51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
// -*- c++ -*-

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

namespace CVD
{
  namespace Exceptions
  {
    namespace DVBuffer3
    {
      struct All : public CVD::Exceptions::VideoBuffer::All 
      {
    All(std::string sWhat)
      {
        what = "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