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)
 *
 * $Log: videoio.h,v $
 * Revision 1.59  2007/09/26 03:43:09  rjongbloed
 * Added ability to get last position of window video output device.
 *
 * Revision 1.58  2007/05/19 09:33:29  rjongbloed
 * Fixed compiler warnings.
 *
 * Revision 1.57  2007/05/16 07:54:21  csoutheren
 * Fix problems created by gcc 4.2.0
 *
 * Revision 1.56  2007/05/01 21:13:46  dsandras
 * Added extra variables to store the number of frames received.
 *
 * Revision 1.55  2007/04/20 06:53:06  csoutheren
 * Fix problem with precompiled headers
 *
 * Revision 1.54  2007/04/20 06:47:02  csoutheren
 * Really disable video code when video is turned off
 *
 * Revision 1.53  2007/04/16 01:59:48  rjongbloed
 * Added function to video info class to parse standard size strings
 *   to width/height, eg "CIF", "QCIF", "VGA" etc
 *
 * Revision 1.52  2007/04/13 23:15:19  shorne
 * added backward compatible SetFrameSizeConverter
 *
 * Revision 1.51  2007/04/13 07:13:13  rjongbloed
 * Major update of video subsystem:
 *   Abstracted video frame info (width, height etc) into separate class.
 *   Changed devices, converter and video file to use above.
 *   Enhanced video file hint detection for frame rate and more
 *     flexible formats.
 *   Fixed issue if need to convert both colour format and size, had to do
 *     colour format first or it didn't convert size.
 *   Win32 video output device can be selected by "MSWIN" alone.
 *
 * Revision 1.50  2007/04/05 01:53:00  rjongbloed
 * Changed PVideoOutputDevice::CreateDeviceByName() to include driverName parameter so symmetric with PVideoInputDevice.
 *
 * Revision 1.49  2007/04/03 12:09:38  rjongbloed
 * Fixed various "file video device" issues:
 *   Remove filename from PVideoDevice::OpenArgs (use deviceName)
 *   Added driverName to PVideoDevice::OpenArgs (so can select YUVFile)
 *   Added new statics to create correct video input/output device object
 *     given a PVideoDevice::OpenArgs structure.
 *   Fixed begin able to write to YUVFile when YUV420P colour format
 *     is not actually selected.
 *   Fixed truncating output video file if overwriting.
 *
 * Revision 1.48  2006/10/31 04:10:40  csoutheren
 * Make sure PVidFileDev class is loaded, and make it work with OPAL
 *
 * Revision 1.47  2006/10/25 11:04:38  shorne
 * fix for devices having same name for different drivers.
 *
 * Revision 1.46  2006/06/21 05:38:58  csoutheren
 * Fixed plugin compile for latest pwlib
 *
 * Revision 1.45  2006/06/21 03:28:41  csoutheren
 * Various cleanups thanks for Frederic Heem
 *
 * Revision 1.44  2006/03/17 06:56:22  csoutheren
 * Exposed video fonts to external access
 *
 * Revision 1.43  2005/11/25 03:43:47  csoutheren
 * Fixed function argument comments to be compatible with Doxygen
 *
 * Revision 1.42  2005/08/09 09:08:09  rjongbloed
 * Merged new video code from branch back to the trunk.
 *
 * Revision 1.41.4.1  2005/07/17 09:27:04  rjongbloed
 * Major revisions of the PWLib video subsystem including:
 *   removal of F suffix on colour formats for vertical flipping, all done with existing bool
 *   working through use of RGB and BGR formats so now consistent
 *   cleaning up the plug in system to use virtuals instead of pointers to functions.
 *   rewrite of SDL to be a plug in compatible video output device.
 *   extensive enhancement of video test program
 *
 * Revision 1.41  2005/01/04 07:44:03  csoutheren
 * More changes to implement the new configuration methodology, and also to
 * attack the global static problem
 *
 * Revision 1.40  2004/04/18 12:49:22  csoutheren
 * Patches to video code thanks to Guilhem Tardy (hope I get it right this time :)
 *
 * Revision 1.39  2004/01/18 14:23:30  dereksmithies
 * Add new function to make opening of video input devices easier.
 *
 * Revision 1.38  2004/01/02 23:30:18  rjongbloed
 * Removed extraneous static function for getting input device names that has been deprecated during the plug ins addition.
 *
 * Revision 1.37  2003/12/14 10:01:02  rjongbloed
 * Resolved issue with name space conflict os static and virtual forms of GetDeviceNames() function.
 *
 * Revision 1.36  2003/12/03 03:47:56  dereksmithies
 * Add fix so video output devices compile and run correctly.
 * Thanks to Craig Southeren.
 *
 * Revision 1.35  2003/11/19 04:29:02  csoutheren
 * Changed to support video output plugins
 *
 * Revision 1.34  2003/11/18 10:39:06  csoutheren
 * Fixed warnings regarding calling virtual Close in destructors
 *
 * Revision 1.33  2003/11/18 06:46:15  csoutheren
 * Changed to support video input plugins
 *
 * Revision 1.32  2003/09/17 05:41:59  csoutheren
 * Removed recursive includes
 *
 * Revision 1.31  2003/09/17 01:18:02  csoutheren
 * Removed recursive include file system and removed all references
 * to deprecated coooperative threading support
 *
 * Revision 1.30  2003/03/17 08:10:00  robertj
 * Fixed GNU warning
 *
 * Revision 1.29  2003/03/17 07:51:07  robertj
 * Added OpenFull() function to open with all video parameters in one go.
 * Made sure vflip variable is set in converter even if converter has not
 *   been set yet, should not depend on the order of functions!
 * Removed canCaptureVideo variable as this is really a virtual function to
 *   distinguish PVideoOutputDevice from PVideoInputDevice, it is not dynamic.
 * Made significant enhancements to PVideoOutputDevice class.
 * Added PVideoOutputDevice descendants for NULL and PPM files.
 *
 * Revision 1.28  2002/09/16 01:08:59  robertj
 * Added #define so can select if #pragma interface/implementation is used on
 *   platform basis (eg MacOS) rather than compiler, thanks Robert Monaghan.
 *
 * Revision 1.27  2002/04/12 08:25:12  robertj
 * Added text string output for tracing video format.
 *
 * Revision 1.26  2002/04/05 06:41:54  rogerh
 * Apply video changes from Damien Sandras <dsandras@seconix.com>.
 * The Video Channel and Format are no longer set in Open(). Instead
 * call the new SetVideoChannelFormat() method. This makes video capture
 * and GnomeMeeting more stable with certain Linux video capture devices.
 *
 * Revision 1.25  2002/02/20 02:37:26  dereks
 * Initial release of Firewire camera support for linux.
 * Many thanks to Ryutaroh Matsumoto <ryutaroh@rmatsumoto.org>.
 *
 * Revision 1.24  2002/01/16 07:51:06  robertj
 * MSVC compatibilty changes
 *
 * Revision 1.23  2002/01/16 03:51:20  dereks
 * Move flip methods in PVideoInputDevice  to  PVideoDevice
 *
 * Revision 1.22  2002/01/14 02:59:54  robertj
 * Added preferred colour format selection, thanks Walter Whitlock
 *
 * Revision 1.21  2002/01/04 04:11:45  dereks
 * Add video flip code from Walter Whitlock, which flips code at the grabber.
 *
 * Revision 1.20  2001/11/28 00:07:32  dereks
 * Locking added to PVideoChannel, allowing reader/writer to be changed mid call
 * Enabled adjustment of the video frame rate
 * New fictitous image, a blank grey area
 *
 * Revision 1.19  2001/08/06 06:12:45  rogerh
 * Fix comments
 *
 * Revision 1.18  2001/08/03 04:21:51  dereks
 * Add colour/size conversion for YUV422->YUV411P
 * Add Get/Set Brightness,Contrast,Hue,Colour for PVideoDevice,  and
 * Linux PVideoInputDevice.
 * Add lots of PTRACE statement for debugging colour conversion.
 * Add support for Sony Vaio laptop under linux. Requires 2.4.7 kernel.
 *
 * Revision 1.17  2001/05/22 23:38:45  robertj
 * Fixed bug in PVideoOutputDevice, removed redundent SetFrameSize.
 *
 * Revision 1.16  2001/05/22 12:49:32  robertj
 * Did some seriously wierd rewrite of platform headers to eliminate the
 *   stupid GNU compiler warning about braces not matching.
 *
 * Revision 1.15  2001/03/20 02:21:57  robertj
 * More enhancements from Mark Cooke
 *
 * Revision 1.14  2001/03/08 23:04:19  robertj
 * Fixed up some documentation.
 *
 * Revision 1.13  2001/03/08 08:31:34  robertj
 * Numerous enhancements to the video grabbing code including resizing
 *   infrastructure to converters. Thanks a LOT, Mark Cooke.
 *
 * Revision 1.12  2001/03/07 01:42:59  dereks
 * miscellaneous video fixes. Works on linux now. Add debug statements
 * (at PTRACE level of 1)
 *
 * Revision 1.11  2001/03/06 23:34:20  robertj
 * Added static function to get input device names.
 * Moved some inline virtuals to non-inline.
 *
 * Revision 1.10  2001/03/03 05:06:31  robertj
 * Major upgrade of video conversion and grabbing classes.
 *
 * Revision 1.9  2001/02/28 01:47:14  robertj
 * Removed function from ancestor and is not very useful, thanks Thorsten Westheider.
 *
 * Revision 1.8  2000/12/19 22:20:26  dereks
 * Add video channel classes to connect to the PwLib PVideoInputDevice class.
 * Add PFakeVideoInput class to generate test images for video.
 *
 * Revision 1.7  2000/11/09 00:20:38  robertj
 * Added qcif size constants
 *
 * Revision 1.6  2000/07/30 03:41:31  robertj
 * Added more colour formats to video device enum.
 *
 * Revision 1.5  2000/07/26 03:50:49  robertj
 * Added last error variable to video device.
 *
 * Revision 1.4  2000/07/26 02:13:46  robertj
 * Added some more "common" bounds checking to video device.
 *
 * Revision 1.3  2000/07/25 13:38:25  robertj
 * Added frame rate parameter to video frame grabber.
 *
 * Revision 1.2  2000/07/25 13:14:05  robertj
 * Got the video capture stuff going!
 *
 * Revision 1.1  2000/07/15 09:47:34  robertj
 * Added video I/O device classes.
 *
 */


#ifndef _PVIDEOIO
#define _PVIDEOIO

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#ifndef _PTLIB_H
#include <ptlib.h>
#endif

#if P_VIDEO

#include <ptlib/plugin.h>
#include <ptlib/pluginmgr.h>

class PColourConverter;


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

  public:
      PVideoFrameInfo();

    enum ResizeMode
    {
        eScale,
        eCropCentre,
        eCropTopLeft,
        eMaxResizeMode
    };

    enum StandardSizes {
      CIF16Width = 1408, CIF16Height = 1152,
      CIF4Width  = 704,  CIF4Height  = 576,
      CIFWidth   = 352,  CIFHeight   = 288,
      QCIFWidth  = 176,  QCIFHeight  = 144,
      SQCIFWidth = 144,  SQCIFHeight = 96,
    };

    virtual BOOL SetFrameSize(
      unsigned width,   
      unsigned height   
    );

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

    virtual unsigned GetFrameWidth() const;

    virtual unsigned GetFrameHeight() const;

    virtual BOOL SetFrameRate(
      unsigned rate  
    );

    virtual unsigned GetFrameRate() const;

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

    virtual const PString & GetColourFormat() const;

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

    ResizeMode GetResizeMode() const { return resizeMode; }

    PINDEX CalculateFrameBytes() const { return CalculateFrameBytes(frameWidth, frameHeight, colourFormat); }
    static PINDEX CalculateFrameBytes(
      unsigned width,               
      unsigned height,              
      const PString & colourFormat  
    );

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

  protected:
    unsigned   frameWidth;
    unsigned   frameHeight;
    unsigned   frameRate;
    PString    colourFormat;
    ResizeMode resizeMode;
};


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

  protected:
    PVideoDevice();


  public:
    virtual ~PVideoDevice();

    enum VideoFormat {
      PAL,
      NTSC,
      SECAM,
      Auto,
      NumVideoFormats
    };

    const PString & GetDeviceName() const
      { return deviceName; }

    virtual PStringList GetDeviceNames() const = 0;

    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;
      int         brightness;
      int         whiteness;
      int         contrast;
      int         colour;
      int         hue;
    };

    virtual BOOL OpenFull(
      const OpenArgs & args,      
      BOOL startImmediate = TRUE  
    );

    virtual BOOL Open(
      const PString & deviceName,   
      BOOL startImmediate = TRUE    
    ) = 0;

    virtual BOOL IsOpen() = 0;

    virtual BOOL Close() = 0;

    virtual BOOL Start() = 0;

    virtual BOOL Stop() = 0;


#if PTRACING
    friend ostream & operator<<(ostream &, VideoFormat);
#endif

    virtual BOOL SetVideoFormat(
      VideoFormat videoFormat   
    );

    virtual VideoFormat GetVideoFormat() const;

    virtual int GetNumChannels();

    virtual BOOL SetChannel(
      int channelNumber  
    );

    virtual int GetChannel() const;

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

    virtual BOOL GetVFlipState();

    virtual BOOL SetVFlipState(
      BOOL newVFlipState    
    );

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


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

    virtual BOOL SetFrameSizeConverter(
      unsigned width,                   
      unsigned height,                  
          BOOL  /*bScaleNotCrop*/           
          )  { return SetFrameSizeConverter(width,height,eScale); }


    virtual BOOL SetFrameSize(
      unsigned width,   
      unsigned height   
    );

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

    virtual PINDEX GetMaxFrameBytes() = 0;

    
    int GetLastError() const { return lastError; }


    virtual BOOL CanCaptureVideo() const = 0;

    virtual int GetBrightness();

    virtual BOOL SetBrightness(unsigned newBrightness);


    virtual int GetWhiteness();

    virtual BOOL SetWhiteness(unsigned newWhiteness);


    virtual int GetColour();

    virtual BOOL SetColour(unsigned newColour);


    virtual int GetContrast();

    virtual BOOL SetContrast(unsigned newContrast);


    virtual int GetHue();

    virtual BOOL SetHue(unsigned newHue);
    
    
    virtual BOOL GetParameters(
      int *whiteness,
      int *brightness,
      int *colour,
      int *contrast,
      int *hue
    );

    
    virtual BOOL SetVideoChannelFormat (
      int channelNumber, 
      VideoFormat videoFormat
    );


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

    const PString & GetPreferredColourFormat() { return preferredColourFormat; }
    
    int GetNumberOfFrames () { return numberOfFrames; }
    
  protected:
    PINDEX GetMaxFrameBytesConverted(PINDEX rawFrameBytes) const;

    PString      deviceName;
    int          lastError;
    VideoFormat  videoFormat;
    int          channelNumber;
    // Preferred native colour format from video input device, empty == no preference
    PString      preferredColourFormat;
    BOOL         nativeVerticalFlip;

    PColourConverter * converter;
    PBYTEArray         frameStore;

    int          frameBrightness; // 16 bit entity, -1 is no value
    int          frameWhiteness;
    int          frameContrast;
    int          frameColour;
    int          frameHue;
    int          numberOfFrames;
};


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

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

    static PStringList GetDriverNames(
      PPluginManager * pluginMgr = NULL   
    );

    static PStringList 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 OpenArgs & args,              
      BOOL startImmediate = TRUE          
    );

    virtual BOOL Close() { return TRUE; }

    virtual BOOL Start() { return TRUE; }

    virtual BOOL Stop() { return TRUE; }

    virtual BOOL CanCaptureVideo() const;

    virtual BOOL SetFrameData(
      unsigned x,
      unsigned y,
      unsigned width,
      unsigned height,
      const BYTE * data,
      BOOL endFrame = TRUE
    ) = 0;

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


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

  public:
    PVideoOutputDeviceRGB();

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

    virtual BOOL SetFrameSize(
      unsigned width,   
      unsigned height   
    );

    virtual PINDEX GetMaxFrameBytes();

    virtual BOOL SetFrameData(
      unsigned x,
      unsigned y,
      unsigned width,
      unsigned height,
      const BYTE * data,
      BOOL endFrame = TRUE
    );

    virtual BOOL FrameComplete() = 0;

  protected:
    PMutex     mutex;
    PINDEX     bytesPerPixel;
    PINDEX     scanLineWidth;
    bool       swappedRedAndBlue;
};


#ifdef SHOULD_BE_MOVED_TO_PLUGIN

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

  public:
    PVideoOutputDevicePPM();

    virtual BOOL Open(
      const PString & deviceName,   
      BOOL startImmediate = TRUE    
    );

    virtual BOOL IsOpen();

    virtual BOOL Close();

    virtual PStringList GetDeviceNames() const;

    virtual BOOL EndFrame();

  protected:
    unsigned   frameNumber;
};

#endif // SHOULD_BE_MOVED_TO_PLUGIN


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

  public:
    //PVideoInputDevice();

    ~PVideoInputDevice() { Close(); }

    static PStringList GetDriverNames(
      PPluginManager * pluginMgr = NULL   
    );

    static PStringList 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 OpenArgs & args,              
      BOOL startImmediate = TRUE          
    );

    virtual BOOL Open(
      const PString & deviceName,   
      BOOL startImmediate = TRUE    
    ) = 0;

    virtual BOOL Close(
    ) { return TRUE; }

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

    virtual BOOL GetFrame(
      PBYTEArray & frame
    );

    virtual BOOL GetFrameData(
      BYTE * buffer,                 
      PINDEX * bytesReturned = NULL  
    ) = 0;

    virtual BOOL GetFrameDataNoDelay(
      BYTE * buffer,                 
      PINDEX * bytesReturned = NULL  
    ) = 0;

    virtual BOOL TestAllFormats() = 0;
};


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

template <class className> class PVideoInputPluginServiceDescriptor : public PDevicePluginServiceDescriptor
{
  public:
    virtual PObject *   CreateInstance(int /*userData*/) const { return new className; }
    virtual PStringList GetDeviceNames(int /*userData*/) const { return className::GetInputDeviceNames(); }
};

#define PCREATE_VIDINPUT_PLUGIN(name) \
  static PVideoInputPluginServiceDescriptor<PVideoInputDevice_##name> PVideoInputDevice_##name##_descriptor; \
  PCREATE_PLUGIN(name, PVideoInputDevice, &PVideoInputDevice_##name##_descriptor)

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

template <class className> class PVideoOutputPluginServiceDescriptor : public PDevicePluginServiceDescriptor
{
  public:
    virtual PObject *   CreateInstance(int /*userData*/) const { return new className; }
    virtual PStringList GetDeviceNames(int /*userData*/) const { return className::GetOutputDeviceNames(); }
};

#define PCREATE_VIDOUTPUT_PLUGIN(name) \
  static PVideoOutputPluginServiceDescriptor<PVideoOutputDevice_##name> PVideoOutputDevice_##name##_descriptor; \
  PCREATE_PLUGIN(name, PVideoOutputDevice, &PVideoOutputDevice_##name##_descriptor)

//
// 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   // _PVIDEOIO

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

---