VideoSource_DSHOW.hh

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

Copyright (C) 2003-2009    (see file CONTACT 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_DSHOW_HH__
#define __BIASVIDEOSOURCE_DSHOW_HH__

//include first, avoid macro collision
#include <bias_config.h>
#include <Gui/StringConv.hh>
#include <windows.h>
#include <atlbase.h>

#include <dshow.h>
#include <qedit.h>
#include <comutil.h>
#include <strmif.h>

#  ifdef Yield
#    undef Yield
#  endif
#include <VideoSource/VideoSource_Base.hh>
#include <VideoSource/VideoSourceCapabilities.hh>
#include <Image/Camera.hh>

namespace BIAS{

  /** 
      \class VideoSource_DSHOW    
      \ingroup g_videosource
      \author ischiller
      \brief This class extends VideoSource for the use of DirectShow devices
      you need Microsoft Windows SDK version 6.1 and Microsoft DirectX 9 SDK (November 2008)
  */


#if !defined __MYSAMPLE_GRABBER_CB_H
#define __MYSAMPLE_GRABBER_CB_H

  class MySampleGrabberCB : public ISampleGrabberCB {

  protected:
 
    // The media type we are processing
    AM_MEDIA_TYPE       mediaType;
  
  public:
   // constructor
    MySampleGrabberCB(int width, int height, int depth);
    // destructor
    ~MySampleGrabberCB();

    bool HasNewImage();   
    void SetNewImageCheck(bool check=true){
      bCheckNewImage_ = check;};
  
   Image<unsigned char>& GetImage(){
      return camera_;};
  protected:
    BIAS::Camera<unsigned char> camera_;
      
    unsigned char* lastMemorySample_;
    unsigned char* currentMemorySample_;
    int sampleLength_;    
    bool bCheckNewImage_;

    // This is the callback method called every time 
    STDMETHODIMP SampleCB(double SampleTime, IMediaSample *pSample);
    // the other TO IMPLEMENT method
    STDMETHODIMP BufferCB(double SampleTime, BYTE *pBuffer, long BufferLen);

    STDMETHODIMP QueryInterface(REFIID riid, void ** ppv);
    STDMETHODIMP_(ULONG) AddRef() { return 2; }
    STDMETHODIMP_(ULONG) Release() { return 1; }

  };


#endif

  class BIASVideoSource_EXPORT VideoSource_DSHOW : public VideoSource{
  
 
  public: 

    VideoSource_DSHOW(bool bShowDialogs = false);
    VideoSource_DSHOW(int width, int height,int depth,bool bShowDialogs = false);

    ~VideoSource_DSHOW();

    // query list of all available devices
    int GetAllDevices(std::vector<std::string> &devices);

    int OpenDevice(unsigned int width, unsigned int height, unsigned int channels,
           const char * device,BIAS::ImageBase::EColorModel model = BIAS::ImageBase::CM_RGB);
    int OpenDevice(const char * device);
    int OpenDevice();
    int CloseDevice();
    /** overwrites Base class function */
    void SetWaitForNew(bool waitForNew) {
      WaitForNew_=waitForNew; 
      if(FGCB != NULL)
        FGCB->SetNewImageCheck(waitForNew);
    };
    int GrabSingle(BIAS::Camera <unsigned char>  &image);
    int InitImage(BIAS::ImageBase &Image);
 
    void ResetPanTiltZoom(void);
 
    int PreGrab();
    int PostGrab();

    inline void SetCaptureDeviceName(std::string sName){
      sCaptureDeviceName_ = sName;};

    inline void SetSizeAndColorModel(int width, int height, 
                     int bytesperpixel=1, BIAS::ImageBase::EColorModel model = BIAS::ImageBase::CM_invalid){
      SetSize( width, height, bytesperpixel);
      SetColorModel(model);
      BIASColorModel_= model;
    };

    bool DisplayCameraProperties();

    void DisplaySourcePinProperties();
  
    bool DisplayFilterProperties( CComPtr<IBaseFilter> pFilter);
 

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

    //shutter  
    bool HasControlShutter();
    float GetShutter();
    /// Set shutter (exposure time) to exptime in seconds
    int SetShutter(float exptime);    
    void SetAutoShutter(bool b);
    bool GetAutoShutter();
  

    //Gain
    bool HasControlGain(){return false;};
    void SetAutoGain(bool b){BIASWARN("Unimplemented!");};
    bool GetAutoGain(){return false;};
    float GetGain(){return -1.0;};
    /// Set gain to g with g[dB]
    int SetGain(float g){return -1;};
       
    //Brightness
    bool HasControlBrightness();
    /* Value: 0<=g<=100 */
    float GetBrightness();
    /* Value: 0<=g<=100 */
    int SetBrightness(float g);
    void SetAutoBrightness(bool b);
    bool GetAutoBrightness();
    
    //Contrast
    bool HasControlContrast();
    /* Value: 0<=g<=100 */
    float GetContrast();
    /* Value: 0<=g<=100 */
    int SetContrast(float g);
    void SetAutoContrast(bool b);
    bool GetAutoContrast();


  protected:

    struct CameraControl {
      long int id; // property number on Win32, -1 means "unavailable
      long int min,max,stepping,standard,flags;
    };
    MySampleGrabberCB*   FGCB;
    bool              bCheckNewImage_;
    long                dDsBufferSize_;
    long *            pDsBuffer_;
    unsigned char *   pImageBuffer_;
    int     dWidth_;
    int     dHeight_;
    int     dDepth_;
    bool  bShowDialogs_;

    BIAS::Camera<unsigned char> camera_; 

    std::string sCaptureDeviceName_;

    HRESULT InitVideoCapture_();
    HRESULT GetInterfaces_(void);   
    HRESULT FindCaptureDevice_(IBaseFilter ** ppSrcFilter);
    HRESULT EnumFilters_(IFilterGraph *pGraph);

    void  InitCamControls_();

    void DetermineColorModel_();
    void DetermineBIASColorModel_();

    void DeleteMediaType_(AM_MEDIA_TYPE *pmt);

    bool DisplayPinProperties_( CComPtr<IPin> pSrcPin );
  
    HRESULT SaveGraphFile_(IGraphBuilder *pGraph, WCHAR *wszPath);

    BIAS::ImageBase::EColorModel BIASColorModel_;
    GUID MediaSubTypeColorModel_;

    CComPtr< IMediaControl >              pMediaControl_;
    CComPtr< IMediaEventEx >              pMediaEvent_;
    // for shutter
    CComPtr< IAMCameraControl >                     pCameraControl_;
    // for Brightness, Contrast, Gain, ...
    CComPtr< IAMVideoProcAmp >                    pVideoProcControl_;
    CComPtr< IPin >     pOutPin_;
    CComPtr< IPin >     pSampleOutPin_;
    IPin                              *pInPin_;
    CComPtr< ISampleGrabber >         pGrabber_;
    CComPtr< IBaseFilter >              pNullRenderer_;
    CComPtr< IGraphBuilder >          pGraphBuilder_;
    CComPtr< ICaptureGraphBuilder2 >  pCaptureGraphBuilder2_;    
    CComPtr< IBaseFilter >            pSrcFilter_;  

    CameraControl ControlPan_;
    CameraControl ControlTilt_;
    CameraControl ControlZoom_;
    CameraControl ControlExposure_;
    CameraControl ControlBrightness_;
    CameraControl ControlContrast_;

   
    // believe it or not: some cameras use -480 as value for height. Store that sign here
    int                               ImageHeightSign_;
    bool OverrideColorMode_; // false: take colormodel suggested by cam, true: take colormodel from SetColorModel()

    VideoSourceCapabilities Capabilities_;
    bool GetCapabilitiesOnly_; // during open, scan all modes

  }; //end class
}//end namespace mip
#endif