PTLib  Version 2.12.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
videoio.h
Go to the documentation of this file.
1 /*
2  * videoio.h
3  *
4  * Classes to support streaming video input (grabbing) and output.
5  *
6  * Portable Windows Library
7  *
8  * Copyright (c) 1993-2000 Equivalence Pty. Ltd.
9  *
10  * The contents of this file are subject to the Mozilla Public License
11  * Version 1.0 (the "License"); you may not use this file except in
12  * compliance with the License. You may obtain a copy of the License at
13  * http://www.mozilla.org/MPL/
14  *
15  * Software distributed under the License is distributed on an "AS IS"
16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
17  * the License for the specific language governing rights and limitations
18  * under the License.
19  *
20  * The Original Code is Portable Windows Library.
21  *
22  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
23  *
24  * Contributor(s): Mark Cooke (mpc@star.sr.bham.ac.uk)
25  *
26  * $Revision: 30763 $
27  * $Author: rjongbloed $
28  * $Date: 2013-10-21 12:13:48 +1100 (Mon, 21 Oct 2013) $
29  */
30 
31 
32 #ifndef PTLIB_PVIDEOIO_H
33 #define PTLIB_PVIDEOIO_H
34 
35 #ifdef P_USE_PRAGMA
36 #pragma interface
37 #endif
38 #include <ptbuildopts.h>
39 
40 #if P_VIDEO
41 
42 #include <ptlib/plugin.h>
43 #include <ptlib/pluginmgr.h>
44 #include <list>
45 
46 class PColourConverter;
47 
48 
49 class PVideoFrameInfo : public PObject
50 {
51  PCLASSINFO(PVideoFrameInfo, PObject);
52  public:
53  P_DECLARE_ENUM_EX(ResizeMode,eMaxResizeMode,
54  eScale,0,
55  eCropCentre,
56  eCropTopLeft
57  );
58  friend ostream & operator<<(ostream & strm, ResizeMode mode);
59 
60  enum StandardSizes {
61  SQCIFWidth = 128, SQCIFHeight = 96,
62  QCIFWidth = 176, QCIFHeight = 144,
63  CIFWidth = 352, CIFHeight = 288,
64  CIF4Width = 704, CIF4Height = 576,
65  CIF16Width = 1408, CIF16Height = 1152,
66  HD480Width = 704, HD480Height = 480,
67  i480Width = 704, i480Height = 480,
68  HD720Width = 1280, HD720Height = 720,
69  p720Width = 1280, p720Height = 720,
70  HD1080Width= 1920, HD1080Height= 1080,
71  i1080Width = 1920, i1080Height = 1080,
72  HDTVWidth = 1920, HDTVHeight = 1080,
73  MaxWidth = 1920, MaxHeight = 1200
74  };
75 
77  PVideoFrameInfo();
78  PVideoFrameInfo(
79  unsigned frameWidth,
80  unsigned frameHeight,
81  const PString & colourFormat = "YUV420P",
82  unsigned frameRate = 15,
83  ResizeMode resizeMode = eScale
84  );
85 
95  virtual Comparison Compare(
96  const PObject & obj // Object to compare against.
97  ) const;
98 
105  virtual void PrintOn(
106  ostream & strm // Stream to print the object into.
107  ) const;
108 
114  virtual PBoolean SetFrameSize(
115  unsigned width,
116  unsigned height
117  );
118 
124  virtual PBoolean GetFrameSize(
125  unsigned & width,
126  unsigned & height
127  ) const;
128 
133  virtual unsigned GetFrameWidth() const;
134 
139  virtual unsigned GetFrameHeight() const;
140 
146  virtual PBoolean SetFrameSar(
147  unsigned width,
148  unsigned height
149  );
150 
156  virtual PBoolean GetSarSize(
157  unsigned & width,
158  unsigned & height
159  ) const;
160 
165  virtual unsigned GetSarWidth() const;
166 
171  virtual unsigned GetSarHeight() const;
172 
178  virtual PBoolean SetFrameRate(
179  unsigned rate
180  );
181 
186  virtual unsigned GetFrameRate() const;
187 
193  virtual PBoolean SetColourFormat(
194  const PString & colourFormat // New colour format for device.
195  );
196 
201  virtual const PString & GetColourFormat() const;
202 
205  void SetResizeMode(
206  ResizeMode mode
207  ) { if (resizeMode < eMaxResizeMode) resizeMode = mode; }
208 
211  ResizeMode GetResizeMode() const { return resizeMode; }
212 
215  PINDEX CalculateFrameBytes() const { return CalculateFrameBytes(frameWidth, frameHeight, colourFormat); }
216  static PINDEX CalculateFrameBytes(
217  unsigned width,
218  unsigned height,
219  const PString & colourFormat
220  );
221 
235  bool Parse(
236  const PString & str
237  );
238 
243  static bool ParseSize(
244  const PString & str,
245  unsigned & width,
246  unsigned & height
247  );
248 
251  static PString AsString(
252  unsigned width,
253  unsigned height
254  );
255 
260  static PStringArray GetSizeNames();
261 
262  protected:
263  unsigned frameWidth;
264  unsigned frameHeight;
265  unsigned sarWidth;
266  unsigned sarHeight;
267  unsigned frameRate;
268  PString colourFormat;
269  ResizeMode resizeMode;
270 };
271 
272 
273 class PVideoControlInfo : public PObject
274 {
275  PCLASSINFO(PVideoControlInfo, PObject);
276 
277  public:
278  P_DECLARE_STREAMABLE_ENUM(Types,
279  Pan,
280  Tilt,
281  Zoom
282  );
283 
284  Types m_type;
285  long m_min;
286  long m_max;
287  long m_step;
288  long m_default;
289  long m_flags;
290  long m_current;
291 
292  PVideoControlInfo()
293  : m_type(EndTypes)
294  , m_min(0)
295  , m_max(0)
296  , m_step(0)
297  , m_default(0)
298  , m_flags(0)
299  , m_current(0)
300  { }
301 
302  bool IsValid() const { return m_max > 0 && m_min < m_max; }
303 };
304 
305 
309 class PVideoInputControl : public PObject
310 {
311  PCLASSINFO(PVideoInputControl, PObject);
312 
313 public:
314  ~PVideoInputControl();
315 
316  virtual PBoolean Pan (long value, bool absolute = false);
317  virtual PBoolean Tilt(long value, bool absolute = false);
318  virtual PBoolean Zoom(long value, bool absolute = false);
319 
320  virtual long GetPan() const { return m_control[PVideoControlInfo::Pan ].m_current; }
321  virtual long GetTilt() const { return m_control[PVideoControlInfo::Tilt].m_current; }
322  virtual long GetZoom() const { return m_control[PVideoControlInfo::Zoom].m_current; }
323 
324  virtual void Reset();
325 
326  bool IsValid(PVideoControlInfo::Types type) const { return m_control[type].IsValid(); }
327  const PVideoControlInfo & GetControl(PVideoControlInfo::Types type) const { return m_control[type]; }
328 
329 protected:
330  PVideoControlInfo m_control[PVideoControlInfo::NumTypes];
331  PMutex m_mutex;
332 
333 };
334 
337 class PVideoInteractionInfo : public PObject
338 {
339  PCLASSINFO(PVideoInteractionInfo, PObject);
340 
341  public:
342 
343  typedef enum {
344  InteractKey,
345  InteractMouse,
346  InteractNavigate,
347  InteractRTSP,
348  InteractOther
349  } InputInteractType;
350 
351  static PString AsString(const InputInteractType & type);
352 
353  InputInteractType type;
354 };
355 
356 
385 class PVideoDevice : public PVideoFrameInfo
386 {
387  PCLASSINFO(PVideoDevice, PVideoFrameInfo);
388 
389  protected:
392  PVideoDevice();
393 
394 
395  public:
398  virtual ~PVideoDevice();
399 
400  enum VideoFormat {
401  PAL,
402  NTSC,
403  SECAM,
404  Auto,
405  NumVideoFormats
406  };
407 
410  const PString & GetDeviceName() const
411  { return deviceName; }
412 
415  virtual PStringArray GetDeviceNames() const = 0;
416 
417  struct Attributes {
418  Attributes();
419 
420  int m_brightness;
421  int m_contrast;
422  int m_saturation;
423  int m_hue;
424  int m_gamma;
425  int m_exposure;
426  };
427 
428  struct OpenArgs {
429  OpenArgs();
430 
431  PPluginManager * pluginMgr;
432  PString driverName;
433  PString deviceName;
434  VideoFormat videoFormat;
435  int channelNumber;
436  PString colourFormat;
437  bool convertFormat;
438  unsigned rate;
439  unsigned width;
440  unsigned height;
441  bool convertSize;
442  ResizeMode resizeMode;
443  bool flip;
444  Attributes m_attributes;
445  };
446 
449  virtual PBoolean OpenFull(
450  const OpenArgs & args,
451  PBoolean startImmediate = true
452  );
453 
456  virtual PBoolean Open(
457  const PString & deviceName,
458  PBoolean startImmediate = true
459  ) = 0;
460 
463  virtual PBoolean IsOpen() = 0;
464 
467  virtual PBoolean Close() = 0;
468 
471  virtual PBoolean Start() = 0;
472 
475  virtual PBoolean Stop() = 0;
476 
477 
478 #if PTRACING
479  friend ostream & operator<<(ostream &, VideoFormat);
480 #endif
481 
487  virtual PBoolean SetVideoFormat(
488  VideoFormat videoFormat
489  );
490 
495  virtual VideoFormat GetVideoFormat() const;
496 
501  virtual int GetNumChannels();
502 
505  virtual PStringArray GetChannelNames();
506 
514  virtual PBoolean SetChannel(
515  int channelNumber
516  );
517 
522  virtual int GetChannel() const;
523 
529  virtual bool SetFrameInfoConverter(
530  const PVideoFrameInfo & info // New frame infofor device.
531  );
532 
539  virtual PBoolean SetColourFormatConverter(
540  const PString & colourFormat // New colour format for device.
541  );
542 
546  virtual PBoolean GetVFlipState();
547 
551  virtual PBoolean SetVFlipState(
552  PBoolean newVFlipState
553  );
554 
560  virtual PBoolean GetFrameSizeLimits(
561  unsigned & minWidth,
562  unsigned & minHeight,
563  unsigned & maxWidth,
564  unsigned & maxHeight
565  ) ;
566 
567 
573  virtual PBoolean SetFrameSizeConverter(
574  unsigned width,
575  unsigned height,
576  ResizeMode resizeMode = eMaxResizeMode
577  );
578 
584  virtual PBoolean SetFrameSizeConverter(
585  unsigned width,
586  unsigned height,
587  PBoolean /*bScaleNotCrop*/
588  ) { return SetFrameSizeConverter(width,height,eScale); }
589 
590 
598  virtual PBoolean SetNearestFrameSize(
599  unsigned width,
600  unsigned height
601  );
602 
611  virtual PBoolean SetFrameSize(
612  unsigned width,
613  unsigned height
614  );
615 
621  virtual PBoolean GetFrameSize(
622  unsigned & width,
623  unsigned & height
624  ) const;
625 
631  virtual const PString& GetColourFormat() const;
632 
641  virtual PINDEX GetMaxFrameBytes() = 0;
642 
643 
646  int GetLastError() const { return lastError; }
647 
648 
651  virtual PBoolean CanCaptureVideo() const = 0;
652 
655  virtual bool GetAttributes(
656  Attributes & attributes
657  );
658 
661  virtual bool SetAttributes(
662  const Attributes & attributes
663  );
664 
665 
668  virtual PBoolean SetVideoChannelFormat (
669  int channelNumber,
670  VideoFormat videoFormat
671  );
672 
673 
677  void SetPreferredColourFormat(const PString & colourFmt) { preferredColourFormat = colourFmt; }
678 
682  const PString & GetPreferredColourFormat() { return preferredColourFormat; }
683 
684  protected:
685  PINDEX GetMaxFrameBytesConverted(PINDEX rawFrameBytes) const;
686 
687  PCaselessString deviceName;
688  int lastError;
689  VideoFormat videoFormat;
690  int channelNumber;
691  // Preferred native colour format from video input device, empty == no preference
692  PString preferredColourFormat;
693  PBoolean nativeVerticalFlip;
694 
695  PColourConverter * converter;
696  PBYTEArray frameStore;
697 
698  private:
699  P_REMOVE_VIRTUAL(int, GetBrightness(), 0);
700  P_REMOVE_VIRTUAL(PBoolean, SetBrightness(unsigned), false);
701  P_REMOVE_VIRTUAL(int, GetWhiteness(), 0);
702  P_REMOVE_VIRTUAL(PBoolean, SetWhiteness(unsigned), false);
703  P_REMOVE_VIRTUAL(int, GetColour(), 0);
704  P_REMOVE_VIRTUAL(PBoolean, SetColour(unsigned), false);
705  P_REMOVE_VIRTUAL(int, GetContrast(), 0);
706  P_REMOVE_VIRTUAL(PBoolean, SetContrast(unsigned), false);
707  P_REMOVE_VIRTUAL(int, GetHue(), 0);
708  P_REMOVE_VIRTUAL(PBoolean, SetHue(unsigned), false);
709  P_REMOVE_VIRTUAL(PBoolean, GetParameters(int *, int *, int *, int *, int *), false);
710 };
711 
712 
715 class PVideoOutputDevice : public PVideoDevice
716 {
717  PCLASSINFO(PVideoOutputDevice, PVideoDevice);
718 
719  public:
722  PVideoOutputDevice();
723 
726  virtual ~PVideoOutputDevice() { Close(); };
727 
730  static PStringArray GetDriverNames(
731  PPluginManager * pluginMgr = NULL
732  );
733 
740  static PStringArray GetDriversDeviceNames(
741  const PString & driverName,
742  PPluginManager * pluginMgr = NULL
743  );
744 
747  static PVideoOutputDevice * CreateDevice(
748  const PString & driverName,
749  PPluginManager * pluginMgr = NULL
750  );
751 
752  /* Create the matching video output device that corresponds to the device name.
753 
754  This is typically used with the return values from GetDriversDeviceNames().
755  */
756  static PVideoOutputDevice *CreateDeviceByName(
757  const PString & deviceName,
758  const PString & driverName = PString::Empty(),
759  PPluginManager * pluginMgr = NULL
760  );
761 
767  static PVideoOutputDevice *CreateOpenedDevice(
768  const PString & driverName,
769  const PString & deviceName,
770  PBoolean startImmediate = true,
771  PPluginManager * pluginMgr = NULL
772  );
773 
776  static PVideoOutputDevice *CreateOpenedDevice(
777  const OpenArgs & args,
778  PBoolean startImmediate = true
779  );
780 
783  virtual PBoolean Close() { return true; }
784 
787  virtual PBoolean Start() { return true; }
788 
791  virtual PBoolean Stop() { return true; }
792 
795  virtual PBoolean CanCaptureVideo() const;
796 
799  virtual PBoolean SetFrameData(
800  unsigned x,
801  unsigned y,
802  unsigned width,
803  unsigned height,
804  const BYTE * data,
805  PBoolean endFrame = true
806  ) = 0;
807  virtual PBoolean SetFrameData(
808  unsigned x,
809  unsigned y,
810  unsigned width,
811  unsigned height,
812  const BYTE * data,
813  PBoolean endFrame,
814  bool & keyFrameNeeded
815  );
816  virtual PBoolean SetFrameData(
817  unsigned x,
818  unsigned y,
819  unsigned width,
820  unsigned height,
821  unsigned sarWidth,
822  unsigned sarHeight,
823  const BYTE * data,
824  PBoolean endFrame,
825  bool & keyFrameNeeded,
826  const void * mark
827  );
828 
835  virtual PBoolean DisableDecode();
836 
843  virtual PBoolean GetPosition(
844  int & x, // X position of device surface
845  int & y // Y position of device surface
846  ) const;
847 
854  virtual bool SetPosition(
855  int x, // X position of device surface
856  int y // Y position of device surface
857  );
858 };
859 
860 
863 class PVideoOutputDeviceRGB : public PVideoOutputDevice
864 {
865  PCLASSINFO(PVideoOutputDeviceRGB, PVideoOutputDevice);
866 
867  public:
870  PVideoOutputDeviceRGB();
871 
882  virtual PBoolean SetColourFormat(
883  const PString & colourFormat // New colour format for device.
884  );
885 
894  virtual PBoolean SetFrameSize(
895  unsigned width,
896  unsigned height
897  );
898 
904  virtual PINDEX GetMaxFrameBytes();
905 
908  virtual PBoolean SetFrameData(
909  unsigned x,
910  unsigned y,
911  unsigned width,
912  unsigned height,
913  const BYTE * data,
914  PBoolean endFrame = true
915  );
916 
919  virtual PBoolean FrameComplete() = 0;
920 
921  protected:
922  PMutex mutex;
923  PINDEX bytesPerPixel;
924  PINDEX scanLineWidth;
925  bool swappedRedAndBlue;
926 };
927 
928 
929 #ifdef SHOULD_BE_MOVED_TO_PLUGIN
930 
933 class PVideoOutputDevicePPM : public PVideoOutputDeviceRGB
934 {
935  PCLASSINFO(PVideoOutputDevicePPM, PVideoOutputDeviceRGB);
936 
937  public:
940  PVideoOutputDevicePPM();
941 
944  virtual PBoolean Open(
945  const PString & deviceName,
946  PBoolean startImmediate = true
947  );
948 
951  virtual PBoolean IsOpen();
952 
955  virtual PBoolean Close();
956 
959  virtual PStringArray GetDeviceNames() const;
960 
963  virtual PBoolean EndFrame();
964 
965  protected:
966  unsigned frameNumber;
967 };
968 
969 #endif // SHOULD_BE_MOVED_TO_PLUGIN
970 
971 
974 class PVideoInputDevice : public PVideoDevice
975 {
976  PCLASSINFO(PVideoInputDevice, PVideoDevice);
977 
978  public:
981  //PVideoInputDevice();
982 
985  ~PVideoInputDevice() { Close(); }
986 
989  static PStringArray GetDriverNames(
990  PPluginManager * pluginMgr = NULL
991  );
992 
999  static PStringArray GetDriversDeviceNames(
1000  const PString & driverName,
1001  PPluginManager * pluginMgr = NULL
1002  );
1003 
1006  static PVideoInputDevice *CreateDevice(
1007  const PString & driverName,
1008  PPluginManager * pluginMgr = NULL
1009  );
1010 
1011  /* Create the matching video input device that corresponds to the device name.
1012  So, for "fake" return a device that will generate fake video.
1013  For "Phillips 680 webcam" (eg) will return appropriate grabber.
1014  Note that Phillips will return the appropriate grabber also.
1015 
1016  This is typically used with the return values from GetDriversDeviceNames().
1017  */
1018  static PVideoInputDevice *CreateDeviceByName(
1019  const PString & deviceName,
1020  const PString & driverName = PString::Empty(),
1021  PPluginManager * pluginMgr = NULL
1022  );
1023 
1029  static PVideoInputDevice *CreateOpenedDevice(
1030  const PString & driverName,
1031  const PString & deviceName,
1032  PBoolean startImmediate = true,
1033  PPluginManager * pluginMgr = NULL
1034  );
1035 
1038  static PVideoInputDevice *CreateOpenedDevice(
1039  const OpenArgs & args,
1040  PBoolean startImmediate = true
1041  );
1042 
1043  typedef struct {
1044  std::list<PVideoFrameInfo> framesizes;
1045  std::list<PVideoControlInfo> controls;
1046  std::list<PVideoInteractionInfo> interactions;
1047  } Capabilities;
1048 
1051  virtual bool GetDeviceCapabilities(
1052  Capabilities * capabilities
1053  ) const { return GetDeviceCapabilities(GetDeviceName(), capabilities); }
1054 
1057  static PBoolean GetDeviceCapabilities(
1058  const PString & deviceName,
1059  Capabilities * capabilities,
1060  PPluginManager * pluginMgr = NULL
1061  );
1062 
1065  static PBoolean GetDeviceCapabilities(
1066  const PString & deviceName,
1067  const PString & driverName,
1068  Capabilities * caps,
1069  PPluginManager * pluginMgr = NULL
1070  );
1071 
1075  virtual PVideoInputControl * GetVideoInputControls();
1076 
1079  virtual PBoolean Open(
1080  const PString & deviceName,
1081  PBoolean startImmediate = true
1082  ) = 0;
1083 
1084  virtual PBoolean Close(
1085  ) { return true; }
1086 
1089  virtual PBoolean CanCaptureVideo() const;
1090 
1093  virtual PBoolean IsCapturing() = 0;
1094 
1102  virtual PBoolean SetNearestFrameSize(
1103  unsigned width,
1104  unsigned height
1105  );
1106 
1109  virtual PBoolean GetFrame(
1110  PBYTEArray & frame
1111  );
1112 
1115  virtual PBoolean GetFrameData(
1116  BYTE * buffer,
1117  PINDEX * bytesReturned,
1118  bool & keyFrame
1120  );
1121  virtual PBoolean GetFrameData(
1122  BYTE * buffer,
1123  PINDEX * bytesReturned = NULL
1124  ) = 0;
1125 
1128  virtual PBoolean GetFrameDataNoDelay(
1129  BYTE * buffer,
1130  PINDEX * bytesReturned,
1131  bool & keyFrame
1133  );
1134  virtual PBoolean GetFrameDataNoDelay(
1135  BYTE * buffer,
1136  PINDEX * bytesReturned = NULL
1137  ) = 0;
1138 
1141  virtual bool FlowControl(const void * flowData);
1142 
1155  virtual bool SetCaptureMode(unsigned mode);
1156 
1160  virtual int GetCaptureMode() const;
1161 
1162  P_REMOVE_VIRTUAL(PBoolean, GetFrameData(BYTE *, PINDEX *, unsigned &), false);
1163  P_REMOVE_VIRTUAL(PBoolean, GetFrameDataNoDelay(BYTE *, PINDEX *, unsigned &), false);
1164 };
1165 
1166 
1168 //
1169 // declare macros and structures needed for video input plugins
1170 //
1171 
1172 template <class className> class PVideoInputPluginServiceDescriptor : public PDevicePluginServiceDescriptor
1173 {
1174  public:
1175  virtual PObject * CreateInstance(int /*userData*/) const { return new className; }
1176  virtual PStringArray GetDeviceNames(int /*userData*/) const { return className::GetInputDeviceNames(); }
1177  virtual bool GetDeviceCapabilities(const PString & deviceName, void * caps) const
1178  { return className::GetDeviceCapabilities(deviceName, (PVideoInputDevice::Capabilities *)caps); }
1179 };
1180 
1181 #define PCREATE_VIDINPUT_PLUGIN(name) \
1182  static PVideoInputPluginServiceDescriptor<PVideoInputDevice_##name> PVideoInputDevice_##name##_descriptor; \
1183  PCREATE_PLUGIN(name, PVideoInputDevice, &PVideoInputDevice_##name##_descriptor)
1184 
1185 
1186 #define P_FAKE_VIDEO_DRIVER "FakeVideo"
1187 #define P_FAKE_VIDEO_PREFIX "Fake/"
1188 #define P_FAKE_VIDEO_MOVING_BLOCKS P_FAKE_VIDEO_PREFIX"MovingBlocks"
1189 #define P_FAKE_VIDEO_MOVING_LINE P_FAKE_VIDEO_PREFIX"MovingLine"
1190 #define P_FAKE_VIDEO_BOUNCING_BOXES P_FAKE_VIDEO_PREFIX"BouncingBoxes"
1191 #define P_FAKE_VIDEO_SOLID_COLOUR P_FAKE_VIDEO_PREFIX"SolidColour"
1192 #define P_FAKE_VIDEO_TEXT P_FAKE_VIDEO_PREFIX"Text"
1193 #define P_FAKE_VIDEO_NTSC P_FAKE_VIDEO_PREFIX"NTSCTest"
1194 
1195 PPLUGIN_STATIC_LOAD(FakeVideo, PVideoInputDevice);
1196 
1197 #ifdef P_APPSHARE
1198  #define P_APPLICATION_VIDEO_DRIVER "Application"
1199  PPLUGIN_STATIC_LOAD(Application, PVideoInputDevice);
1200 #endif
1201 
1202 #if P_FFVDEV
1203  PPLUGIN_STATIC_LOAD(FFMPEG, PVideoInputDevice);
1204 #endif
1205 
1206 #if P_VIDFILE
1207  #define P_VIDEO_FILE_DRIVER "YUVFile"
1208  PPLUGIN_STATIC_LOAD(YUVFile, PVideoInputDevice);
1209 #endif
1210 
1211 #ifdef WIN32
1212  #define P_VIDEO_FOR_WINDOWS_DRIVER "VideoForWindows"
1213  PPLUGIN_STATIC_LOAD(VideoForWindows, PVideoInputDevice);
1214 #endif
1215 
1216 #ifdef P_DIRECTSHOW
1217  #define P_DIRECT_SHOW_DRIVER "DirectShow"
1218  PPLUGIN_STATIC_LOAD(DirectShow, PVideoInputDevice);
1219 #endif
1220 
1221 
1223 //
1224 // declare macros and structures needed for video output plugins
1225 //
1226 
1227 template <class className> class PVideoOutputPluginServiceDescriptor : public PDevicePluginServiceDescriptor
1228 {
1229  public:
1230  virtual PObject * CreateInstance(int /*userData*/) const { return new className; }
1231  virtual PStringArray GetDeviceNames(int /*userData*/) const { return className::GetOutputDeviceNames(); }
1232 };
1233 
1234 #define PCREATE_VIDOUTPUT_PLUGIN(name) \
1235  static PVideoOutputPluginServiceDescriptor<PVideoOutputDevice_##name> PVideoOutputDevice_##name##_descriptor; \
1236  PCREATE_PLUGIN(name, PVideoOutputDevice, &PVideoOutputDevice_##name##_descriptor)
1237 
1238 #define P_NULL_VIDEO_DRIVER "NULLOutput"
1239 #define P_NULL_VIDEO_DEVICE "Null Video Out"
1240 PPLUGIN_STATIC_LOAD(NULLOutput, PVideoOutputDevice);
1241 
1242 
1243 #if P_VFW_CAPTURE
1244 #if _WIN32
1245  #define P_MSWIN_VIDEO_DRIVER "Window"
1246  #define P_MSWIN_VIDEO_PREFIX "MSWIN"
1247  #define P_MSWIN_VIDEO_DEVICE(x,y,width,height) P_MSWIN_VIDEO_PREFIX " X=" x " Y=" y " WIDTH=" width " HEIGHT=" height
1248  PPLUGIN_STATIC_LOAD(Window, PVideoOutputDevice);
1249 #endif
1250 #endif
1251 
1252 #if P_SDL
1253  #if P_MACOSX
1254  #include <SDL_main.h>
1255  #endif
1256  #define P_SDL_VIDEO_DRIVER "SDL"
1257  #define P_SDL_VIDEO_PREFIX "SDL"
1258  #define P_SDL_VIDEO_DEVICE(x,y,width,height) P_SDL_VIDEO_PREFIX " X=" x " Y=" y " WIDTH=" width " HEIGHT=" height
1259  PPLUGIN_STATIC_LOAD(SDL, PVideoOutputDevice);
1260 #endif
1261 
1262 
1264 //
1265 // declare classes needed for access to simple video font
1266 //
1267 
1268 class PVideoFont : public PObject
1269 {
1270  PCLASSINFO(PVideoFont, PObject);
1271  public:
1272  enum {
1273  MAX_L_HEIGHT = 11
1274  };
1275  struct LetterData {
1276  char ascii;
1277  const char *line[MAX_L_HEIGHT];
1278  };
1279 
1280  static const LetterData * GetLetterData(char ascii);
1281 };
1282 
1283 #endif // P_VIDEO
1284 
1285 #endif // PTLIB_PVIDEOIO_H
1286 
1287 // End Of File ///////////////////////////////////////////////////////////////
1288