Main Page | Namespace List | Class Hierarchy | Class List | Directories | File List | Class Members | File Members

videoio.h

Go to the documentation of this file.
00001 /*
00002  * videoio.h
00003  *
00004  * Classes to support streaming video input (grabbing) and output.
00005  *
00006  * Portable Windows Library
00007  *
00008  * Copyright (c) 1993-2000 Equivalence Pty. Ltd.
00009  *
00010  * The contents of this file are subject to the Mozilla Public License
00011  * Version 1.0 (the "License"); you may not use this file except in
00012  * compliance with the License. You may obtain a copy of the License at
00013  * http://www.mozilla.org/MPL/
00014  *
00015  * Software distributed under the License is distributed on an "AS IS"
00016  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
00017  * the License for the specific language governing rights and limitations
00018  * under the License.
00019  *
00020  * The Original Code is Portable Windows Library.
00021  *
00022  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
00023  *
00024  * Contributor(s): Mark Cooke (mpc@star.sr.bham.ac.uk)
00025  *
00026  * $Log: videoio.h,v $
00027  * Revision 1.40  2004/04/18 12:49:22  csoutheren
00028  * Patches to video code thanks to Guilhem Tardy (hope I get it right this time :)
00029  *
00030  * Revision 1.39  2004/01/18 14:23:30  dereksmithies
00031  * Add new function to make opening of video input devices easier.
00032  *
00033  * Revision 1.38  2004/01/02 23:30:18  rjongbloed
00034  * Removed extraneous static function for getting input device names that has been deprecated during the plug ins addition.
00035  *
00036  * Revision 1.37  2003/12/14 10:01:02  rjongbloed
00037  * Resolved issue with name space conflict os static and virtual forms of GetDeviceNames() function.
00038  *
00039  * Revision 1.36  2003/12/03 03:47:56  dereksmithies
00040  * Add fix so video output devices compile and run correctly.
00041  * Thanks to Craig Southeren.
00042  *
00043  * Revision 1.35  2003/11/19 04:29:02  csoutheren
00044  * Changed to support video output plugins
00045  *
00046  * Revision 1.34  2003/11/18 10:39:06  csoutheren
00047  * Fixed warnings regarding calling virtual Close in destructors
00048  *
00049  * Revision 1.33  2003/11/18 06:46:15  csoutheren
00050  * Changed to support video input plugins
00051  *
00052  * Revision 1.32  2003/09/17 05:41:59  csoutheren
00053  * Removed recursive includes
00054  *
00055  * Revision 1.31  2003/09/17 01:18:02  csoutheren
00056  * Removed recursive include file system and removed all references
00057  * to deprecated coooperative threading support
00058  *
00059  * Revision 1.30  2003/03/17 08:10:00  robertj
00060  * Fixed GNU warning
00061  *
00062  * Revision 1.29  2003/03/17 07:51:07  robertj
00063  * Added OpenFull() function to open with all video parameters in one go.
00064  * Made sure vflip variable is set in converter even if converter has not
00065  *   been set yet, should not depend on the order of functions!
00066  * Removed canCaptureVideo variable as this is really a virtual function to
00067  *   distinguish PVideoOutputDevice from PVideoInputDevice, it is not dynamic.
00068  * Made significant enhancements to PVideoOutputDevice class.
00069  * Added PVideoOutputDevice descendants for NULL and PPM files.
00070  *
00071  * Revision 1.28  2002/09/16 01:08:59  robertj
00072  * Added #define so can select if #pragma interface/implementation is used on
00073  *   platform basis (eg MacOS) rather than compiler, thanks Robert Monaghan.
00074  *
00075  * Revision 1.27  2002/04/12 08:25:12  robertj
00076  * Added text string output for tracing video format.
00077  *
00078  * Revision 1.26  2002/04/05 06:41:54  rogerh
00079  * Apply video changes from Damien Sandras <dsandras@seconix.com>.
00080  * The Video Channel and Format are no longer set in Open(). Instead
00081  * call the new SetVideoChannelFormat() method. This makes video capture
00082  * and GnomeMeeting more stable with certain Linux video capture devices.
00083  *
00084  * Revision 1.25  2002/02/20 02:37:26  dereks
00085  * Initial release of Firewire camera support for linux.
00086  * Many thanks to Ryutaroh Matsumoto <ryutaroh@rmatsumoto.org>.
00087  *
00088  * Revision 1.24  2002/01/16 07:51:06  robertj
00089  * MSVC compatibilty changes
00090  *
00091  * Revision 1.23  2002/01/16 03:51:20  dereks
00092  * Move flip methods in PVideoInputDevice  to  PVideoDevice
00093  *
00094  * Revision 1.22  2002/01/14 02:59:54  robertj
00095  * Added preferred colour format selection, thanks Walter Whitlock
00096  *
00097  * Revision 1.21  2002/01/04 04:11:45  dereks
00098  * Add video flip code from Walter Whitlock, which flips code at the grabber.
00099  *
00100  * Revision 1.20  2001/11/28 00:07:32  dereks
00101  * Locking added to PVideoChannel, allowing reader/writer to be changed mid call
00102  * Enabled adjustment of the video frame rate
00103  * New fictitous image, a blank grey area
00104  *
00105  * Revision 1.19  2001/08/06 06:12:45  rogerh
00106  * Fix comments
00107  *
00108  * Revision 1.18  2001/08/03 04:21:51  dereks
00109  * Add colour/size conversion for YUV422->YUV411P
00110  * Add Get/Set Brightness,Contrast,Hue,Colour for PVideoDevice,  and
00111  * Linux PVideoInputDevice.
00112  * Add lots of PTRACE statement for debugging colour conversion.
00113  * Add support for Sony Vaio laptop under linux. Requires 2.4.7 kernel.
00114  *
00115  * Revision 1.17  2001/05/22 23:38:45  robertj
00116  * Fixed bug in PVideoOutputDevice, removed redundent SetFrameSize.
00117  *
00118  * Revision 1.16  2001/05/22 12:49:32  robertj
00119  * Did some seriously wierd rewrite of platform headers to eliminate the
00120  *   stupid GNU compiler warning about braces not matching.
00121  *
00122  * Revision 1.15  2001/03/20 02:21:57  robertj
00123  * More enhancements from Mark Cooke
00124  *
00125  * Revision 1.14  2001/03/08 23:04:19  robertj
00126  * Fixed up some documentation.
00127  *
00128  * Revision 1.13  2001/03/08 08:31:34  robertj
00129  * Numerous enhancements to the video grabbing code including resizing
00130  *   infrastructure to converters. Thanks a LOT, Mark Cooke.
00131  *
00132  * Revision 1.12  2001/03/07 01:42:59  dereks
00133  * miscellaneous video fixes. Works on linux now. Add debug statements
00134  * (at PTRACE level of 1)
00135  *
00136  * Revision 1.11  2001/03/06 23:34:20  robertj
00137  * Added static function to get input device names.
00138  * Moved some inline virtuals to non-inline.
00139  *
00140  * Revision 1.10  2001/03/03 05:06:31  robertj
00141  * Major upgrade of video conversion and grabbing classes.
00142  *
00143  * Revision 1.9  2001/02/28 01:47:14  robertj
00144  * Removed function from ancestor and is not very useful, thanks Thorsten Westheider.
00145  *
00146  * Revision 1.8  2000/12/19 22:20:26  dereks
00147  * Add video channel classes to connect to the PwLib PVideoInputDevice class.
00148  * Add PFakeVideoInput class to generate test images for video.
00149  *
00150  * Revision 1.7  2000/11/09 00:20:38  robertj
00151  * Added qcif size constants
00152  *
00153  * Revision 1.6  2000/07/30 03:41:31  robertj
00154  * Added more colour formats to video device enum.
00155  *
00156  * Revision 1.5  2000/07/26 03:50:49  robertj
00157  * Added last error variable to video device.
00158  *
00159  * Revision 1.4  2000/07/26 02:13:46  robertj
00160  * Added some more "common" bounds checking to video device.
00161  *
00162  * Revision 1.3  2000/07/25 13:38:25  robertj
00163  * Added frame rate parameter to video frame grabber.
00164  *
00165  * Revision 1.2  2000/07/25 13:14:05  robertj
00166  * Got the video capture stuff going!
00167  *
00168  * Revision 1.1  2000/07/15 09:47:34  robertj
00169  * Added video I/O device classes.
00170  *
00171  */
00172 
00173 
00174 #ifndef _PVIDEOIO
00175 #define _PVIDEOIO
00176 
00177 #ifdef P_USE_PRAGMA
00178 #pragma interface
00179 #endif
00180 
00181 #if defined(_WIN32)
00182 PWLIB_STATIC_LOAD_PLUGIN(PVideoInputDevice_VideoForWindows);
00183 PWLIB_STATIC_LOAD_PLUGIN(PVideoInputDevice_FakeVideo);
00184 
00185 PWLIB_STATIC_LOAD_PLUGIN(PVideoOutputDevice_NULLOutput);
00186 #endif
00187 
00188 class PColourConverter;
00189 
00220 class PVideoDevice : public PObject
00221 {
00222   PCLASSINFO(PVideoDevice, PObject);
00223 
00224   protected:
00227     PVideoDevice();
00228 
00229 
00230   public:
00233     virtual ~PVideoDevice();
00234 
00235     enum VideoFormat {
00236       PAL,
00237       NTSC,
00238       SECAM,
00239       Auto,
00240       NumVideoFormats
00241     };
00242 
00243     enum StandardSizes {
00244       CIF16Width = 1408,
00245       CIF16Height = 1152,
00246       CIF4Width = 704,
00247       CIF4Height = 576,
00248       CIFWidth = 352,
00249       CIFHeight = 288,
00250       QCIFWidth = 176,
00251       QCIFHeight = 144,
00252       SQCIFWidth = 144,
00253       SQCIFHeight = 96,
00254     };
00255 
00256     struct OpenArgs {
00257       OpenArgs()
00258         : deviceName("#1"),
00259           videoFormat(Auto),
00260           channelNumber(0),
00261           colourFormat("YUV420P"),
00262           convertFormat(TRUE),
00263           rate(0),
00264           width(CIFWidth),
00265           height(CIFHeight),
00266           convertSize(TRUE),
00267           scaleSize(FALSE),
00268           flip(FALSE),
00269           brightness(-1),
00270           whiteness(-1),
00271           contrast(-1),
00272           colour(-1),
00273           hue(-1)
00274         { }
00275       PString     deviceName;
00276       VideoFormat videoFormat;
00277       int         channelNumber;
00278       PString     colourFormat;
00279       BOOL        convertFormat;
00280       unsigned    rate;
00281       unsigned    width;
00282       unsigned    height;
00283       BOOL        convertSize;
00284       BOOL        scaleSize;
00285       BOOL        flip;
00286       int         brightness;
00287       int         whiteness;
00288       int         contrast;
00289       int         colour;
00290       int         hue;
00291     };
00292 
00295     virtual BOOL OpenFull(
00296       const OpenArgs & args,      
00297       BOOL startImmediate = TRUE  
00298     );
00299 
00302     virtual BOOL Open(
00303       const PString & deviceName,   
00304       BOOL startImmediate = TRUE    
00305     ) = 0;
00306 
00309     virtual BOOL IsOpen() = 0;
00310 
00313     virtual BOOL Close() = 0;
00314 
00317     virtual BOOL Start() = 0;
00318 
00321     virtual BOOL Stop() = 0;
00322 
00323 
00326     const PString & GetDeviceName() const
00327       { return deviceName; }
00328 
00331     virtual PStringList GetDeviceNames() const = 0;
00332 
00333 #if PTRACING
00334     friend ostream & operator<<(ostream &, VideoFormat);
00335 #endif
00336 
00342     virtual BOOL SetVideoFormat(
00343       VideoFormat videoFormat   
00344     );
00345 
00350     virtual VideoFormat GetVideoFormat() const;
00351 
00356     virtual int GetNumChannels();
00357 
00365     virtual BOOL SetChannel(
00366       int channelNumber  
00367     );
00368 
00373     virtual int GetChannel() const;
00374 
00381     virtual BOOL SetColourFormatConverter(
00382       const PString & colourFormat // New colour format for device.
00383     );
00384 
00395     virtual BOOL SetColourFormat(
00396       const PString & colourFormat // New colour format for device.
00397     );
00398 
00403     const PString & GetColourFormat() const;
00404 
00410     virtual BOOL SetFrameRate(
00411       unsigned rate  
00412     );
00413 
00418     virtual unsigned GetFrameRate() const;
00419 
00425     virtual BOOL GetFrameSizeLimits(
00426       unsigned & minWidth,   
00427       unsigned & minHeight,  
00428       unsigned & maxWidth,   
00429       unsigned & maxHeight   
00430     ) ;
00431 
00432 
00438     virtual BOOL SetFrameSizeConverter(
00439       unsigned width,        
00440       unsigned height,       
00441       BOOL     bScaleNotCrop 
00442     );
00443 
00452     virtual BOOL SetFrameSize(
00453       unsigned width,   
00454       unsigned height   
00455     );
00456 
00462     virtual BOOL GetFrameSize(
00463       unsigned & width,
00464       unsigned & height
00465     );
00466 
00471     virtual unsigned GetFrameWidth() const;
00472 
00477     virtual unsigned GetFrameHeight() const;
00478 
00484     virtual PINDEX GetMaxFrameBytes() = 0;
00485 
00488     static unsigned CalculateFrameBytes( 
00489       unsigned width,
00490       unsigned height,
00491       const PString & colourFormat
00492     );
00493 
00494     
00497     int GetLastError() const { return lastError; }
00498 
00499 
00502     virtual BOOL CanCaptureVideo() const = 0;
00503 
00506     virtual int GetBrightness();
00507 
00510     virtual BOOL SetBrightness(unsigned newBrightness);
00511 
00512 
00515     virtual int GetWhiteness();
00516 
00519     virtual BOOL SetWhiteness(unsigned newWhiteness);
00520 
00521 
00524     virtual int GetColour();
00525 
00528     virtual BOOL SetColour(unsigned newColour);
00529 
00530 
00533     virtual int GetContrast();
00534 
00537     virtual BOOL SetContrast(unsigned newContrast);
00538 
00539 
00542     virtual int GetHue();
00543 
00546     virtual BOOL SetHue(unsigned newHue);
00547     
00548     
00551     virtual BOOL GetParameters(
00552       int *whiteness,
00553       int *brightness,
00554       int *colour,
00555       int *contrast,
00556       int *hue
00557     );
00558 
00559     
00562     virtual BOOL SetVideoChannelFormat (
00563       int channelNumber, 
00564       VideoFormat videoFormat
00565     );
00566 
00567 
00571     virtual BOOL GetVFlipState();
00572 
00576     virtual BOOL SetVFlipState(
00577       BOOL newVFlipState    
00578     );
00579 
00580 
00584     void SetPreferredColourFormat(const PString & colourFmt) { preferredColourFormat = colourFmt; }
00585 
00589     const PString & GetPreferredColourFormat() { return preferredColourFormat; }
00590 
00591   protected:
00592     PString      deviceName;
00593     int          lastError;
00594     VideoFormat  videoFormat;
00595     int          channelNumber;
00596     PString      colourFormat;
00597     // Preferred native colour format from video input device, empty == no preference
00598     PString      preferredColourFormat;
00599     unsigned     frameRate;
00600     unsigned     frameWidth;
00601     unsigned     frameHeight;
00602     BOOL         doVFlip;
00603 
00604     PColourConverter * converter;
00605  
00606     int          frameBrightness; // 16 bit entity, -1 is no value
00607     int          frameWhiteness;
00608     int          frameContrast;
00609     int          frameColour;
00610     int          frameHue;
00611 
00612     PTime        previousFrameTime; // Time of the last frame.
00613     int          msBetweenFrames;   // msBetween subsequent frames. 
00614     int          frameTimeError;    // determines  when this frame should happen.
00615 };
00616 
00617 
00620 class PVideoOutputDevice : public PVideoDevice
00621 {
00622   PCLASSINFO(PVideoOutputDevice, PVideoDevice);
00623 
00624   public:
00627     PVideoOutputDevice();
00628     
00631     virtual ~PVideoOutputDevice() { Close(); };      
00632 
00636     static PStringList GetDriverNames(PPluginManager * pluginMgr = NULL);
00637 
00641     static PStringList GetDriversDeviceNames(
00642                                      const PString &driverName,
00643                                      PPluginManager * pluginMgr = NULL
00644                                      );
00645 
00649     static PVideoOutputDevice *CreateDevice(
00650                                           const PString &driverName,
00651                                           PPluginManager * pluginMgr = NULL
00652                                           );
00653 
00657     static PVideoOutputDevice *CreateOpenedDevice(
00658                                           const PString & driverName,
00659                                           const PString & deviceName,
00660                                           BOOL startImmediate = TRUE,
00661                                           PPluginManager * pluginMgr = NULL
00662                                           );
00663 
00666     virtual BOOL Close() { return TRUE; }
00667 
00670     virtual BOOL CanCaptureVideo() const;
00671 
00674     virtual BOOL SetFrameData(
00675       unsigned x,
00676       unsigned y,
00677       unsigned width,
00678       unsigned height,
00679       const BYTE * data,
00680       BOOL endFrame = TRUE
00681     ) = 0;
00682 
00688     virtual BOOL Start() { return TRUE; }
00689 
00692     virtual BOOL Stop() { return TRUE; }
00693 };
00694 
00695 
00696 #ifdef SHOULD_BE_MOVED_TO_PLUGIN
00697 
00700 class PVideoOutputDeviceRGB : public PVideoOutputDevice
00701 {
00702   PCLASSINFO(PVideoOutputDeviceRGB, PVideoOutputDevice);
00703 
00704   public:
00707     PVideoOutputDeviceRGB();
00708 
00719     virtual BOOL SetColourFormat(
00720       const PString & colourFormat // New colour format for device.
00721     );
00722 
00731     virtual BOOL SetFrameSize(
00732       unsigned width,   
00733       unsigned height   
00734     );
00735 
00741     virtual PINDEX GetMaxFrameBytes();
00742 
00745     virtual BOOL SetFrameData(
00746       unsigned x,
00747       unsigned y,
00748       unsigned width,
00749       unsigned height,
00750       const BYTE * data,
00751       BOOL endFrame = TRUE
00752     );
00753 
00756     virtual BOOL EndFrame() = 0;
00757 
00758   protected:
00759     PBYTEArray frameStore;
00760     PINDEX     bytesPerPixel;
00761 };
00762 
00763 #endif // SHOULD_BE_MOVED_TO_PLUGIN
00764 
00765 #ifdef SHOULD_BE_MOVED_TO_PLUGIN
00766 
00769 class PVideoOutputDevicePPM : public PVideoOutputDeviceRGB
00770 {
00771   PCLASSINFO(PVideoOutputDevicePPM, PVideoOutputDeviceRGB);
00772 
00773   public:
00776     PVideoOutputDevicePPM();
00777 
00780     virtual BOOL Open(
00781       const PString & deviceName,   
00782       BOOL startImmediate = TRUE    
00783     );
00784 
00787     virtual BOOL IsOpen();
00788 
00791     virtual BOOL Close();
00792 
00795     virtual PStringList GetDeviceNames() const;
00796 
00799     virtual BOOL EndFrame();
00800 
00801   protected:
00802     unsigned   frameNumber;
00803 };
00804 
00805 #endif // SHOULD_BE_MOVED_TO_PLUGIN
00806 
00809 class PVideoInputDevice : public PVideoDevice
00810 {
00811   PCLASSINFO(PVideoInputDevice, PVideoDevice);
00812 
00813   public:
00816     //PVideoInputDevice();
00817 
00820     ~PVideoInputDevice() { Close(); }
00821 
00825     static PStringList GetDriverNames(PPluginManager * pluginMgr = NULL);
00826 
00830     static PStringList GetDriversDeviceNames(
00831                                      const PString &driverName,
00832                                      PPluginManager * pluginMgr = NULL
00833                                      );
00834 
00838     static PVideoInputDevice *CreateDevice(
00839                                           const PString &driverName,
00840                                           PPluginManager * pluginMgr = NULL
00841                                           );
00842 
00843     /* Return the matching video input device that corresponds to the devicename.
00844        So, for "fake" return a device that will generate fake video.
00845        For "Phillips 680 webcam" (eg) will return appropriate grabber.
00846        Note that Phillips will return the appropriate grabber also.
00847      */
00848     static PVideoInputDevice *CreateDeviceByName(const PString &deviceName,
00849                                           PPluginManager * pluginMgr = NULL
00850                                           );
00851 
00855     static PVideoInputDevice *CreateOpenedDevice(
00856                                           const PString & driverName,
00857                                           const PString & deviceName,
00858                                           BOOL startImmediate = TRUE,
00859                                           PPluginManager * pluginMgr = NULL
00860                                           );
00861 
00864     virtual BOOL CanCaptureVideo() const;
00865  
00868     virtual BOOL Open(
00869       const PString & deviceName,   
00870       BOOL startImmediate = TRUE    
00871     ) = 0;
00872 
00873     virtual BOOL Close(
00874     ) { return TRUE; }
00875 
00878     virtual BOOL IsCapturing() = 0;
00879 
00885     virtual PINDEX GetMaxFrameBytes() = 0;
00886 
00889     virtual BOOL GetFrame(
00890       PBYTEArray & frame
00891     ) = 0;
00892 
00895     virtual BOOL GetFrameData(
00896       BYTE * buffer,                 
00897       PINDEX * bytesReturned = NULL  
00898     ) = 0;
00899 
00902     virtual BOOL GetFrameDataNoDelay(
00903       BYTE * buffer,                 
00904       PINDEX * bytesReturned = NULL  
00905     ) = 0;
00906 
00909     virtual BOOL TestAllFormats() = 0;
00910 };
00911 
00913 //
00914 // declare macros and structures needed for video input plugins
00915 //
00916 
00917 class PVideoInputDevicePluginServiceDescriptor : public PPluginServiceDescriptor
00918 {
00919   public:
00920     PVideoInputDevicePluginServiceDescriptor(
00921                      unsigned (*_GetVersion)(),
00922                PVideoInputDevice *(*_CreateInstance)(),
00923                  PStringList (*_GetDeviceNames)()
00924      )
00925     : PPluginServiceDescriptor(_GetVersion),
00926       CreateInstance(_CreateInstance),
00927       GetDeviceNames(_GetDeviceNames)
00928     { }
00929 
00930     PVideoInputDevice *(*CreateInstance)();
00931     PStringList (*GetDeviceNames) ();
00932 };
00933 
00934 
00935 #define PCREATE_VIDINPUT_SERVICE_DESCRIPTOR(className, versionFn) \
00936 PVideoInputDevice * className##_CreateInstance () \
00937 { \
00938   return new className; \
00939 } \
00940 \
00941 PStringList className##_GetDeviceNames () \
00942 { \
00943   return className::GetInputDeviceNames(); \
00944 } \
00945 \
00946 PVideoInputDevicePluginServiceDescriptor className##_descriptor(\
00947    versionFn, \
00948    className##_CreateInstance, \
00949    className##_GetDeviceNames \
00950 ); \
00951 
00952 #define PCREATE_VIDINPUT_PLUGIN(name, className) \
00953 PCREATE_PLUGIN_VERSION_FN(name, PVideoInputDevice) \
00954 PCREATE_VIDINPUT_SERVICE_DESCRIPTOR(className, PPLUGIN_VERSION_FN(name, PVideoInputDevice)) \
00955 PCREATE_PLUGIN(name, PVideoInputDevice, &className##_descriptor)
00956 
00958 //
00959 // declare macros and structures needed for video output plugins
00960 //
00961 
00962 class PVideoOutputDevicePluginServiceDescriptor : public PPluginServiceDescriptor
00963 {
00964   public:
00965     PVideoOutputDevicePluginServiceDescriptor(
00966                      unsigned (*_GetVersion)(),
00967                PVideoOutputDevice *(*_CreateInstance)(),
00968                  PStringList (*_GetDeviceNames)()
00969      )
00970     : PPluginServiceDescriptor(_GetVersion),
00971       CreateInstance(_CreateInstance),
00972       GetDeviceNames(_GetDeviceNames)
00973     { }
00974 
00975     PVideoOutputDevice *(*CreateInstance)();
00976     PStringList (*GetDeviceNames) ();
00977 };
00978 
00979 
00980 #define PCREATE_VIDOUTPUT_SERVICE_DESCRIPTOR(className, versionFn) \
00981 PVideoOutputDevice * className##_CreateInstance () \
00982 { \
00983   return new className; \
00984 } \
00985 \
00986 PStringList className##_GetDeviceNames () \
00987 { \
00988   return className::GetOutputDeviceNames(); \
00989 } \
00990 \
00991 PVideoOutputDevicePluginServiceDescriptor className##_descriptor(\
00992    versionFn, \
00993    className##_CreateInstance, \
00994    className##_GetDeviceNames \
00995 ); \
00996 
00997 #define PCREATE_VIDOUTPUT_PLUGIN(name, className) \
00998 PCREATE_PLUGIN_VERSION_FN(name, PVideoOutputDevice) \
00999 PCREATE_VIDOUTPUT_SERVICE_DESCRIPTOR(className, PPLUGIN_VERSION_FN(name, PVideoOutputDevice)) \
01000 PCREATE_PLUGIN(name, PVideoOutputDevice, &className##_descriptor)
01001 
01002 #endif   // _PVIDEOIO
01003 
01004 // End Of File ///////////////////////////////////////////////////////////////

Generated on Tue Mar 15 10:44:52 2005 for PWLib by  doxygen 1.4.0