PTLib  Version 2.10.4
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  * $Revision: 25752 $
00027  * $Author: rjongbloed $
00028  * $Date: 2011-05-11 21:50:32 -0500 (Wed, 11 May 2011) $
00029  */
00030 
00031 
00032 #ifndef PTLIB_PVIDEOIO_H
00033 #define PTLIB_PVIDEOIO_H
00034 
00035 #ifdef P_USE_PRAGMA
00036 #pragma interface
00037 #endif
00038 #include <ptbuildopts.h>
00039 
00040 #if P_VIDEO
00041 
00042 #include <ptlib/plugin.h>
00043 #include <ptlib/pluginmgr.h>
00044 #include <list>
00045 
00046 class PColourConverter;
00047 
00048 
00049 class PVideoFrameInfo : public PObject
00050 {
00051   PCLASSINFO(PVideoFrameInfo, PObject);
00052 
00053   public:
00054     enum ResizeMode
00055     {
00056       eScale,
00057       eCropCentre,
00058       eCropTopLeft,
00059       eMaxResizeMode
00060     };
00061     friend ostream & operator<<(ostream & strm, ResizeMode mode);
00062 
00063     enum StandardSizes {
00064       SQCIFWidth = 128,  SQCIFHeight = 96,
00065       QCIFWidth  = 176,  QCIFHeight  = 144,
00066       CIFWidth   = 352,  CIFHeight   = 288,
00067       CIF4Width  = 704,  CIF4Height  = 576,
00068       CIF16Width = 1408, CIF16Height = 1152,
00069       HD480Width = 704,  HD480Height = 480,
00070       i480Width  = 704,  i480Height  = 480,
00071       HD720Width = 1280, HD720Height = 720,
00072       p720Width  = 1280, p720Height  = 720,
00073       HD1080Width= 1920, HD1080Height= 1080,
00074       i1080Width = 1920, i1080Height = 1080,
00075       HDTVWidth  = 1920, HDTVHeight  = 1080,
00076       MaxWidth   = 1920, MaxHeight   = 1200
00077     };
00078 
00080     PVideoFrameInfo();
00081     PVideoFrameInfo(
00082       unsigned        frameWidth,
00083       unsigned        frameHeight,
00084       const PString & colourFormat = "YUV420P",
00085       unsigned        frameRate = 15,
00086       ResizeMode      resizeMode = eScale
00087     );
00088 
00095     virtual void PrintOn(
00096       ostream & strm   // Stream to print the object into.
00097     ) const;
00098 
00104     virtual PBoolean SetFrameSize(
00105       unsigned width,   
00106       unsigned height   
00107     );
00108 
00114     virtual PBoolean GetFrameSize(
00115       unsigned & width,
00116       unsigned & height
00117     ) const;
00118 
00123     virtual unsigned GetFrameWidth() const;
00124 
00129     virtual unsigned GetFrameHeight() const;
00130 
00136     virtual PBoolean SetFrameSar(unsigned width, unsigned height);
00137 
00143     virtual PBoolean GetSarSize(
00144       unsigned & width,
00145       unsigned & height
00146     ) const;
00147 
00152     virtual unsigned GetSarWidth() const;
00153 
00158     virtual unsigned GetSarHeight() const;
00159     
00165     virtual PBoolean SetFrameRate(
00166       unsigned rate  
00167     );
00168 
00173     virtual unsigned GetFrameRate() const;
00174 
00180     virtual PBoolean SetColourFormat(
00181       const PString & colourFormat // New colour format for device.
00182     );
00183 
00188     virtual const PString & GetColourFormat() const;
00189 
00192     void SetResizeMode(
00193       ResizeMode mode
00194     ) { if (resizeMode < eMaxResizeMode) resizeMode = mode; }
00195 
00198     ResizeMode GetResizeMode() const { return resizeMode; }
00199 
00202     PINDEX CalculateFrameBytes() const { return CalculateFrameBytes(frameWidth, frameHeight, colourFormat); }
00203     static PINDEX CalculateFrameBytes(
00204       unsigned width,               
00205       unsigned height,              
00206       const PString & colourFormat  
00207     );
00208 
00222     bool Parse(
00223       const PString & str   
00224     );
00225 
00230     static bool ParseSize(
00231       const PString & str,  
00232       unsigned & width,     
00233       unsigned & height     
00234     );
00235 
00238     static PString AsString(
00239       unsigned width,     
00240       unsigned height     
00241     );
00242 
00247     static PStringArray GetSizeNames();
00248 
00249   protected:
00250     unsigned   frameWidth;
00251     unsigned   frameHeight;
00252     unsigned   sarWidth;
00253     unsigned   sarHeight;
00254     unsigned   frameRate;
00255     PString    colourFormat;
00256     ResizeMode resizeMode;
00257 };
00258 
00259 
00260 class PVideoControlInfo : public PObject
00261 {
00262   PCLASSINFO(PVideoControlInfo, PObject);
00263 
00264  public:
00265 
00266     typedef enum {
00267       ControlPan,
00268       ControlTilt,
00269       ControlZoom
00270     } InputControlType;
00271 
00272     static PString AsString(const InputControlType & type);
00273 
00274     InputControlType type;
00275     long             min;
00276     long             max;
00277     long             step;
00278     long             def;
00279     long             flags;
00280     long             current;
00281 };
00282 
00283 
00287 class PVideoInputControl : public PVideoControlInfo
00288 {
00289     PCLASSINFO(PVideoInputControl, PVideoControlInfo);
00290 
00291 public:
00292   ~PVideoInputControl();
00293 
00294   virtual PBoolean Pan(long value, bool absolute = false );
00295   virtual PBoolean Tilt(long value, bool absolute = false);
00296   virtual PBoolean Zoom(long value, bool absolute = false);
00297 
00298   long GetPan();
00299   long GetTilt();
00300   long GetZoom();
00301 
00302   void Reset();
00303   void SetCurrentPosition(const InputControlType ctype, long current);
00304 
00305   typedef std::list<PVideoControlInfo> InputDeviceControls;
00306 
00307 protected:
00308   PBoolean GetVideoControlInfo(const InputControlType ctype, PVideoControlInfo & control);
00309   PBoolean GetDefaultPosition(const InputControlType ctype, long & def);
00310   PBoolean GetCurrentPosition(const InputControlType ctype, long & current);
00311 
00312   std::list<PVideoControlInfo> m_info;
00313   PMutex ccmutex;
00314 
00315 };
00316 
00319 class PVideoInteractionInfo : public PObject
00320 {
00321   PCLASSINFO(PVideoInteractionInfo, PObject);
00322 
00323  public:
00324 
00325    typedef enum {
00326         InteractKey,    
00327         InteractMouse,    
00328         InteractNavigate,  
00329     InteractRTSP,    
00330     InteractOther    
00331      } InputInteractType;
00332 
00333    static PString AsString(const InputInteractType & type);
00334 
00335   InputInteractType type;
00336 };
00337 
00338 
00367 class PVideoDevice : public PVideoFrameInfo
00368 {
00369   PCLASSINFO(PVideoDevice, PVideoFrameInfo);
00370 
00371   protected:
00374     PVideoDevice();
00375 
00376 
00377   public:
00380     virtual ~PVideoDevice();
00381 
00382     enum VideoFormat {
00383       PAL,
00384       NTSC,
00385       SECAM,
00386       Auto,
00387       NumVideoFormats
00388     };
00389 
00392     const PString & GetDeviceName() const
00393       { return deviceName; }
00394 
00397     virtual PStringArray GetDeviceNames() const = 0;
00398 
00399     struct OpenArgs {
00400       OpenArgs();
00401 
00402       PPluginManager * pluginMgr;
00403       PString     driverName;
00404       PString     deviceName;
00405       VideoFormat videoFormat;
00406       int         channelNumber;
00407       PString     colourFormat;
00408       bool        convertFormat;
00409       unsigned    rate;
00410       unsigned    width;
00411       unsigned    height;
00412       bool        convertSize;
00413       ResizeMode  resizeMode;
00414       bool        flip;
00415       int         brightness;
00416       int         whiteness;
00417       int         contrast;
00418       int         colour;
00419       int         hue;
00420     };
00421 
00424     virtual PBoolean OpenFull(
00425       const OpenArgs & args,      
00426       PBoolean startImmediate = true  
00427     );
00428 
00431     virtual PBoolean Open(
00432       const PString & deviceName,   
00433       PBoolean startImmediate = true    
00434     ) = 0;
00435 
00438     virtual PBoolean IsOpen() = 0;
00439 
00442     virtual PBoolean Close() = 0;
00443 
00446     virtual PBoolean Start() = 0;
00447 
00450     virtual PBoolean Stop() = 0;
00451 
00452 
00453 #if PTRACING
00454     friend ostream & operator<<(ostream &, VideoFormat);
00455 #endif
00456 
00462     virtual PBoolean SetVideoFormat(
00463       VideoFormat videoFormat   
00464     );
00465 
00470     virtual VideoFormat GetVideoFormat() const;
00471 
00476     virtual int GetNumChannels();
00477 
00485     virtual PBoolean SetChannel(
00486       int channelNumber  
00487     );
00488 
00493     virtual int GetChannel() const;
00494 
00501     virtual PBoolean SetColourFormatConverter(
00502       const PString & colourFormat // New colour format for device.
00503     );
00504 
00508     virtual PBoolean GetVFlipState();
00509 
00513     virtual PBoolean SetVFlipState(
00514       PBoolean newVFlipState    
00515     );
00516 
00522     virtual PBoolean GetFrameSizeLimits(
00523       unsigned & minWidth,   
00524       unsigned & minHeight,  
00525       unsigned & maxWidth,   
00526       unsigned & maxHeight   
00527     ) ;
00528 
00529 
00535     virtual PBoolean SetFrameSizeConverter(
00536       unsigned width,  
00537       unsigned height, 
00538       ResizeMode resizeMode = eMaxResizeMode 
00539     );
00540 
00546     virtual PBoolean SetFrameSizeConverter(
00547       unsigned width,                   
00548       unsigned height,                  
00549     PBoolean  /*bScaleNotCrop*/           
00550     )  { return SetFrameSizeConverter(width,height,eScale); }
00551 
00552 
00560     virtual PBoolean SetNearestFrameSize(
00561       unsigned width,   
00562       unsigned height   
00563     );
00564 
00573     virtual PBoolean SetFrameSize(
00574       unsigned width,   
00575       unsigned height   
00576     );
00577 
00583     virtual PBoolean GetFrameSize(
00584       unsigned & width,
00585       unsigned & height
00586     ) const;
00587 
00593     virtual PINDEX GetMaxFrameBytes() = 0;
00594 
00595     
00598     int GetLastError() const { return lastError; }
00599 
00600 
00603     virtual PBoolean CanCaptureVideo() const = 0;
00604 
00607     virtual int GetBrightness();
00608 
00611     virtual PBoolean SetBrightness(unsigned newBrightness);
00612 
00613 
00616     virtual int GetWhiteness();
00617 
00620     virtual PBoolean SetWhiteness(unsigned newWhiteness);
00621 
00622 
00625     virtual int GetColour();
00626 
00629     virtual PBoolean SetColour(unsigned newColour);
00630 
00631 
00634     virtual int GetContrast();
00635 
00638     virtual PBoolean SetContrast(unsigned newContrast);
00639 
00640 
00643     virtual int GetHue();
00644 
00647     virtual PBoolean SetHue(unsigned newHue);
00648     
00649     
00652     virtual PBoolean GetParameters(
00653       int *whiteness,
00654       int *brightness,
00655       int *colour,
00656       int *contrast,
00657       int *hue
00658     );
00659 
00660     
00663     virtual PBoolean SetVideoChannelFormat (
00664       int channelNumber, 
00665       VideoFormat videoFormat
00666     );
00667 
00668 
00672     void SetPreferredColourFormat(const PString & colourFmt) { preferredColourFormat = colourFmt; }
00673 
00677     const PString & GetPreferredColourFormat() { return preferredColourFormat; }
00678     
00679   protected:
00680     PINDEX GetMaxFrameBytesConverted(PINDEX rawFrameBytes) const;
00681 
00682     PString      deviceName;
00683     int          lastError;
00684     VideoFormat  videoFormat;
00685     int          channelNumber;
00686     // Preferred native colour format from video input device, empty == no preference
00687     PString      preferredColourFormat;
00688     PBoolean         nativeVerticalFlip;
00689 
00690     PColourConverter * converter;
00691     PBYTEArray         frameStore;
00692 
00693     int          frameBrightness; // 16 bit entity, -1 is no value
00694     int          frameWhiteness;
00695     int          frameContrast;
00696     int          frameColour;
00697     int          frameHue;
00698 };
00699 
00700 
00703 class PVideoOutputDevice : public PVideoDevice
00704 {
00705   PCLASSINFO(PVideoOutputDevice, PVideoDevice);
00706 
00707   public:
00710     PVideoOutputDevice();
00711     
00714     virtual ~PVideoOutputDevice() { Close(); };      
00715 
00718     static PStringArray GetDriverNames(
00719       PPluginManager * pluginMgr = NULL   
00720     );
00721 
00728     static PStringArray GetDriversDeviceNames(
00729       const PString & driverName,         
00730       PPluginManager * pluginMgr = NULL   
00731     );
00732 
00735     static PVideoOutputDevice * CreateDevice(
00736       const PString & driverName,         
00737       PPluginManager * pluginMgr = NULL   
00738     );
00739 
00740     /* Create the matching video output device that corresponds to the device name.
00741 
00742        This is typically used with the return values from GetDriversDeviceNames().
00743      */
00744     static PVideoOutputDevice *CreateDeviceByName(
00745       const PString & deviceName,         
00746       const PString & driverName = PString::Empty(),  
00747       PPluginManager * pluginMgr = NULL   
00748     );
00749 
00755     static PVideoOutputDevice *CreateOpenedDevice(
00756       const PString & driverName,         
00757       const PString & deviceName,         
00758       PBoolean startImmediate = true,         
00759       PPluginManager * pluginMgr = NULL   
00760     );
00761 
00764     static PVideoOutputDevice *CreateOpenedDevice(
00765       const OpenArgs & args,              
00766       PBoolean startImmediate = true          
00767     );
00768 
00771     virtual PBoolean Close() { return true; }
00772 
00775     virtual PBoolean Start() { return true; }
00776 
00779     virtual PBoolean Stop() { return true; }
00780 
00783     virtual PBoolean CanCaptureVideo() const;
00784 
00787     virtual PBoolean SetFrameData(
00788       unsigned x,
00789       unsigned y,
00790       unsigned width,
00791       unsigned height,
00792       const BYTE * data,
00793       PBoolean endFrame = true
00794     ) = 0;
00795     virtual PBoolean SetFrameData(
00796       unsigned x,
00797       unsigned y,
00798       unsigned width,
00799       unsigned height,
00800       const BYTE * data,
00801       PBoolean endFrame,
00802       unsigned flags
00803     );
00804     virtual PBoolean SetFrameData(
00805       unsigned x,
00806       unsigned y,
00807       unsigned width,
00808       unsigned height,
00809       unsigned sarwidth,
00810       unsigned sarheight,
00811       const BYTE * data,
00812       PBoolean endFrame,
00813       unsigned flags,
00814       const void * mark
00815     );
00816 
00823     virtual PBoolean DisableDecode();
00824 
00831     virtual PBoolean GetPosition(
00832       int & x,  // X position of device surface
00833       int & y   // Y position of device surface
00834     ) const;
00835 
00842     virtual bool SetPosition(
00843       int x,  // X position of device surface
00844       int y   // Y position of device surface
00845     );
00846 };
00847 
00848 
00851 class PVideoOutputDeviceRGB : public PVideoOutputDevice
00852 {
00853   PCLASSINFO(PVideoOutputDeviceRGB, PVideoOutputDevice);
00854 
00855   public:
00858     PVideoOutputDeviceRGB();
00859 
00870     virtual PBoolean SetColourFormat(
00871       const PString & colourFormat // New colour format for device.
00872     );
00873 
00882     virtual PBoolean SetFrameSize(
00883       unsigned width,   
00884       unsigned height   
00885     );
00886 
00892     virtual PINDEX GetMaxFrameBytes();
00893 
00896     virtual PBoolean SetFrameData(
00897       unsigned x,
00898       unsigned y,
00899       unsigned width,
00900       unsigned height,
00901       const BYTE * data,
00902       PBoolean endFrame = true
00903     );
00904 
00907     virtual PBoolean FrameComplete() = 0;
00908 
00909   protected:
00910     PMutex     mutex;
00911     PINDEX     bytesPerPixel;
00912     PINDEX     scanLineWidth;
00913     bool       swappedRedAndBlue;
00914 };
00915 
00916 
00917 #ifdef SHOULD_BE_MOVED_TO_PLUGIN
00918 
00921 class PVideoOutputDevicePPM : public PVideoOutputDeviceRGB
00922 {
00923   PCLASSINFO(PVideoOutputDevicePPM, PVideoOutputDeviceRGB);
00924 
00925   public:
00928     PVideoOutputDevicePPM();
00929 
00932     virtual PBoolean Open(
00933       const PString & deviceName,   
00934       PBoolean startImmediate = true    
00935     );
00936 
00939     virtual PBoolean IsOpen();
00940 
00943     virtual PBoolean Close();
00944 
00947     virtual PStringArray GetDeviceNames() const;
00948 
00951     virtual PBoolean EndFrame();
00952 
00953   protected:
00954     unsigned   frameNumber;
00955 };
00956 
00957 #endif // SHOULD_BE_MOVED_TO_PLUGIN
00958 
00959 
00962 class PVideoInputDevice : public PVideoDevice
00963 {
00964   PCLASSINFO(PVideoInputDevice, PVideoDevice);
00965 
00966   public:
00969     //PVideoInputDevice();
00970 
00973     ~PVideoInputDevice() { Close(); }
00974 
00977     static PStringArray GetDriverNames(
00978       PPluginManager * pluginMgr = NULL   
00979     );
00980 
00987     static PStringArray GetDriversDeviceNames(
00988       const PString & driverName,         
00989       PPluginManager * pluginMgr = NULL   
00990     );
00991 
00994     static PVideoInputDevice *CreateDevice(
00995       const PString & driverName,         
00996       PPluginManager * pluginMgr = NULL   
00997     );
00998 
00999     /* Create the matching video input device that corresponds to the device name.
01000        So, for "fake" return a device that will generate fake video.
01001        For "Phillips 680 webcam" (eg) will return appropriate grabber.
01002        Note that Phillips will return the appropriate grabber also.
01003 
01004        This is typically used with the return values from GetDriversDeviceNames().
01005      */
01006     static PVideoInputDevice *CreateDeviceByName(
01007       const PString & deviceName,         
01008       const PString & driverName = PString::Empty(),  
01009       PPluginManager * pluginMgr = NULL   
01010     );
01011 
01017     static PVideoInputDevice *CreateOpenedDevice(
01018       const PString & driverName,         
01019       const PString & deviceName,         
01020       PBoolean startImmediate = true,         
01021       PPluginManager * pluginMgr = NULL   
01022     );
01023 
01026     static PVideoInputDevice *CreateOpenedDevice(
01027       const OpenArgs & args,              
01028       PBoolean startImmediate = true          
01029     );
01030 
01031   typedef struct {
01032      std::list<PVideoFrameInfo> framesizes;
01033      std::list<PVideoControlInfo> controls;
01034      std::list<PVideoInteractionInfo> interactions;
01035   } Capabilities;
01036 
01039     virtual bool GetDeviceCapabilities(
01040       Capabilities * capabilities          
01041     ) const { return GetDeviceCapabilities(GetDeviceName(), capabilities); }
01042 
01045     static PBoolean GetDeviceCapabilities(
01046       const PString & deviceName,           
01047       Capabilities * capabilities,          
01048       PPluginManager * pluginMgr = NULL     
01049     );
01050 
01053     static PBoolean GetDeviceCapabilities(
01054       const PString & deviceName,           
01055       const PString & driverName,           
01056       Capabilities * caps,                  
01057       PPluginManager * pluginMgr = NULL     
01058     );
01059 
01063     virtual PVideoInputControl * GetVideoInputControls();
01064 
01067     virtual PBoolean Open(
01068       const PString & deviceName,   
01069       PBoolean startImmediate = true    
01070     ) = 0;
01071 
01072     virtual PBoolean Close(
01073     ) { return true; }
01074 
01077     virtual PBoolean CanCaptureVideo() const;
01078  
01081     virtual PBoolean IsCapturing() = 0;
01082 
01090     virtual PBoolean SetNearestFrameSize(
01091       unsigned width,   
01092       unsigned height   
01093     );
01094 
01097     virtual PBoolean GetFrame(
01098       PBYTEArray & frame
01099     );
01100 
01103     virtual PBoolean GetFrameData(
01104       BYTE * buffer,                 
01105       PINDEX * bytesReturned,        
01106       unsigned int & flags           
01107     );
01108     virtual PBoolean GetFrameData(
01109       BYTE * buffer,                 
01110       PINDEX * bytesReturned = NULL  
01111     ) = 0;
01112 
01115     virtual PBoolean GetFrameDataNoDelay(
01116       BYTE * buffer,                 
01117       PINDEX * bytesReturned,       
01118       unsigned int & flags           
01119     );
01120     virtual PBoolean GetFrameDataNoDelay(
01121       BYTE * buffer,                 
01122       PINDEX * bytesReturned = NULL  
01123     ) = 0;
01124 
01127     virtual bool FlowControl(const void * flowData);
01128 
01141     virtual bool SetCaptureMode(unsigned mode);
01142 
01146     virtual int GetCaptureMode() const;
01147 };
01148 
01149 
01151 //
01152 // declare macros and structures needed for video input plugins
01153 //
01154 
01155 template <class className> class PVideoInputPluginServiceDescriptor : public PDevicePluginServiceDescriptor
01156 {
01157   public:
01158     virtual PObject *    CreateInstance(int /*userData*/) const { return new className; }
01159     virtual PStringArray GetDeviceNames(int /*userData*/) const { return className::GetInputDeviceNames(); }
01160     virtual bool         GetDeviceCapabilities(const PString & deviceName, void * caps) const
01161       { return className::GetDeviceCapabilities(deviceName, (PVideoInputDevice::Capabilities *)caps); }
01162 };
01163 
01164 #define PCREATE_VIDINPUT_PLUGIN(name) \
01165   static PVideoInputPluginServiceDescriptor<PVideoInputDevice_##name> PVideoInputDevice_##name##_descriptor; \
01166   PCREATE_PLUGIN(name, PVideoInputDevice, &PVideoInputDevice_##name##_descriptor)
01167 
01168 PPLUGIN_STATIC_LOAD(FakeVideo, PVideoInputDevice);
01169 
01170 #ifdef P_APPSHARE
01171   PPLUGIN_STATIC_LOAD(Application, PVideoInputDevice);
01172 #endif
01173 
01174 #if P_FFVDEV
01175   PPLUGIN_STATIC_LOAD(FFMPEG, PVideoInputDevice);
01176 #endif
01177 
01178 #if P_VIDFILE
01179   PPLUGIN_STATIC_LOAD(YUVFile, PVideoInputDevice);
01180 #endif
01181 
01182 #ifdef P_DIRECTSHOW
01183   PPLUGIN_STATIC_LOAD(DirectShow, PVideoInputDevice);
01184 #endif
01185 
01186 
01188 //
01189 // declare macros and structures needed for video output plugins
01190 //
01191 
01192 template <class className> class PVideoOutputPluginServiceDescriptor : public PDevicePluginServiceDescriptor
01193 {
01194   public:
01195     virtual PObject *    CreateInstance(int /*userData*/) const { return new className; }
01196     virtual PStringArray GetDeviceNames(int /*userData*/) const { return className::GetOutputDeviceNames(); }
01197 };
01198 
01199 #define PCREATE_VIDOUTPUT_PLUGIN(name) \
01200   static PVideoOutputPluginServiceDescriptor<PVideoOutputDevice_##name> PVideoOutputDevice_##name##_descriptor; \
01201   PCREATE_PLUGIN(name, PVideoOutputDevice, &PVideoOutputDevice_##name##_descriptor)
01202 
01203 #if _WIN32
01204   PPLUGIN_STATIC_LOAD(Window, PVideoOutputDevice);
01205 #endif
01206 
01207 #if P_SDL
01208   PPLUGIN_STATIC_LOAD(SDL, PVideoOutputDevice);
01209 #endif
01210 
01211 
01213 //
01214 // declare classes needed for access to simple video font
01215 //
01216 
01217 class PVideoFont : public PObject
01218 {
01219   PCLASSINFO(PVideoFont, PObject);
01220   public:
01221     enum {
01222       MAX_L_HEIGHT = 11
01223     };
01224     struct LetterData {
01225       char ascii;
01226       const char *line[MAX_L_HEIGHT];
01227     };
01228 
01229     static const LetterData * GetLetterData(char ascii);
01230 };
01231 
01232 #endif // P_VIDEO
01233 
01234 #endif   // PTLIB_PVIDEOIO_H
01235 
01236 // End Of File ///////////////////////////////////////////////////////////////
01237 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines