VideoSource_V4L.hh

/* 
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003, 2004    (see file CONTACTS for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS 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.

BIAS 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 BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef __BIASVIDEOSOURCE_V4L_HH__
#define __BIASVIDEOSOURCE_V4L_HH__

#include <bias_config.h>

#ifndef BIAS_HAVE_V4L
#  error Please recompile BIAS with BUILD_V4L to use VideoSource V4L.
#endif 
#ifndef BIAS_HAVE_PTHREADS
#  error BIAS_HAVE_PTHREADS not defined. But BIAS::VideoSource_V4L needs pthreads (on Unix and Win32). Please enable USE_PTHREADS in CMake configure step.
#endif

#include <VideoSource/VideoSource_Base.hh>

#ifdef BIAS_HAVE_LIBJPEG
#  include <Base/Image/CompressJpeg.hh>
#  include <Base/Image/ImageConvert.hh>
#  include <Image/Camera.hh>
#endif

#include <linux/videodev2.h>
#include <pthread.h>
#include <sys/time.h>


namespace BIAS
{
/** \class VideoSource_V4L 
    \ingroup g_videosource
    \author evers, v4l2 by grest
    \see ExampleV4L.cpp
    \brief This class extends VideoSource for the use of Video4Linux 
    supported devices like framegrabber, USB cameras.
*/
  class VideoSource_V4L : public VideoSource
  {
 
  public: 
    VideoSource_V4L();
    virtual ~VideoSource_V4L();
  
    int GetAllDevices(std::vector<std::string> &devices);

    int GetCapabilities(VideoSourceCapabilities &caps);
    int GetCapabilities(const char *device, VideoSourceCapabilities &caps);
  

    /**\brief if more than one channel is present names can are returned here.
    *  the position in the vector corresponds to the channel number in SetChannel()
    *  \attention GetCapabilities() has to be called before */
    void GetDeviceChannelNames(std::vector<std::string> &names);

    virtual int OpenDevice();
    virtual int OpenDevice(const char *device);
    virtual int OpenDevice(int device);
    virtual int CloseDevice();
  
    /** \brief blocks until a new frame arrives from the cam,
        if dont want blocking set waitForNew() to false
        \param image[out]: the grabbed image*/
    virtual int GrabSingle(BIAS::Camera <unsigned char> &image);

    int PreGrab();
    int PostGrab();

    float GetGain();
    int SetGain(float g);

    bool HasControlBrightness();
    /* Value: 0<=g<=100 */
    float GetBrightness();
    /* Value: 0<=g<=100 */
    int SetBrightness(float g);

    bool HasControlContrast();
    /* Value: 0<=g<=100 */
    float GetContrast();
    /* Value: 0<=g<=100 */
    int SetContrast(float g);

    bool HasControlShutter();
    /* Value: 0<=g<=1.0 */
    float GetShutter();
    /* Value: 0<=g<=1.0 */
    int SetShutter(float g);
    void SetAutoShutter(bool b);
    bool GetAutoShutter();

    bool HasControlGain();
    void SetAutoGain(bool b);
    bool GetAutoGain();

    bool HasControlWhiteBalance(){return false;};
    void SetAutoBrightness(bool b){};
    bool GetAutoBrightness(){return false;};

    /// Reset digital zoom, pan and tilt to defaults to ensure
    /// compliance with calibration.
    void ResetPanTiltZoom();

    //////////////////////////////////////////////////////////
  protected:

#ifdef BIAS_HAVE_LIBJPEG
    BIAS::JpegHandler Decompressor_;
    BIAS::Camera<unsigned char> jpegImg_;
#endif //BIAS_HAVE_LIBJPEG
   
    int fd;

    struct v4l2_requestbuffers reqBuf;
    struct v4l2_capability   capability2;
    struct v4l2_format       format2_;
    struct v4l2_format       formatRGB_;
    struct v4l2_buffer buffer_;
    unsigned int numBuffers_;

    struct v4l2_queryctrl ControlBrightness_;
    struct v4l2_queryctrl ControlContrast_;
    struct v4l2_queryctrl ControlGain_;
    struct v4l2_queryctrl ControlShutter_;
    struct v4l2_queryctrl ControlAutoGain_;
    struct v4l2_queryctrl ControlZoom_;
    struct v4l2_queryctrl ControlPanReset_;
    struct v4l2_queryctrl ControlTiltReset_;

    bool newFrame_;
    bool isJPEG_;
    /**\cond HIDDEN_SYMBOLS */
    struct buffer {
      void * start;
      size_t length;
    };
    /** \endcond */
    std::vector<struct buffer> Buffers_;
    unsigned ActiveFrame_;
    bool ReadFirstFrame_;
    std::vector<BIAS::Camera<unsigned char> > Frame_;


    pthread_t ContinousThread_;
    pthread_mutex_t ActiveFrameMutex_;

    struct timeval GrabTime_;

    static void *GrabContThread_(void * arg);
    void FixIdentifierString_();

    std::vector<std::string> deviceChannelNames_;
    std::map<std::string , std::string> ModelNameToDevice_;
    v4l2_field interlaceMode_;

  private:
    int xioctl_(int fd, int request, void *arg);
    // initializes Buffers_ using mmap
    int InitMMap_();
    // initialses the device
    int InitDevice_();
    // queues all buffers ans starts the streaming by calling STREAMON
    int StartCapturing_();
    // stops streaming by calling STREAMOFF
    int StopCapturing_();
    // calls uninit
    int UninitMMap_();
    // alternately fills Frame_[0] and Frame_[1]
    int ReadFrame_();
  };

} // namespace MIP


#endif