videoio.h

Go to the documentation of this file.

/*
 * videoio.h
 *
 * Classes to support streaming video input (grabbing) and output.
 *
 * Portable Windows Library
 *
 * Copyright (c) 1993-2000 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): Mark Cooke (mpc@star.sr.bham.ac.uk)
 */


#ifndef PTLIB_PVIDEOIO_H
#define PTLIB_PVIDEOIO_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif
#include <ptlib.h>

#if P_VIDEO

#include <ptlib/plugin.h>
#include <ptlib/pluginmgr.h>
#include <ptclib/delaychan.h>
#include <list>

class PColourConverter;


#define PTLIB_VIDEO_YUV420P "YUV420P"


class PVideoFrameInfo : public PObject
{
    PCLASSINFO(PVideoFrameInfo, PObject);
  public:
    P_DECLARE_ENUM_EX(ResizeMode,eMaxResizeMode,
      eScale,0,
      eCropCentre,
      eCropTopLeft,
      eScaleKeepAspect
    );
    friend ostream & operator<<(ostream & strm, ResizeMode mode);

    enum StandardSizes {
      SQCIFWidth = 128,  SQCIFHeight = 96,
      QCIFWidth  = 176,  QCIFHeight  = 144,
      CIFWidth   = 352,  CIFHeight   = 288,
      CIF4Width  = 704,  CIF4Height  = 576,
      CIF16Width = 1408, CIF16Height = 1152,
      HD480Width = 704,  HD480Height = 480,
      i480Width  = 704,  i480Height  = 480,
      HD720Width = 1280, HD720Height = 720,
      p720Width  = 1280, p720Height  = 720,
      HD1080Width= 1920, HD1080Height= 1080,
      i1080Width = 1920, i1080Height = 1080,
      HDTVWidth  = 1920, HDTVHeight  = 1080,
      MaxWidth   = 1920, MaxHeight   = 1200
    };

    static const PString & YUV420P();

    PVideoFrameInfo();
    PVideoFrameInfo(
      unsigned        frameWidth,
      unsigned        frameHeight,
      const PString & colourFormat = PVideoFrameInfo::YUV420P(),
      unsigned        frameRate = 15,
      ResizeMode      resizeMode = eScale
    );

    virtual Comparison Compare(
      const PObject & obj   // Object to compare against.
    ) const;

    virtual void PrintOn(
      ostream & strm   // Stream to print the object into.
    ) const;

    virtual PBoolean SetFrameSize(
      unsigned width,   
      unsigned height   
    );

    virtual PBoolean GetFrameSize(
      unsigned & width, 
      unsigned & height 
    ) const;

    virtual unsigned GetFrameWidth() const;

    virtual unsigned GetFrameHeight() const;

    virtual PBoolean SetFrameSar(
      unsigned width,   
      unsigned height   
    );

    virtual PBoolean GetSarSize(
      unsigned & width, 
      unsigned & height 
    ) const;

    virtual unsigned GetSarWidth() const;

    virtual unsigned GetSarHeight() const;
    
    virtual PBoolean SetFrameRate(
      unsigned rate  
    );

    virtual unsigned GetFrameRate() const;

    virtual PBoolean SetColourFormat(
      const PString & colourFormat // New colour format for device.
    );

    virtual PString GetColourFormat() const;

    virtual void SetResizeMode(
      ResizeMode mode
    ) { if (m_resizeMode < eMaxResizeMode) m_resizeMode = mode; }

    virtual ResizeMode GetResizeMode() const { return m_resizeMode; }

    virtual PINDEX CalculateFrameBytes() const { return CalculateFrameBytes(m_frameWidth, m_frameHeight, m_colourFormat); }
    static PINDEX CalculateFrameBytes(
      unsigned width,               
      unsigned height,              
      const PString & colourFormat = PVideoFrameInfo::YUV420P()  
    );

    virtual bool Parse(
      const PString & str   
    );

    static bool ParseSize(
      const PString & str,  
      unsigned & width,     
      unsigned & height     
    );

    static PString AsString(
      unsigned width,     
      unsigned height     
    );

    static PStringArray GetSizeNames();

  protected:
    unsigned   m_frameWidth;
    unsigned   m_frameHeight;
    unsigned   m_sarWidth;
    unsigned   m_sarHeight;
    unsigned   m_frameRate;
    PString    m_colourFormat;
    ResizeMode m_resizeMode;
};


class PVideoControlInfo : public PObject
{
  PCLASSINFO(PVideoControlInfo, PObject);

 public:
    P_DECLARE_STREAMABLE_ENUM(Types,
      Pan,
      Tilt,
      Zoom,
      Focus
    );

    PVideoControlInfo(
      Types type = EndTypes,
      int minimum = 0,
      int maximum = 100,
      int step = 1,
      int reset = 0
    ) : m_type(type)
      , m_minimum(minimum)
      , m_maximum(maximum)
      , m_step(step)
      , m_reset(reset)
      , m_current(reset)
    { }

    virtual void PrintOn(ostream & strm) const;

    bool IsValid() const   { return m_type != EndTypes; }

    Types GetType() const  { return m_type; }
    int GetStep()    const { return m_step; }
    int Reset()            { return m_current = m_reset; }
    int GetCurrent() const { return m_current; }
    int SetCurrent(int current);

  protected:
    Types m_type;
    int   m_minimum;
    int   m_maximum;
    int   m_step;
    int   m_reset;
    int   m_current;
};


class PVideoInteractionInfo : public PObject
{
    PCLASSINFO(PVideoInteractionInfo, PObject);
  public:
    P_DECLARE_ENUM(Type,
      InteractKey,       
      InteractMouse,     
      InteractNavigate,  
      InteractRTSP,      
      InteractOther      
    );

    PVideoInteractionInfo();
    virtual void PrintOn(ostream & strm) const;
    static PString AsString(const Type & type);

    Type m_type;
};


class PVideoDevice : public PVideoFrameInfo
{
  PCLASSINFO(PVideoDevice, PVideoFrameInfo);

  protected:
    PVideoDevice();


  public:
    virtual ~PVideoDevice();

    virtual void PrintOn(
      ostream & strm   // Stream to print the object into.
    ) const;

    P_DECLARE_STREAMABLE_ENUM(VideoFormat,
      PAL,
      NTSC,
      SECAM,
      Auto
    );

    virtual PString GetDeviceName() const
      { return m_deviceName; }

    virtual PStringArray GetDeviceNames() const = 0;

    struct Attributes {
      Attributes();

      int m_brightness;
      int m_contrast;
      int m_saturation;
      int m_hue;
      int m_gamma;
      int m_exposure;
    };

    struct OpenArgs {
      OpenArgs();

      PPluginManager * pluginMgr;
      PString     driverName;
      PString     deviceName;
      VideoFormat videoFormat;
      int         channelNumber;
      PString     colourFormat;
      bool        convertFormat;
      unsigned    rate;
      unsigned    width;
      unsigned    height;
      bool        convertSize;
      ResizeMode  resizeMode;
      bool        flip;
      Attributes  m_attributes;

      template<class PVideoXxxDevice>
      bool Validate(PVideoDevice::OpenArgs & validated) const
      {
        // Check that the input device is legal
        PVideoXxxDevice * pDevice = PVideoXxxDevice::CreateDeviceByName(deviceName, driverName, pluginMgr);
        if (pDevice == NULL)
          return false;

        delete pDevice;
        validated = *this;
        return true;
      }
    };

    virtual PBoolean OpenFull(
      const OpenArgs & args,      
      PBoolean startImmediate = true  
    );

    virtual PBoolean Open(
      const PString & deviceName,   
      PBoolean startImmediate = true    
    ) = 0;

    virtual PBoolean IsOpen() = 0;

    virtual PBoolean Close() = 0;

    virtual PBoolean Start() = 0;

    virtual PBoolean Stop() = 0;


    virtual PBoolean SetVideoFormat(
      VideoFormat videoFormat   
    );

    virtual VideoFormat GetVideoFormat() const;

    virtual int GetNumChannels();

    virtual PStringArray GetChannelNames();

    virtual PBoolean SetChannel(
      int channelNumber  
    );

    virtual int GetChannel() const;

    virtual bool SetFrameInfoConverter(
      const PVideoFrameInfo & info // New frame infofor device.
    );

    virtual PBoolean SetColourFormatConverter(
      const PString & colourFormat // New colour format for device.
    );

    virtual PBoolean GetVFlipState();

    virtual PBoolean SetVFlipState(
      PBoolean newVFlipState    
    );

    virtual PBoolean GetFrameSizeLimits(
      unsigned & minWidth,   
      unsigned & minHeight,  
      unsigned & maxWidth,   
      unsigned & maxHeight   
    ) ;


    virtual PBoolean SetFrameSizeConverter(
      unsigned width,  
      unsigned height, 
      ResizeMode resizeMode = eMaxResizeMode 
    );

    virtual PBoolean SetNearestFrameSize(
      unsigned width,   
      unsigned height   
    );

    virtual PBoolean SetFrameSize(
      unsigned width,   
      unsigned height   
    );

    virtual PBoolean GetFrameSize(
      unsigned & width,
      unsigned & height
    ) const;

    virtual PString GetColourFormat() const;

    virtual PINDEX GetMaxFrameBytes();

    
    virtual int GetLastError() const { return m_lastError; }


    virtual PBoolean CanCaptureVideo() const = 0;

    virtual bool GetAttributes(
      Attributes & attributes
    );

    virtual bool SetAttributes(
      const Attributes & attributes
    );


    virtual PBoolean SetVideoChannelFormat (
      int channelNumber, 
      VideoFormat videoFormat
    );


    virtual void SetPreferredColourFormat(const PString & colourFmt) { m_preferredColourFormat = colourFmt; }

    virtual PString GetPreferredColourFormat() { return m_preferredColourFormat; }
    
  protected:
    PINDEX GetMaxFrameBytesConverted(PINDEX rawFrameBytes) const;
    PString GetDeviceNameFromOpenArgs(const OpenArgs & args) const;
    PString ParseDeviceNameTokenString(const char * token, const char * defaultValue);
    int ParseDeviceNameTokenInt(const char * token, int defaultValue);
    uint64_t ParseDeviceNameTokenUnsigned(const char * token, uint64_t defaultValue);

    PCaselessString m_deviceName;
    int             m_lastError;
    VideoFormat     m_videoFormat;
    int             m_channelNumber;
    PString         m_preferredColourFormat; // Preferred native colour format from video input device, empty == no preference
    bool            m_nativeVerticalFlip;

    PColourConverter * m_converter;
    PBYTEArray         m_frameStore;

  private:
    P_REMOVE_VIRTUAL(int, GetBrightness(), 0);
    P_REMOVE_VIRTUAL(PBoolean, SetBrightness(unsigned), false);
    P_REMOVE_VIRTUAL(int, GetWhiteness(), 0);
    P_REMOVE_VIRTUAL(PBoolean, SetWhiteness(unsigned), false);
    P_REMOVE_VIRTUAL(int, GetColour(), 0);
    P_REMOVE_VIRTUAL(PBoolean, SetColour(unsigned), false);
    P_REMOVE_VIRTUAL(int, GetContrast(), 0);
    P_REMOVE_VIRTUAL(PBoolean, SetContrast(unsigned), false);
    P_REMOVE_VIRTUAL(int, GetHue(), 0);
    P_REMOVE_VIRTUAL(PBoolean, SetHue(unsigned), false);
    P_REMOVE_VIRTUAL(PBoolean, GetParameters(int *, int *, int *, int *, int *), false);
    P_REMOVE_VIRTUAL(PBoolean, SetFrameSizeConverter(unsigned, unsigned, PBoolean), false);
};


class PVideoOutputDevice : public PVideoDevice
{
  PCLASSINFO(PVideoOutputDevice, PVideoDevice);

  public:
    PVideoOutputDevice();
    
    virtual ~PVideoOutputDevice() { Close(); };      

    static PStringArray GetDriverNames(
      PPluginManager * pluginMgr = NULL   
    );

    static PStringArray GetDriversDeviceNames(
      const PString & driverName,         
      PPluginManager * pluginMgr = NULL   
    );

    static PVideoOutputDevice * CreateDevice(
      const PString & driverName,         
      PPluginManager * pluginMgr = NULL   
    );

    /* Create the matching video output device that corresponds to the device name.

       This is typically used with the return values from GetDriversDeviceNames().
     */
    static PVideoOutputDevice *CreateDeviceByName(
      const PString & deviceName,         
      const PString & driverName = PString::Empty(),  
      PPluginManager * pluginMgr = NULL   
    );

    static PVideoOutputDevice *CreateOpenedDevice(
      const PString & driverName,         
      const PString & deviceName,         
      bool startImmediate = true,         
      PPluginManager * pluginMgr = NULL   
    );
    static PVideoOutputDevice *CreateOpenedDevice(
      const PString & deviceName,         
      bool startImmediate = true,         
      PPluginManager * pluginMgr = NULL   
    ) { return CreateOpenedDevice(PString::Empty(), deviceName, startImmediate, pluginMgr); }

    static PVideoOutputDevice *CreateOpenedDevice(
      const OpenArgs & args,              
      bool startImmediate = true          
    );

    virtual PBoolean Close() { return true; }

    virtual PBoolean Start() { return true; }

    virtual PBoolean Stop() { return true; }

    virtual PBoolean CanCaptureVideo() const;

    struct FrameData
    {
      unsigned      x;               
      unsigned      y;               
      unsigned      width;           
      unsigned      height;          
      unsigned      sarWidth;        
      unsigned      sarHeight;       
      PTimeInterval sampleTime;      
      const BYTE  * pixels;          
      bool          partialFrame;    
      bool        * keyFrameNeeded;  
      void        * mark;            // For backward compatibility, not sure what it is for ...

      FrameData() : x(0), y(0), width(0), height(0), sarWidth(0), sarHeight(0), pixels(NULL), partialFrame(false), keyFrameNeeded(NULL), mark(NULL) { }
    };

    virtual PBoolean SetFrameData(
      const FrameData & frameData   
    ) = 0;

    // For backward compatibility
    bool SetFrameData(
      unsigned x,               
      unsigned y,               
      unsigned width,           
      unsigned height,          
      const BYTE * data,        
      bool endFrame = true      
    );
    bool SetFrameData(
      unsigned x,               
      unsigned y,               
      unsigned width,           
      unsigned height,          
      const BYTE * data,        
      bool endFrame,            
      bool & keyFrameNeeded     
    );

    virtual PBoolean DisableDecode();

    virtual PBoolean GetPosition(
      int & x,  // X position of device surface
      int & y   // Y position of device surface
    ) const;

    virtual bool SetPosition(
      int x,  // X position of device surface
      int y   // Y position of device surface
    );
  
#ifdef P_MACOSX
  virtual bool ApplicationMain() { return false; }
#endif
};


class PVideoOutputDeviceRGB : public PVideoOutputDevice
{
  PCLASSINFO(PVideoOutputDeviceRGB, PVideoOutputDevice);

  public:
    PVideoOutputDeviceRGB();

    virtual PBoolean SetColourFormat(
      const PString & colourFormat // New colour format for device.
    );

    virtual PBoolean SetFrameSize(
      unsigned width,   
      unsigned height   
    );

    virtual PINDEX GetMaxFrameBytes();

    virtual PBoolean SetFrameData(const FrameData & frameData);

    virtual PBoolean FrameComplete() = 0;

  protected:
    PDECLARE_MUTEX(m_mutex);
    PINDEX         m_bytesPerPixel;
    PINDEX         m_scanLineWidth;
    bool           m_swappedRedAndBlue;
};


class PVideoInputDevice : public PVideoDevice
{
  PCLASSINFO(PVideoInputDevice, PVideoDevice);

  public:
    //PVideoInputDevice();

    ~PVideoInputDevice() { Close(); }

    static PStringArray GetDriverNames(
      PPluginManager * pluginMgr = NULL   
    );

    static PStringArray GetDriversDeviceNames(
      const PString & driverName,         
      PPluginManager * pluginMgr = NULL   
    );

    static PVideoInputDevice *CreateDevice(
      const PString & driverName,         
      PPluginManager * pluginMgr = NULL   
    );

    /* Create the matching video input device that corresponds to the device name.
       So, for "fake" return a device that will generate fake video.
       For "Phillips 680 webcam" (eg) will return appropriate grabber.
       Note that Phillips will return the appropriate grabber also.

       This is typically used with the return values from GetDriversDeviceNames().
     */
    static PVideoInputDevice *CreateDeviceByName(
      const PString & deviceName,         
      const PString & driverName = PString::Empty(),  
      PPluginManager * pluginMgr = NULL   
    );

    static PVideoInputDevice *CreateOpenedDevice(
      const PString & driverName,         
      const PString & deviceName,         
      bool startImmediate = true,         
      PPluginManager * pluginMgr = NULL   
    );
    static PVideoInputDevice *CreateOpenedDevice(
      const PString & deviceName,         
      bool startImmediate = true,         
      PPluginManager * pluginMgr = NULL   
    ) { return CreateOpenedDevice(PString::Empty(), deviceName, startImmediate, pluginMgr); }

    static PVideoInputDevice *CreateOpenedDevice(
      const OpenArgs & args,              
      bool startImmediate = true          
    );

    class Capabilities : public PObject {
      PCLASSINFO(Capabilities, PObject);
    public:
      Capabilities();
      virtual void PrintOn(ostream & strm) const;

      unsigned                         m_channels;
      bool                             m_brightness;
      bool                             m_contrast;
      bool                             m_saturation;
      bool                             m_hue;
      bool                             m_gamma;
      bool                             m_exposure;
      std::list<PVideoFrameInfo>       m_frameSizes;
      std::list<PVideoControlInfo>     m_controls;
      std::list<PVideoInteractionInfo> m_interactions;
    };

    virtual bool GetDeviceCapabilities(
      Capabilities * capabilities          
      ) const;

    static bool GetDeviceCapabilities(
      const PString & deviceName,           
      Capabilities * capabilities,          
      PPluginManager * pluginMgr = NULL     
    );

    static bool GetDeviceCapabilities(
      const PString & deviceName,           
      const PString & driverName,           
      Capabilities * caps,                  
      PPluginManager * pluginMgr = NULL     
    );

    static PBoolean GetInputDeviceCapabilities(const PString &, Capabilities *)
      { return false; }

    virtual PBoolean Open(
      const PString & deviceName,   
      PBoolean startImmediate = true    
    ) = 0;

    virtual PBoolean Close(
    ) { return true; }

    virtual PBoolean CanCaptureVideo() const;
 
    virtual PBoolean IsCapturing() = 0;

    virtual PBoolean SetNearestFrameSize(
      unsigned width,   
      unsigned height   
    );

    bool GetFrame(
      BYTE * buffer,          
      PINDEX & bytesReturned, 
      bool & keyFrame,        
      bool wait = true        
    );
    virtual PBoolean GetFrame(
      PBYTEArray & frame
    );
    virtual PBoolean GetFrame(
      PBYTEArray & frame,
      unsigned & width,
      unsigned & height
    );

    bool GetFrameData(
      BYTE * buffer,                 
      PINDEX * bytesReturned,        
      bool & keyFrame         
    );
    bool GetFrameData(
      BYTE * buffer,                 
      PINDEX * bytesReturned = NULL  
    );

    bool GetFrameDataNoDelay(
      BYTE * buffer,                 
      PINDEX * bytesReturned,       
      bool & keyFrame         
    );

    bool GetFrameDataNoDelay(
      BYTE * buffer,                 
      PINDEX * bytesReturned = NULL  
    );

    virtual bool FlowControl(const void * flowData);

    virtual bool SetCaptureMode(unsigned mode);

    virtual int GetCaptureMode() const;

    enum ControlMode {
      AutomaticControl,
      AbsoluteControl,
      RelativeControl,
      ResetControl
    };

    virtual bool SetControl(PVideoControlInfo::Types type, int value, ControlMode mode);
    virtual const PVideoControlInfo & GetControlInfo(PVideoControlInfo::Types type) const { return m_controlInfo[type]; }

  protected:
    virtual bool InternalGetFrameData(
      BYTE * buffer,          
      PINDEX & bytesReturned, 
      bool & keyFrame,        
      bool wait
    ) = 0;

    PVideoControlInfo m_controlInfo[PVideoControlInfo::NumTypes];

  private:
    P_REMOVE_VIRTUAL(PBoolean, GetFrameData(BYTE *, PINDEX *, unsigned &), false);
    P_REMOVE_VIRTUAL(PBoolean, GetFrameDataNoDelay(BYTE *, PINDEX *, unsigned &), false);
};


class PVideoInputDeviceIndirect : public PVideoInputDevice
{
  PCLASSINFO(PVideoInputDeviceIndirect, PVideoInputDevice);

  public:
    explicit PVideoInputDeviceIndirect(PVideoInputDevice * device = NULL, bool autoDelete = true)
      : m_actualDevice(device), m_autoDeleteActualDevice(autoDelete) { }
    ~PVideoInputDeviceIndirect() { SetActualDevice(NULL); }

    virtual void SetActualDevice(PVideoInputDevice * actualDevice, bool autoDelete = true);
    virtual PVideoInputDevice * GetActualDevice() const;

    virtual Comparison Compare(const PObject & obj) const;
    virtual void PrintOn(ostream & strm) const;
    virtual PBoolean SetFrameSize(unsigned width, unsigned height);
    virtual PBoolean SetFrameSar(unsigned width, unsigned height);
    virtual PBoolean SetFrameRate(unsigned rate);
    virtual PBoolean SetColourFormat(const PString & colourFormat);
    virtual void SetResizeMode(ResizeMode mode);
    virtual PINDEX CalculateFrameBytes() const;
    virtual bool Parse(const PString & str);
    virtual PString GetDeviceName() const;
    virtual PStringArray GetDeviceNames() const;
    virtual PBoolean OpenFull(const OpenArgs & args, PBoolean startImmediate = true);
    virtual PBoolean Open(const PString & deviceName, PBoolean startImmediate = true);
    virtual PBoolean IsOpen();
    virtual PBoolean Close();
    virtual PBoolean Start();
    virtual PBoolean Stop();
    virtual PBoolean SetVideoFormat(VideoFormat videoFormat);
    virtual int GetNumChannels();
    virtual PStringArray GetChannelNames();
    virtual PBoolean SetChannel(int channelNumber);
    virtual int GetChannel() const;
    virtual PBoolean SetVFlipState(PBoolean newVFlipState);
    virtual PBoolean GetFrameSizeLimits(unsigned & minWidth, unsigned & minHeight, unsigned & maxWidth, unsigned & maxHeight);
    virtual PBoolean SetNearestFrameSize(unsigned width, unsigned height);
    virtual bool SetFrameInfoConverter(const PVideoFrameInfo & info);
    virtual PBoolean SetColourFormatConverter(const PString & colourFormat);
    virtual PBoolean SetFrameSizeConverter(unsigned width, unsigned height, ResizeMode resizeMode = eMaxResizeMode);
    virtual int GetLastError() const;
    virtual bool GetAttributes(Attributes & attributes);
    virtual bool SetAttributes(const Attributes & attributes);
    virtual PBoolean SetVideoChannelFormat(int channelNumber, VideoFormat videoFormat);
    virtual bool GetDeviceCapabilities(Capabilities * capabilities) const;
    virtual PBoolean IsCapturing();
    virtual bool FlowControl(const void * flowData);
    virtual bool SetCaptureMode(unsigned mode);
    virtual int GetCaptureMode() const;
    virtual bool SetControl(PVideoControlInfo::Types type, int value, ControlMode mode);

  protected:
    virtual bool InternalGetFrameData(BYTE * buffer, PINDEX & bytesReturned, bool & keyFrame, bool wait);
    PDECLARE_MUTEX(     m_actualDeviceMutex);
    PVideoInputDevice * m_actualDevice;
    bool                m_autoDeleteActualDevice;
};


class PVideoInputEmulatedDevice : public PVideoInputDevice
{
  PCLASSINFO(PVideoInputEmulatedDevice, PVideoInputDevice);
  public:
    explicit PVideoInputEmulatedDevice();
    ~PVideoInputEmulatedDevice();

    PBoolean Start();

    PBoolean Stop();

    PBoolean IsCapturing();

    virtual PBoolean SetColourFormat(
      const PString & colourFormat   // New colour format for device.
    );
    
    enum {
      Channel_PlayAndClose,
      Channel_PlayAndRepeat,
      Channel_PlayAndKeepLast,
      Channel_PlayAndShowBlack,
      Channel_PlayAndShowWhite,
      ChannelCount
    };

    virtual int GetNumChannels();

    virtual PStringArray GetChannelNames();

    virtual PBoolean GetFrameSizeLimits(
      unsigned & minWidth,   
      unsigned & minHeight,  
      unsigned & maxWidth,   
      unsigned & maxHeight   
    ) ;

    virtual PBoolean SetFrameRate(
      unsigned rate  
    );
         
    virtual PBoolean SetFrameSize(
      unsigned width,   
      unsigned height   
    );

  protected:
    virtual bool InternalGetFrameData(BYTE * buffer, PINDEX & bytesReturned, bool & keyFrame, bool wait);
    virtual bool InternalReadFrameData(BYTE * frame) = 0;

    PAdaptiveDelay m_pacing;
    unsigned       m_fixedFrameRate;
    unsigned       m_frameRateAdjust;
    unsigned       m_frameNumber;
};

//
// declare macros and structures needed for video input plugins
//

PCREATE_PLUGIN_DEVICE(PVideoInputDevice);

#define PCREATE_VIDINPUT_PLUGIN_EX(name, extra) \
    PCREATE_PLUGIN(name, PVideoInputDevice, PVideoInputDevice_##name, PPlugin_PVideoInputDevice, \
      virtual PStringArray GetDeviceNames(P_INT_PTR /*userData*/) const { return PVideoInputDevice_##name::GetInputDeviceNames(); } \
      virtual bool GetDeviceCapabilities(const PString & deviceName, void * caps) const { return PVideoInputDevice_##name::GetInputDeviceCapabilities(deviceName, (PVideoInputDevice::Capabilities *)caps); } \
      extra)

#define PCREATE_VIDINPUT_PLUGIN(name) PCREATE_VIDINPUT_PLUGIN_EX(name, )


#define P_FAKE_VIDEO_DRIVER         "FakeVideo"
#define P_FAKE_VIDEO_PREFIX         "Fake/"
#define P_FAKE_VIDEO_MOVING_BLOCKS  P_FAKE_VIDEO_PREFIX"MovingBlocks"
#define P_FAKE_VIDEO_MOVING_LINE    P_FAKE_VIDEO_PREFIX"MovingLine"
#define P_FAKE_VIDEO_BOUNCING_BOXES P_FAKE_VIDEO_PREFIX"BouncingBoxes"
#define P_FAKE_VIDEO_SOLID_COLOUR   P_FAKE_VIDEO_PREFIX"SolidColour"
#define P_FAKE_VIDEO_TEXT           P_FAKE_VIDEO_PREFIX"Text"
#define P_FAKE_VIDEO_NTSC           P_FAKE_VIDEO_PREFIX"NTSCTest"
#define P_FAKE_VIDEO_BLACK          P_FAKE_VIDEO_PREFIX"Black"

PPLUGIN_STATIC_LOAD(FakeVideo, PVideoInputDevice);

#ifdef P_APPSHARE
  #define P_APPLICATION_VIDEO_DRIVER "Application"
  PPLUGIN_STATIC_LOAD(Application, PVideoInputDevice);
#endif

#if P_MEDIAFILE
  #define P_MEDIA_FILE_DRIVER "MediaFile"
  PPLUGIN_STATIC_LOAD(MediaFile, PVideoInputDevice);
#endif

#if P_VIDFILE
  #define P_VIDEO_FILE_DRIVER "VideoFile"
  PPLUGIN_STATIC_LOAD(VideoFile, PVideoInputDevice);
#endif

#ifdef WIN32
  #define P_VIDEO_FOR_WINDOWS_DRIVER "VideoForWindows"
  PPLUGIN_STATIC_LOAD(VideoForWindows, PVideoInputDevice);
#endif

#ifdef P_DIRECTSHOW
  #define P_DIRECT_SHOW_DRIVER "DirectShow"
  PPLUGIN_STATIC_LOAD(DirectShow, PVideoInputDevice);
#endif

#if defined(P_MACOSX)
  #define P_MAC_VIDEO_DRIVER "Mac"
  PPLUGIN_STATIC_LOAD(Mac, PVideoInputDevice);
#endif


//
// declare macros and structures needed for video output plugins
//

PCREATE_PLUGIN_DEVICE(PVideoOutputDevice);

#define PCREATE_VIDOUTPUT_PLUGIN_EX(name, extra) \
    PCREATE_PLUGIN(name, PVideoOutputDevice, PVideoOutputDevice_##name, PPlugin_PVideoOutputDevice, \
      virtual PStringArray GetDeviceNames(P_INT_PTR /*userData*/) const { return PVideoOutputDevice_##name::GetOutputDeviceNames(); } \
    extra)

#define PCREATE_VIDOUTPUT_PLUGIN(name) PCREATE_VIDOUTPUT_PLUGIN_EX(name,)

#define P_NULL_VIDEO_DRIVER "NULLOutput"
#define P_NULL_VIDEO_DEVICE "Null Video Out"
PPLUGIN_STATIC_LOAD(NULLOutput, PVideoOutputDevice);


#if P_VFW_CAPTURE
#if _WIN32
  #define P_MSWIN_VIDEO_DRIVER "Window"
  #define P_MSWIN_VIDEO_PREFIX "MSWIN"
  #define P_MSWIN_VIDEO_DEVICE(x,y,width,height) P_MSWIN_VIDEO_PREFIX " X=" x " Y=" y " WIDTH=" width " HEIGHT=" height
  PPLUGIN_STATIC_LOAD(Window, PVideoOutputDevice);
#endif
#endif

#if P_SDL
  #if defined(P_MACOSX) || defined(P_IOS)
    #include <SDL_main.h>
  #endif
  #define P_SDL_VIDEO_DRIVER "SDL"
  #define P_SDL_VIDEO_PREFIX "SDL"
  #define P_SDL_VIDEO_DEVICE(x,y,width,height) P_SDL_VIDEO_PREFIX " X=" x " Y=" y " WIDTH=" width " HEIGHT=" height
  PPLUGIN_STATIC_LOAD(SDL, PVideoOutputDevice);
#endif


//
// declare classes needed for access to simple video font
//

class PVideoFont : public PObject
{
  PCLASSINFO(PVideoFont, PObject);
  public:
    enum {
      MAX_L_HEIGHT = 11
    };
    struct LetterData {
      char ascii;
      const char *line[MAX_L_HEIGHT];
    };

    static const LetterData * GetLetterData(char ascii);
};

#endif // P_VIDEO

#endif   // PTLIB_PVIDEOIO_H

// End Of File ///////////////////////////////////////////////////////////////