src/ptlib/common/videoio.cxx

   1 /*
   2  * videoio.cxx
   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  * $Log$
  27  * Revision 1.67  2007/04/05 01:53:00  rjongbloed
  28  * Changed PVideoOutputDevice::CreateDeviceByName() to include driverName parameter so symmetric with PVideoInputDevice.
  29  *
  30  * Revision 1.66  2007/04/03 12:09:38  rjongbloed
  31  * Fixed various "file video device" issues:
  32  *   Remove filename from PVideoDevice::OpenArgs (use deviceName)
  33  *   Added driverName to PVideoDevice::OpenArgs (so can select YUVFile)
  34  *   Added new statics to create correct video input/output device object
  35  *     given a PVideoDevice::OpenArgs structure.
  36  *   Fixed begin able to write to YUVFile when YUV420P colour format
  37  *     is not actually selected.
  38  *   Fixed truncating output video file if overwriting.
  39  *
  40  * Revision 1.65  2006/12/07 21:33:24  dominance
  41  * make sure we support also webcams that do *only* do 640x480 properly.
  42  * Thanks goes to Luc Saillard for this patch.
  43  *
  44  * Revision 1.64  2006/10/31 04:10:40  csoutheren
  45  * Make sure PVidFileDev class is loaded, and make it work with OPAL
  46  *
  47  * Revision 1.63  2006/10/25 11:04:38  shorne
  48  * fix for devices having same name for different drivers.
  49  *
  50  * Revision 1.62  2006/06/21 03:28:44  csoutheren
  51  * Various cleanups thanks for Frederic Heem
  52  *
  53  * Revision 1.61  2006/04/19 04:10:27  csoutheren
  54  * Fix problem when using converter when frame size not supported
  55  *
  56  * Revision 1.60  2006/03/07 20:53:51  dsandras
  57  * Added support for JPEG based webcams, thanks to Luc Saillard <luc saillard org>.
  58  *
  59  * Revision 1.59  2006/01/29 22:46:39  csoutheren
  60  * Added support for cameras that return MJPEG streams
  61  * Thanks to Luc Saillard and Damien Sandras
  62  *
  63  * Revision 1.58  2006/01/09 18:19:13  dsandras
  64  * Add YUY2 (or YUV420) format. Resizing to YUV420P is done, but it's not very
  65  * efficient.
  66  * Fix the gray border when doing padding for YUV420P (change it to black).
  67  * Logitech webcam fusion export only big format in yuy2.
  68  * Patches provided by Luc Saillard <luc _AT____ saillard.org>. Many thanks!
  69  *
  70  * Revision 1.57  2005/11/30 12:47:42  csoutheren
  71  * Removed tabs, reformatted some code, and changed tags for Doxygen
  72  *
  73  * Revision 1.56  2005/09/06 12:41:22  rjongbloed
  74  * Fixed correct creation (or non creation) of converter when using SetFrameSizeConverter()
  75  *
  76  * Revision 1.55  2005/08/23 12:42:23  rjongbloed
  77  * Fixed problems with negative hight native flipping not working with all sizes.
  78  *
  79  * Revision 1.54  2005/08/09 09:08:12  rjongbloed
  80  * Merged new video code from branch back to the trunk.
  81  *
  82  * Revision 1.53.6.2  2005/07/17 12:17:41  rjongbloed
  83  * Fixed deadlock changing size
  84  *
  85  * Revision 1.53.6.1  2005/07/17 09:27:08  rjongbloed
  86  * Major revisions of the PWLib video subsystem including:
  87  *   removal of F suffix on colour formats for vertical flipping, all done with existing bool
  88  *   working through use of RGB and BGR formats so now consistent
  89  *   cleaning up the plug in system to use virtuals instead of pointers to functions.
  90  *   rewrite of SDL to be a plug in compatible video output device.
  91  *   extensive enhancement of video test program
  92  *
  93  * Revision 1.53  2005/01/04 08:09:42  csoutheren
  94  * Fixed Linux configure problems
  95  *
  96  * Revision 1.52  2004/11/17 10:13:14  csoutheren
  97  * Fixed compilation with gcc 4.0.0
  98  *
  99  * Revision 1.51  2004/10/27 09:24:18  dsandras
 100  * Added patch from Nicola Orru' to convert from SBGGR8 to YUV420P. Thanks!
 101  *
 102  * Revision 1.50  2004/10/23 10:54:39  ykiryanov
 103  * Added ifdef _WIN32_WCE for PocketPC 2003 SDK port
 104  *
 105  * Revision 1.49  2004/08/16 06:40:59  csoutheren
 106  * Added adapters template to make device plugins available via the abstract factory interface
 107  *
 108  * Revision 1.48  2004/04/18 12:49:22  csoutheren
 109  * Patches to video code thanks to Guilhem Tardy (hope I get it right this time :)
 110  *
 111  * Revision 1.47  2004/04/03 23:53:10  csoutheren
 112  * Added various changes to improce compatibility with the Sun Forte compiler
 113  *   Thanks to Brian Cameron
 114  * Added detection of readdir_r version
 115  *
 116  * Revision 1.46  2004/01/18 14:25:58  dereksmithies
 117  * New methods to make the opening of video input devices easier.
 118  *
 119  * Revision 1.45  2004/01/17 17:41:50  csoutheren
 120  * Changed to use PString::MakeEmpty
 121  *
 122  * Revision 1.44  2003/12/14 10:01:02  rjongbloed
 123  * Resolved issue with name space conflict os static and virtual forms of GetDeviceNames() function.
 124  *
 125  * Revision 1.43  2003/11/23 22:17:35  dsandras
 126  * Added YUV420P to BGR24 and BGR32 conversion.
 127  *
 128  * Revision 1.42  2003/11/19 04:30:15  csoutheren
 129  * Changed to support video output plugins
 130  *
 131  * Revision 1.41  2003/11/18 10:40:51  csoutheren
 132  * Added pragma implementation to fix vtable link problems
 133  *
 134  * Revision 1.40  2003/11/18 06:46:38  csoutheren
 135  * Changed to support video input plugins
 136  *
 137  * Revision 1.39  2003/05/14 07:51:23  rjongbloed
 138  * Changed SetColourFormatConverter so if converter already in place no
 139  *   change is made.
 140  * Fixed some trace logs.
 141  *
 142  * Revision 1.38  2003/04/03 23:21:34  robertj
 143  * Added reversed RGB byte order versions (BGR24), thanks Damien Sandras
 144  *
 145  * Revision 1.37  2003/03/21 04:09:33  robertj
 146  * Changed PPM video output device so you can specify the full format of the
 147  *   output file uinng printf command for the frame number eg %u or %03i or
 148  *   something. If there is no %u in the Opan() argument, a %u is added after
 149  *   the filename.
 150  * Fixed video output RGB SetFrameData so abide by correct semantics. The input
 151  *   is aways to be what was set using SetColourFormat() or
 152  *   SetColourFormatConverter().
 153  *
 154  * Revision 1.36  2003/03/20 23:42:01  dereks
 155  * Make PPM video output device work correctly.
 156  *
 157  * Revision 1.35  2003/03/17 07:50:41  robertj
 158  * Added OpenFull() function to open with all video parameters in one go.
 159  * Made sure vflip variable is set in converter even if converter has not
 160  *   been set yet, should not depend on the order of functions!
 161  * Removed canCaptureVideo variable as this is really a virtual function to
 162  *   distinguish PVideoOutputDevice from PVideoInputDevice, it is not dynamic.
 163  * Made significant enhancements to PVideoOutputDevice class.
 164  * Added PVideoOutputDevice descendants for NULL and PPM files.
 165  *
 166  * Revision 1.34  2002/09/01 23:25:26  dereks
 167  * Documentation fix from Walter Whitlock. Many thanks.
 168  *
 169  * Revision 1.33  2002/09/01 22:38:21  dereks
 170  * Remove previous clarification, cause it breaks openphone code.
 171  *
 172  * Revision 1.32  2002/08/30 02:31:43  dereks
 173  * Make operation of the code more clear. Thanks Diego Tartara
 174  *
 175  * Revision 1.31  2002/04/12 08:24:53  robertj
 176  * Added text string output for tracing video format.
 177  *
 178  * Revision 1.30  2002/04/07 22:49:32  rogerh
 179  * Add some comments
 180  *
 181  * Revision 1.29  2002/04/05 06:41:54  rogerh
 182  * Apply video changes from Damien Sandras <dsandras@seconix.com>.
 183  * The Video Channel and Format are no longer set in Open(). Instead
 184  * call the new SetVideoChannelFormat() method. This makes video capture
 185  * and GnomeMeeting more stable with certain Linux video capture devices.
 186  *
 187  * Revision 1.28  2002/02/20 02:37:26  dereks
 188  * Initial release of Firewire camera support for linux.
 189  * Many thanks to Ryutaroh Matsumoto <ryutaroh@rmatsumoto.org>.
 190  *
 191  * Revision 1.27  2002/01/17 20:20:46  dereks
 192  * Adjust PVideoInputDevice::SetVFlipState to cope better when a converter class is
 193  * not attached.   Thanks  Walter Whitlock.
 194  *
 195  * Revision 1.26  2002/01/16 07:51:16  robertj
 196  * MSVC compatibilty changes
 197  *
 198  * Revision 1.25  2002/01/14 02:59:41  robertj
 199  * Added preferred colour format selection, thanks Walter Whitlock
 200  *
 201  * Revision 1.24  2002/01/08 01:32:20  robertj
 202  * Tidied up some PTRACE debug output.
 203  *
 204  * Revision 1.23  2002/01/04 04:11:45  dereks
 205  * Add video flip code from Walter Whitlock, which flips code at the grabber.
 206  *
 207  * Revision 1.22  2001/12/10 22:23:43  dereks
 208  * Enable resize of CIF source image into QCIF size.
 209  *
 210  * Revision 1.21  2001/12/06 22:15:09  dereks
 211  * Additional debugging lines
 212  *
 213  * Revision 1.20  2001/11/28 04:45:14  robertj
 214  * Added Win32 flipped RGB colour formats.
 215  *
 216  * Revision 1.19  2001/11/28 00:07:32  dereks
 217  * Locking added to PVideoChannel, allowing reader/writer to be changed mid call
 218  * Enabled adjustment of the video frame rate
 219  * New fictitous image, a blank grey area
 220  *
 221  * Revision 1.18  2001/09/25 04:25:38  dereks
 222  * Add fix from Stelian Pop to improve the field of view  for
 223  * the  small image with a  Sony Vaio Motion Eye. Many thanks.
 224  *
 225  * Revision 1.17  2001/08/03 04:21:51  dereks
 226  * Add colour/size conversion for YUV422->YUV411P
 227  * Add Get/Set Brightness,Contrast,Hue,Colour for PVideoDevice,  and
 228  * Linux PVideoInputDevice.
 229  * Add lots of PTRACE statement for debugging colour conversion.
 230  * Add support for Sony Vaio laptop under linux. Requires 2.4.7 kernel.
 231  *
 232  * Revision 1.16  2001/06/27 17:23:33  rogerh
 233  * Back out my previous change
 234  *
 235  * Revision 1.15  2001/06/26 15:48:31  rogerh
 236  * Do not call GetInputDeviceName if there is no video grabber code
 237  *
 238  * Revision 1.14  2001/05/22 23:38:45  robertj
 239  * Fixed bug in PVideoOutputDevice, removed redundent SetFrameSize.
 240  *
 241  * Revision 1.13  2001/03/20 02:21:57  robertj
 242  * More enhancements from Mark Cooke
 243  *
 244  * Revision 1.12  2001/03/08 08:31:34  robertj
 245  * Numerous enhancements to the video grabbing code including resizing
 246  *   infrastructure to converters. Thanks a LOT, Mark Cooke.
 247  *
 248  * Revision 1.11  2001/03/08 02:18:45  robertj
 249  * Added improved defaulting of video formats so Open() does not fail.
 250  * Removed the requirement that the device be open before you can set
 251  *   formats such as colour, video, channel number etc.
 252  *
 253  * Revision 1.10  2001/03/07 01:41:03  dereks
 254  * Fix memory leak, on destroying PVideoDevice
 255  * Ensure converter class is resized correctly.
 256  *
 257  * Revision 1.9  2001/03/06 23:34:20  robertj
 258  * Added static function to get input device names.
 259  * Moved some inline virtuals to non-inline.
 260  *
 261  * Revision 1.8  2001/03/05 01:12:41  robertj
 262  * Added more source formats for conversion, use list. Thanks Mark Cooke.
 263  *
 264  * Revision 1.7  2001/03/03 05:06:31  robertj
 265  * Major upgrade of video conversion and grabbing classes.
 266  *
 267  * Revision 1.6  2000/12/19 22:20:26  dereks
 268  * Add video channel classes to connect to the PwLib PVideoInputDevice class.
 269  * Add PFakeVideoInput class to generate test images for video.
 270  *
 271  * Revision 1.5  2000/11/09 00:20:58  robertj
 272  * Added qcif size constants
 273  *
 274  * Revision 1.4  2000/07/26 03:50:50  robertj
 275  * Added last error variable to video device.
 276  *
 277  * Revision 1.3  2000/07/26 02:13:48  robertj
 278  * Added some more "common" bounds checking to video device.
 279  *
 280  * Revision 1.2  2000/07/25 13:38:26  robertj
 281  * Added frame rate parameter to video frame grabber.
 282  *
 283  * Revision 1.1  2000/07/15 09:47:35  robertj
 284  * Added video I/O device classes.
 285  *
 286  */
 287
 288 #ifndef _WIN32_WCE
 289 #pragma implementation "videoio.h"
 290 #endif // !_WIN32_WCE
 291
 292 #include <ptlib.h>
 293 #include <ptlib/pluginmgr.h>
 294 #include <ptlib/videoio.h>
 295 #include <ptlib/vconvert.h>
 296
 297 namespace PWLibStupidWindowsHacks {
 298   int loadVideoStuff;
 299 };
 300
 301 namespace PWLib {
 302   PFactory<PDevicePluginAdapterBase>::Worker< PDevicePluginAdapter<PVideoInputDevice> > vidinChannelFactoryAdapter("PVideoInputDevice", TRUE);
 303   PFactory<PDevicePluginAdapterBase>::Worker< PDevicePluginAdapter<PVideoOutputDevice> > vidoutChannelFactoryAdapter("PVideoOutputDevice", TRUE);
 304 };
 305
 306 template <> PVideoInputDevice * PDevicePluginFactory<PVideoInputDevice>::Worker::Create(const PString & type) const
 307 {
 308   return PVideoInputDevice::CreateDevice(type);
 309 }
 310
 311 template <> PVideoOutputDevice * PDevicePluginFactory<PVideoOutputDevice>::Worker::Create(const PString & type) const
 312 {
 313   return PVideoOutputDevice::CreateDevice(type);
 314 }
 315
 316 ///////////////////////////////////////////////////////////////////////////////
 317
 318 #if PTRACING
 319 ostream & operator<<(ostream & strm, PVideoDevice::VideoFormat fmt)
 320 {
 321   static const char * const VideoFormatNames[PVideoDevice::NumVideoFormats] = {
 322     "PAL",
 323     "NTSC",
 324     "SECAM",
 325     "Auto"
 326   };
 327
 328   if (fmt < PVideoDevice::NumVideoFormats && VideoFormatNames[fmt] != NULL)
 329     strm << VideoFormatNames[fmt];
 330   else
 331     strm << "VideoFormat<" << (unsigned)fmt << '>';
 332
 333   return strm;
 334 }
 335 #endif
 336
 337 ///////////////////////////////////////////////////////////////////////////////
 338 // PVideoDevice
 339
 340 PVideoDevice::PVideoDevice()
 341 {
 342   lastError = 0;
 343
 344   videoFormat = Auto;
 345   channelNumber = -1;  // -1 will find the first working channel number.
 346   frameWidth = CIFWidth;
 347   frameHeight = CIFHeight;
 348   nativeVerticalFlip = FALSE;
 349
 350   converter = NULL;
 351
 352   SetFrameRate(0);
 353 }
 354
 355 PVideoDevice::~PVideoDevice()
 356 {
 357   if (converter)
 358     delete converter;
 359 }
 360
 361
 362 PVideoDevice::OpenArgs::OpenArgs()
 363   : pluginMgr(NULL),
 364     deviceName("#1"),
 365     videoFormat(Auto),
 366     channelNumber(0),
 367     colourFormat("YUV420P"),
 368     convertFormat(TRUE),
 369     rate(0),
 370     width(CIFWidth),
 371     height(CIFHeight),
 372     convertSize(TRUE),
 373     scaleSize(FALSE),
 374     flip(FALSE),
 375     brightness(-1),
 376     whiteness(-1),
 377     contrast(-1),
 378     colour(-1),
 379     hue(-1)
 380 {
 381 }
 382
 383
 384 BOOL PVideoDevice::OpenFull(const OpenArgs & args, BOOL startImmediate)
 385 {
 386   if (args.deviceName[0] == '#') {
 387     PStringArray devices = GetDeviceNames();
 388     PINDEX id = args.deviceName.Mid(1).AsUnsigned();
 389     if (id == 0 || id > devices.GetSize())
 390       return FALSE;
 391
 392     if (!Open(devices[id-1], FALSE))
 393       return FALSE;
 394   }
 395   else {
 396     if (!Open(args.deviceName, FALSE))
 397       return FALSE;
 398   }
 399
 400   if (!SetVideoFormat(args.videoFormat))
 401     return FALSE;
 402
 403   if (!SetChannel(args.channelNumber))
 404     return FALSE;
 405
 406   if (args.convertFormat) {
 407     if (!SetColourFormatConverter(args.colourFormat))
 408       return FALSE;
 409   }
 410   else {
 411     if (!SetColourFormat(args.colourFormat))
 412       return FALSE;
 413   }
 414
 415   if (args.rate > 0) {
 416     if (!SetFrameRate(args.rate))
 417       return FALSE;
 418   }
 419
 420   if (args.convertSize) {
 421     if (!SetFrameSizeConverter(args.width, args.height, args.scaleSize))
 422       return FALSE;
 423   }
 424   else {
 425     if (!SetFrameSize(args.width, args.height))
 426       return FALSE;
 427   }
 428
 429   if (!SetVFlipState(args.flip))
 430     return FALSE;
 431
 432   if (args.brightness >= 0) {
 433     if (!SetBrightness(args.brightness))
 434       return FALSE;
 435   }
 436
 437   if (args.whiteness >= 0) {
 438     if (!SetWhiteness(args.whiteness))
 439       return FALSE;
 440   }
 441
 442   if (args.contrast >= 0) {
 443     if (!SetContrast(args.contrast))
 444       return FALSE;
 445   }
 446
 447   if (args.colour >= 0) {
 448     if (!SetColour(args.colour))
 449       return FALSE;
 450   }
 451
 452   if (args.hue >= 0) {
 453     if (!SetColour(args.hue))
 454       return FALSE;
 455   }
 456
 457   if (startImmediate)
 458     return Start();
 459
 460   return TRUE;
 461 }
 462
 463
 464 BOOL PVideoDevice::Close()
 465 {
 466   return TRUE;
 467 }
 468
 469
 470 BOOL PVideoDevice::Start()
 471 {
 472   return TRUE;
 473 }
 474
 475
 476 BOOL PVideoDevice::Stop()
 477 {
 478   return TRUE;
 479 }
 480
 481
 482 BOOL PVideoDevice::SetVideoFormat(VideoFormat videoFmt)
 483 {
 484   videoFormat = videoFmt;
 485   return TRUE;
 486 }
 487
 488
 489 PVideoDevice::VideoFormat PVideoDevice::GetVideoFormat() const
 490 {
 491   return videoFormat;
 492 }
 493
 494
 495 int PVideoDevice::GetNumChannels()
 496 {
 497   return 1;
 498 }
 499
 500
 501 BOOL PVideoDevice::SetChannel(int channelNum)
 502 {
 503   if (channelNum < 0) { // Seek out the first available channel
 504     for (int c = 0; c < GetNumChannels(); c++) {
 505       if (SetChannel(c))
 506         return TRUE;
 507     }
 508     return FALSE;
 509   }
 510
 511   if (channelNum >= GetNumChannels())
 512     return FALSE;
 513
 514   channelNumber = channelNum;
 515   return TRUE;
 516 }
 517
 518
 519 int PVideoDevice::GetChannel() const
 520 {
 521   return channelNumber;
 522 }
 523
 524
 525 //Colour format bit per pixel table.
 526 // These are in rough order of colour gamut size
 527 static struct {
 528   const char * colourFormat;
 529   unsigned     bitsPerPixel;
 530 } colourFormatBPPTab[] = {
 531   { "RGB32",   32 },
 532   { "BGR32",   32 },
 533   { "RGB24",   24 },
 534   { "BGR24",   24 },
 535   { "MJPEG",   16 },
 536   { "JPEG",    16 },
 537   { "YUY2",    16 },
 538   { "YUV422",  16 },
 539   { "YUV422P", 16 },
 540   { "YUV411",  12 },
 541   { "YUV411P", 12 },
 542   { "RGB565",  16 },
 543   { "RGB555",  16 },
 544   { "YUV420",  12 },
 545   { "YUV420P", 12 },
 546   { "IYUV",    12 },
 547   { "I420",    12 },
 548   { "YUV410",  10 },
 549   { "YUV410P", 10 },
 550   { "Grey",     8 },
 551   { "GreyF",    8 },
 552   { "UYVY422", 16 },
 553   { "UYV444",  24 },
 554   { "SBGGR8",   8 }
 555 };
 556
 557
 558 BOOL PVideoDevice::SetColourFormatConverter(const PString & colourFmt)
 559 {
 560   if (converter != NULL) {
 561     if (CanCaptureVideo()) {
 562       if (converter->GetDstColourFormat() == colourFmt)
 563         return TRUE;
 564     }
 565     else {
 566       if (converter->GetSrcColourFormat() == colourFmt)
 567         return TRUE;
 568     }
 569     delete converter;
 570     converter = NULL;
 571   }
 572
 573   if (!preferredColourFormat.IsEmpty()) {
 574     PTRACE(4,"PVidDev\tSetColourFormatConverter, want " << colourFmt << " trying " << preferredColourFormat);
 575     if (SetColourFormat(preferredColourFormat)) {
 576       if (CanCaptureVideo()) {
 577         PTRACE(4,"PVidDev\tSetColourFormatConverter set camera to native "<< preferredColourFormat);
 578         if (preferredColourFormat != colourFmt)
 579           converter = PColourConverter::Create(preferredColourFormat, colourFmt, frameWidth, frameHeight);
 580       }
 581       else {
 582         PTRACE(4,"PVidDev\tSetColourFormatConverter set renderer to "<< preferredColourFormat);
 583         if (preferredColourFormat != colourFmt)
 584           converter = PColourConverter::Create(colourFmt, preferredColourFormat, frameWidth, frameHeight);
 585       }
 586
 587       if (nativeVerticalFlip && converter == NULL)
 588           converter = PColourConverter::Create(colourFmt, colourFmt, frameWidth, frameHeight);
 589
 590       if (converter != NULL) {
 591         converter->SetVFlipState(nativeVerticalFlip);
 592         return TRUE;
 593       }
 594     }
 595   }
 596
 597   if (SetColourFormat(colourFmt)) {
 598     if (nativeVerticalFlip) {
 599       converter = PColourConverter::Create(colourFmt, colourFmt, frameWidth, frameHeight);
 600       if (PAssertNULL(converter) == NULL)
 601         return FALSE;
 602       converter->SetVFlipState(nativeVerticalFlip);
 603     }
 604
 605     PTRACE(3, "PVidDev\tSetColourFormatConverter success for native " << colourFmt);
 606     return TRUE;
 607   }
 608
 609   /************************
 610     Eventually, need something more sophisticated than this, but for the
 611     moment pick the known colour formats that the device is very likely to
 612     support and then look for a conversion routine from that to the
 613     destination format.
 614
 615     What we really want is some sort of better heuristic that looks at
 616     computational requirements of each converter and picks a pair of formats
 617     that the hardware supports and uses the least CPU.
 618   */
 619
 620   PINDEX knownFormatIdx = 0;
 621   while (knownFormatIdx < PARRAYSIZE(colourFormatBPPTab)) {
 622     PString formatToTry = colourFormatBPPTab[knownFormatIdx].colourFormat;
 623     PTRACE(4,"PVidDev\tSetColourFormatConverter, want " << colourFmt << " trying " << formatToTry);
 624     if (SetColourFormat(formatToTry)) {
 625       if (CanCaptureVideo()) {
 626         PTRACE(4,"PVidDev\tSetColourFormatConverter set camera to "<< formatToTry);
 627         converter = PColourConverter::Create(formatToTry, colourFmt, frameWidth, frameHeight);
 628       }
 629       else {
 630         PTRACE(4,"PVidDev\tSetColourFormatConverter set renderer to "<< formatToTry);
 631         converter = PColourConverter::Create(colourFmt, formatToTry, frameWidth, frameHeight);
 632       }
 633       if (converter != NULL) {
 634         // set converter properties that depend on this color format
 635         PTRACE(3, "PVidDev\tSetColourFormatConverter succeeded for " << colourFmt << " and device using " << formatToTry);
 636         converter->SetVFlipState(nativeVerticalFlip);
 637         return TRUE;
 638       }
 639     }
 640     knownFormatIdx++;
 641   }
 642
 643   PTRACE(2, "PVidDev\tSetColourFormatConverter  FAILED for " << colourFmt);
 644   return FALSE;
 645 }
 646
 647
 648 BOOL PVideoDevice::SetColourFormat(const PString & colourFmt)
 649 {
 650   if (!colourFmt) {
 651     colourFormat = colourFmt.ToUpper();
 652     return TRUE;
 653   }
 654
 655   for (PINDEX i = 0; i < PARRAYSIZE(colourFormatBPPTab); i++) {
 656     if (SetColourFormat(colourFormatBPPTab[i].colourFormat))
 657       return TRUE;
 658   }
 659
 660   return FALSE;
 661 }
 662
 663
 664 const PString & PVideoDevice::GetColourFormat() const
 665 {
 666   return colourFormat;
 667 }
 668
 669
 670 BOOL PVideoDevice::SetFrameRate(unsigned rate)
 671 {
 672
 673   if (rate < 1) {
 674     frameRate = 0;
 675     return TRUE;
 676   }
 677
 678   frameRate = rate;
 679   previousFrameTime = PTime();
 680   msBetweenFrames = 1000/rate;
 681   frameTimeError  = 0;
 682
 683   return TRUE;
 684 }
 685
 686
 687 BOOL PVideoDevice::GetVFlipState()
 688 {
 689   if (converter != NULL)
 690     return converter->GetVFlipState() ^ nativeVerticalFlip;
 691
 692   return nativeVerticalFlip;
 693 }
 694
 695
 696 BOOL PVideoDevice::SetVFlipState(BOOL newVFlip)
 697 {
 698   if (newVFlip && converter == NULL)
 699     converter = PColourConverter::Create(colourFormat, colourFormat, frameWidth, frameHeight);
 700
 701   if (converter != NULL)
 702     converter->SetVFlipState(newVFlip ^ nativeVerticalFlip);
 703
 704   return TRUE;
 705 }
 706
 707
 708 unsigned PVideoDevice::GetFrameRate() const
 709 {
 710   return frameRate;
 711 }
 712
 713
 714 BOOL PVideoDevice::GetFrameSizeLimits(unsigned & minWidth,
 715                                       unsigned & minHeight,
 716                                       unsigned & maxWidth,
 717                                       unsigned & maxHeight)
 718 {
 719   minWidth = minHeight = 1;
 720   maxWidth = maxHeight = UINT_MAX;
 721   return FALSE;
 722 }
 723
 724
 725 static struct {
 726     unsigned asked_width, asked_height, device_width, device_height;
 727 } framesizeTab[] = {
 728     { 704, 576,    640, 480 },
 729     { 640, 480,    704, 576 },
 730     { 640, 480,    352, 288 },
 731
 732     { 352, 288,    704, 576 },
 733     { 352, 288,    640, 480 },
 734     { 352, 288,    352, 240 },
 735     { 352, 288,    320, 240 },
 736     { 352, 288,    176, 144 },
 737     { 352, 288,   1024, 576 }, /* High resolution need to be set at the end */
 738     { 352, 288,   1280, 960 },
 739
 740     { 352, 240,    352, 288 },
 741     { 352, 240,    320, 240 },
 742     { 352, 240,    640, 480 },
 743
 744     { 320, 240,    352, 288 },
 745     { 320, 240,    352, 240 },
 746     { 320, 240,    640, 480 },
 747
 748     { 176, 144,    352, 288 },
 749     { 176, 144,    352, 240 },
 750     { 176, 144,    320, 240 },
 751     { 176, 144,    176, 120 },
 752     { 176, 144,    160, 120 },
 753     { 176, 144,    640, 480 },
 754     { 176, 144,   1024, 576 },
 755     { 176, 144,   1280, 960 }, /* High resolution need to be set at the end */
 756
 757     { 176, 120,    352, 288 },
 758     { 176, 120,    352, 240 },
 759     { 176, 120,    320, 240 },
 760     { 176, 120,    176, 144 },
 761     { 176, 120,    160, 120 },
 762     { 176, 120,    640, 480 },
 763
 764     { 160, 120,    352, 288 },
 765     { 160, 120,    352, 240 },
 766     { 160, 120,    320, 240 },
 767     { 160, 120,    176, 144 },
 768     { 160, 120,    176, 120 },
 769     { 160, 120,    640, 480 },
 770 };
 771
 772 BOOL PVideoDevice::SetFrameSizeConverter(unsigned width, unsigned height,
 773            BOOL bScaleNotCrop)
 774 {
 775   if (SetFrameSize(width, height)) {
 776     if (nativeVerticalFlip && converter == NULL) {
 777       converter = PColourConverter::Create(colourFormat, colourFormat, frameWidth, frameHeight);
 778       if (PAssertNULL(converter) == NULL)
 779         return FALSE;
 780     }
 781     if (converter != NULL) {
 782       converter->SetFrameSize(frameWidth, frameHeight);
 783       converter->SetVFlipState(nativeVerticalFlip);
 784     }
 785     return TRUE;
 786   }
 787
 788   if (converter == NULL) {
 789     converter = PColourConverter::Create(colourFormat, colourFormat, frameWidth, frameHeight);
 790     if (converter == NULL) {
 791       PTRACE(1, "PVidDev\tSetFrameSizeConverter Colour converter creation failed");
 792       return FALSE;
 793     }
 794   }
 795
 796   PTRACE(3,"PVidDev\tColour converter used for " << width << 'x' << height);
 797
 798   unsigned minWidth, minHeight, maxWidth, maxHeight;
 799   BOOL limits = GetFrameSizeLimits(minWidth, minHeight, maxWidth, maxHeight);
 800
 801   for (PINDEX i = 0; i < PARRAYSIZE(framesizeTab); i++) {
 802     if (framesizeTab[i].asked_width == width &&
 803         framesizeTab[i].asked_height == height &&
 804         (!limits ||
 805          (framesizeTab[i].device_width >= minWidth &&
 806           framesizeTab[i].device_width <= maxWidth &&
 807           framesizeTab[i].device_height >= minHeight &&
 808           framesizeTab[i].device_height <= maxHeight)) &&
 809           SetFrameSize(framesizeTab[i].device_width,
 810           framesizeTab[i].device_height)) {
 811       if (CanCaptureVideo() ?
 812           converter->SetDstFrameSize(width, height, bScaleNotCrop)
 813           :
 814           converter->SetSrcFrameSize(width, height) &&
 815           converter->SetDstFrameSize(framesizeTab[i].device_width,
 816           framesizeTab[i].device_height,
 817           bScaleNotCrop)) {
 818         PTRACE(4,"PVideoDevice\tSetFrameSizeConverter succeeded for converting from "
 819             << framesizeTab[i].device_width << 'x' << framesizeTab[i].device_height
 820          << " to " << width << 'x' << height);
 821
 822         converter->SetVFlipState(converter->GetVFlipState() ^ nativeVerticalFlip);
 823         return TRUE;
 824       }
 825     }
 826   }
 827
 828   if (CanCaptureVideo()) {
 829     // Failed to find a resolution the device can do so far, so try
 830     // using the maximum width and height it claims it can do.
 831     if (limits &&
 832       SetFrameSize(maxWidth, maxHeight)) {
 833       if (converter->SetDstFrameSize(width, height, bScaleNotCrop)) {
 834         PTRACE(4,"PVideoDevice\tSetFrameSizeConverter succeeded for converting from "
 835           << maxWidth << 'x' << maxHeight
 836           << " to " << width << 'x' << height);
 837
 838         converter->SetVFlipState(converter->GetVFlipState() ^ nativeVerticalFlip);
 839         return TRUE;
 840       }
 841     }
 842   }
 843
 844   PTRACE(2,"PVideoDevice\tSetFrameSizeConverter failed for " << width << 'x' << height);
 845
 846   return FALSE;
 847 }
 848
 849
 850 BOOL PVideoDevice::SetFrameSize(unsigned width, unsigned height)
 851 {
 852 #if PTRACING
 853   unsigned oldWidth = frameWidth;
 854   unsigned oldHeight = frameHeight;
 855 #endif
 856
 857   unsigned minWidth, minHeight, maxWidth, maxHeight;
 858   GetFrameSizeLimits(minWidth, minHeight, maxWidth, maxHeight);
 859
 860   if (width < minWidth)
 861     frameWidth = minWidth;
 862   else if (width > maxWidth)
 863     frameWidth = maxWidth;
 864   else
 865     frameWidth = width;
 866
 867   if (height < minHeight)
 868     frameHeight = minHeight;
 869   else if (height > maxHeight)
 870     frameHeight = maxHeight;
 871   else
 872     frameHeight = height;
 873
 874   if (converter != NULL) {
 875     if (!converter->SetSrcFrameSize(width, height) ||
 876         !converter->SetDstFrameSize(width, height, FALSE)) {
 877       PTRACE(1, "PVidDev\tSetFrameSize with converter failed with " << width << 'x' << height);
 878       return FALSE;
 879     }
 880   }
 881
 882   PTRACE_IF(2, oldWidth != frameWidth || oldHeight != frameHeight,
 883             "PVidDev\tSetFrameSize to " << frameWidth << 'x' << frameHeight);
 884   return TRUE;
 885 }
 886
 887
 888 BOOL PVideoDevice::GetFrameSize(unsigned & width, unsigned & height)
 889 {
 890 #if 1
 891   // Channels get very upset at this not returning the output size.
 892   if (converter)
 893     return converter->GetDstFrameSize(width, height);
 894 #endif
 895   width = frameWidth;
 896   height = frameHeight;
 897   return TRUE;
 898 }
 899
 900
 901 unsigned PVideoDevice::GetFrameWidth() const
 902 {
 903 #if 1
 904     unsigned w,h;
 905
 906     // Channels get very upset at this not returning the output size.
 907     if (converter) {
 908       converter->GetDstFrameSize(w, h);
 909       return w;
 910     }
 911 #endif
 912   return frameWidth;
 913 }
 914
 915
 916 unsigned PVideoDevice::GetFrameHeight() const
 917 {
 918 #if 1
 919     unsigned w,h;
 920
 921     // Channels get very upset at this not returning the output size.
 922     if (converter) {
 923       converter->GetDstFrameSize(w, h);
 924       return h;
 925     }
 926 #endif
 927   return frameHeight;
 928 }
 929
 930
 931 unsigned PVideoDevice::CalculateFrameBytes(unsigned width, unsigned height,
 932                                            const PString & colourFormat)
 933 {
 934   for (PINDEX i = 0; i < PARRAYSIZE(colourFormatBPPTab); i++) {
 935     if (colourFormat *= colourFormatBPPTab[i].colourFormat)
 936       return width * height * colourFormatBPPTab[i].bitsPerPixel/8;
 937   }
 938   return 0;
 939 }
 940
 941
 942 PINDEX PVideoDevice::GetMaxFrameBytesConverted(PINDEX rawFrameBytes) const
 943 {
 944   if (converter == NULL)
 945     return rawFrameBytes;
 946
 947   PINDEX srcFrameBytes = converter->GetMaxSrcFrameBytes();
 948   PINDEX dstFrameBytes = converter->GetMaxDstFrameBytes();
 949   PINDEX convertedFrameBytes = PMAX(srcFrameBytes, dstFrameBytes);
 950   return PMAX(rawFrameBytes, convertedFrameBytes);
 951 }
 952
 953
 954 int PVideoDevice::GetBrightness()
 955 {
 956   return frameBrightness;
 957 }
 958
 959
 960 BOOL PVideoDevice::SetBrightness(unsigned newBrightness)
 961 {
 962   frameBrightness = newBrightness;
 963   return TRUE;
 964 }
 965
 966
 967 int PVideoDevice::GetWhiteness()
 968 {
 969   return frameWhiteness;
 970 }
 971
 972
 973 BOOL PVideoDevice::SetWhiteness(unsigned newWhiteness)
 974 {
 975   frameWhiteness = newWhiteness;
 976   return TRUE;
 977 }
 978
 979
 980 int PVideoDevice::GetColour()
 981 {
 982   return frameColour;
 983 }
 984
 985
 986 BOOL PVideoDevice::SetColour(unsigned newColour)
 987 {
 988   frameColour=newColour;
 989   return TRUE;
 990 }
 991
 992
 993 int PVideoDevice::GetContrast()
 994 {
 995   return frameContrast;
 996 }
 997
 998
 999 BOOL PVideoDevice::SetContrast(unsigned newContrast)
1000 {
1001   frameContrast=newContrast;
1002   return TRUE;
1003 }
1004
1005
1006 int PVideoDevice::GetHue()
1007 {
1008   return frameHue;
1009 }
1010
1011
1012 BOOL PVideoDevice::SetHue(unsigned newHue)
1013 {
1014   frameHue=newHue;
1015   return TRUE;
1016 }
1017
1018
1019 BOOL PVideoDevice::GetParameters (int *whiteness,
1020                                   int *brightness,
1021                                   int *colour,
1022                                   int *contrast,
1023                                   int *hue)
1024 {
1025   if (!IsOpen())
1026     return FALSE;
1027
1028   *brightness = frameBrightness;
1029   *colour     = frameColour;
1030   *contrast   = frameContrast;
1031   *hue        = frameHue;
1032   *whiteness  = frameWhiteness;
1033
1034   return TRUE;
1035 }
1036
1037 BOOL PVideoDevice::SetVideoChannelFormat (int newNumber, VideoFormat newFormat)
1038 {
1039   BOOL err1, err2;
1040
1041   err1 = SetChannel (newNumber);
1042   err2 = SetVideoFormat (newFormat);
1043
1044   return (err1 && err2);
1045 }
1046
1047 PStringList PVideoDevice::GetDeviceNames() const
1048 {
1049   return PStringList();
1050 }
1051
1052
1053 ///////////////////////////////////////////////////////////////////////////////
1054 // PVideoOutputDevice
1055
1056 PVideoOutputDevice::PVideoOutputDevice()
1057 {
1058 }
1059
1060
1061 BOOL PVideoOutputDevice::CanCaptureVideo() const
1062 {
1063   return FALSE;
1064 }
1065
1066
1067 ///////////////////////////////////////////////////////////////////////////////
1068 // PVideoOutputDeviceRGB
1069
1070 PVideoOutputDeviceRGB::PVideoOutputDeviceRGB()
1071 {
1072   PTRACE(6, "RGB\t Constructor of PVideoOutputDeviceRGB");
1073
1074   colourFormat = "RGB24";
1075   bytesPerPixel = 3;
1076   swappedRedAndBlue = false;
1077   SetFrameSize(frameWidth, frameHeight);
1078 }
1079
1080
1081 BOOL PVideoOutputDeviceRGB::SetColourFormat(const PString & colourFormat)
1082 {
1083   PWaitAndSignal m(mutex);
1084
1085   PINDEX newBytesPerPixel;
1086   bool newSwappedRedAndBlue;
1087   if (colourFormat *= "RGB32") {
1088     newBytesPerPixel = 4;
1089     newSwappedRedAndBlue = false;
1090   }
1091   else if (colourFormat *= "RGB24") {
1092     newBytesPerPixel = 3;
1093     newSwappedRedAndBlue = false;
1094   }
1095   else if (colourFormat *= "BGR32") {
1096     newBytesPerPixel = 4;
1097     newSwappedRedAndBlue = true;
1098   }
1099   else if (colourFormat *= "BGR24") {
1100     newBytesPerPixel = 3;
1101     newSwappedRedAndBlue = true;
1102   }
1103   else
1104     return FALSE;
1105
1106   if (!PVideoOutputDevice::SetColourFormat(colourFormat))
1107     return FALSE;
1108
1109   bytesPerPixel = newBytesPerPixel;
1110   scanLineWidth = ((frameWidth*bytesPerPixel+3)/4)*4;
1111   return frameStore.SetSize(frameHeight*scanLineWidth);
1112 }
1113
1114
1115 BOOL PVideoOutputDeviceRGB::SetFrameSize(unsigned width, unsigned height)
1116 {
1117   PWaitAndSignal m(mutex);
1118
1119   if (!PVideoOutputDevice::SetFrameSize(width, height))
1120     return FALSE;
1121
1122   scanLineWidth = ((frameWidth*bytesPerPixel+3)/4)*4;
1123   return frameStore.SetSize(frameHeight*scanLineWidth);
1124 }
1125
1126
1127 PINDEX PVideoOutputDeviceRGB::GetMaxFrameBytes()
1128 {
1129   PWaitAndSignal m(mutex);
1130   return GetMaxFrameBytesConverted(frameStore.GetSize());
1131 }
1132
1133
1134 BOOL PVideoOutputDeviceRGB::SetFrameData(unsigned x, unsigned y,
1135                                          unsigned width, unsigned height,
1136                                          const BYTE * data,
1137                                          BOOL endFrame)
1138 {
1139   PWaitAndSignal m(mutex);
1140
1141   if (x+width > frameWidth || y+height > frameHeight)
1142     return FALSE;
1143
1144   if (x == 0 && width == frameWidth && y == 0 && height == frameHeight) {
1145     if (converter != NULL)
1146       converter->Convert(data, frameStore.GetPointer());
1147     else
1148       memcpy(frameStore.GetPointer(), data, height*scanLineWidth);
1149   }
1150   else {
1151     if (converter != NULL) {
1152       PAssertAlways("Converted output of partial RGB frame not supported");
1153       return FALSE;
1154     }
1155
1156     if (x == 0 && width == frameWidth)
1157       memcpy(frameStore.GetPointer() + y*scanLineWidth, data, height*scanLineWidth);
1158     else {
1159       for (unsigned dy = 0; dy < height; dy++)
1160         memcpy(frameStore.GetPointer() + (y+dy)*scanLineWidth + x*bytesPerPixel,
1161                data + dy*width*bytesPerPixel, width*bytesPerPixel);
1162     }
1163   }
1164
1165   if (endFrame)
1166     return FrameComplete();
1167
1168   return TRUE;
1169 }
1170
1171
1172 ///////////////////////////////////////////////////////////////////////////////
1173 // PVideoOutputDevicePPM
1174
1175 #ifdef SHOULD_BE_MOVED_TO_PLUGIN
1176
1177 PVideoOutputDevicePPM::PVideoOutputDevicePPM()
1178 {
1179   PTRACE(6, "PPM\t Constructor of PVideoOutputDevicePPM");
1180   frameNumber = 0;
1181 }
1182
1183
1184 BOOL PVideoOutputDevicePPM::Open(const PString & name,
1185                                  BOOL /*startImmediate*/)
1186 {
1187   Close();
1188
1189   PFilePath path = name;
1190   if (!PDirectory::Exists(path.GetDirectory()))
1191     return FALSE;
1192
1193   if (path != psprintf(path, 12345))
1194     deviceName = path;
1195   else
1196     deviceName = path.GetDirectory() + path.GetTitle() + "%u" + path.GetType();
1197
1198   return TRUE;
1199 }
1200
1201
1202 BOOL PVideoOutputDevicePPM::IsOpen()
1203 {
1204   return !deviceName;
1205 }
1206
1207
1208 BOOL PVideoOutputDevicePPM::Close()
1209 {
1210   deviceName.MakeEmpty();
1211   return TRUE;
1212 }
1213
1214
1215 PStringList PVideoOutputDevicePPM::GetDeviceNames() const
1216 {
1217   PStringList list;
1218   list += PDirectory();
1219   return list;
1220 }
1221
1222
1223 BOOL PVideoOutputDevicePPM::EndFrame()
1224 {
1225   PFile file;
1226   if (!file.Open(psprintf(deviceName, frameNumber++), PFile::WriteOnly)) {
1227     PTRACE(1, "PPMVid\tFailed to open PPM output file \""
1228            << file.GetName() << "\": " << file.GetErrorText());
1229     return FALSE;
1230   }
1231
1232   file << "P6 " << frameWidth  << " " << frameHeight << " " << 255 << "\n";
1233
1234   if (!file.Write(frameStore, frameStore.GetSize())) {
1235     PTRACE(1, "PPMVid\tFailed to write frame data to PPM output file " << file.GetName());
1236     return FALSE;
1237   }
1238
1239   PTRACE(6, "PPMVid\tFinished writing PPM file " << file.GetName());
1240   return file.Close();
1241 }
1242
1243 #endif // SHOULD_BE_MOVED_TO_PLUGIN
1244
1245
1246 ///////////////////////////////////////////////////////////////////////////////
1247 // PVideoInputDevice
1248
1249 BOOL PVideoInputDevice::CanCaptureVideo() const
1250 {
1251   return TRUE;
1252 }
1253
1254 static const char videoInputPluginBaseClass[] = "PVideoInputDevice";
1255
1256
1257 PStringList PVideoInputDevice::GetDriverNames(PPluginManager * pluginMgr)
1258 {
1259   if (pluginMgr == NULL)
1260     pluginMgr = &PPluginManager::GetPluginManager();
1261
1262   return pluginMgr->GetPluginsProviding(videoInputPluginBaseClass);
1263 }
1264
1265
1266 PStringList PVideoInputDevice::GetDriversDeviceNames(const PString & driverName, PPluginManager * pluginMgr)
1267 {
1268   if (pluginMgr == NULL)
1269     pluginMgr = &PPluginManager::GetPluginManager();
1270
1271   return pluginMgr->GetPluginsDeviceNames(driverName, videoInputPluginBaseClass);
1272 }
1273
1274
1275 PVideoInputDevice * PVideoInputDevice::CreateDevice(const PString &driverName, PPluginManager * pluginMgr)
1276 {
1277   if (pluginMgr == NULL)
1278     pluginMgr = &PPluginManager::GetPluginManager();
1279
1280   return (PVideoInputDevice *)pluginMgr->CreatePluginsDevice(driverName, videoInputPluginBaseClass);
1281 }
1282
1283
1284 PVideoInputDevice * PVideoInputDevice::CreateDeviceByName(const PString & deviceName, const PString & driverName, PPluginManager * pluginMgr)
1285 {
1286   if (pluginMgr == NULL)
1287     pluginMgr = &PPluginManager::GetPluginManager();
1288
1289   return (PVideoInputDevice *)pluginMgr->CreatePluginsDeviceByName(deviceName, videoInputPluginBaseClass,0,driverName);
1290 }
1291
1292
1293 PVideoInputDevice * PVideoInputDevice::CreateOpenedDevice(const PString & driverName,
1294                                                           const PString & deviceName,
1295                                                           BOOL startImmediate,
1296                                                           PPluginManager * pluginMgr)
1297 {
1298   PVideoInputDevice * device = CreateDeviceByName(deviceName, driverName, pluginMgr);
1299
1300   if (device != NULL && device->Open(deviceName, startImmediate))
1301     return device;
1302
1303   delete device;
1304   return NULL;
1305 }
1306
1307
1308 PVideoInputDevice * PVideoInputDevice::CreateOpenedDevice(const OpenArgs & args,
1309                                                           BOOL startImmediate)
1310 {
1311   PVideoInputDevice * device = CreateDeviceByName(args.deviceName, args.driverName, args.pluginMgr);
1312
1313   if (device != NULL && device->OpenFull(args, startImmediate))
1314     return device;
1315
1316   delete device;
1317   return NULL;
1318 }
1319
1320
1321 BOOL PVideoInputDevice::GetFrame(PBYTEArray & frame)
1322 {
1323   PINDEX returned;
1324   if (!GetFrameData(frame.GetPointer(GetMaxFrameBytes()), &returned))
1325     return FALSE;
1326
1327   frame.SetSize(returned);
1328   return TRUE;
1329 }
1330
1331
1332 ////////////////////////////////////////////////////////////////////////////////////////////
1333
1334 static const char videoOutputPluginBaseClass[] = "PVideoOutputDevice";
1335
1336
1337 PStringList PVideoOutputDevice::GetDriverNames(PPluginManager * pluginMgr)
1338 {
1339   if (pluginMgr == NULL)
1340     pluginMgr = &PPluginManager::GetPluginManager();
1341
1342   return pluginMgr->GetPluginsProviding(videoOutputPluginBaseClass);
1343 }
1344
1345
1346 PStringList PVideoOutputDevice::GetDriversDeviceNames(const PString & driverName, PPluginManager * pluginMgr)
1347 {
1348   if (pluginMgr == NULL)
1349     pluginMgr = &PPluginManager::GetPluginManager();
1350
1351   return pluginMgr->GetPluginsDeviceNames(driverName, videoOutputPluginBaseClass);
1352 }
1353
1354
1355 PVideoOutputDevice * PVideoOutputDevice::CreateDevice(const PString & driverName, PPluginManager * pluginMgr)
1356 {
1357   if (pluginMgr == NULL)
1358     pluginMgr = &PPluginManager::GetPluginManager();
1359
1360   return (PVideoOutputDevice *)pluginMgr->CreatePluginsDevice(driverName, videoOutputPluginBaseClass);
1361 }
1362
1363
1364 PVideoOutputDevice * PVideoOutputDevice::CreateDeviceByName(const PString & deviceName, const PString & driverName, PPluginManager * pluginMgr)
1365 {
1366   if (pluginMgr == NULL)
1367     pluginMgr = &PPluginManager::GetPluginManager();
1368
1369   return (PVideoOutputDevice *)pluginMgr->CreatePluginsDeviceByName(deviceName, videoOutputPluginBaseClass, 0, driverName);
1370 }
1371
1372
1373 PVideoOutputDevice * PVideoOutputDevice::CreateOpenedDevice(const PString &driverName,
1374                                                             const PString &deviceName,
1375                                                             BOOL startImmediate,
1376                                                             PPluginManager * pluginMgr)
1377 {
1378   PVideoOutputDevice * device;
1379   if (driverName.IsEmpty() || driverName == "*")
1380     device = CreateDeviceByName(deviceName, driverName, pluginMgr);
1381   else
1382     device = CreateDevice(driverName, pluginMgr);
1383
1384   if (device != NULL && device->Open(deviceName, startImmediate))
1385     return device;
1386
1387   delete device;
1388   return NULL;
1389 }
1390
1391
1392 PVideoOutputDevice * PVideoOutputDevice::CreateOpenedDevice(const OpenArgs & args,
1393                                                             BOOL startImmediate)
1394 {
1395   PVideoOutputDevice * device;
1396   if (args.driverName.IsEmpty() || args.driverName == "*")
1397     device = CreateDeviceByName(args.deviceName, args.driverName, args.pluginMgr);
1398   else
1399     device = CreateDevice(args.driverName, args.pluginMgr);
1400
1401   if (device != NULL && device->OpenFull(args, startImmediate))
1402     return device;
1403
1404   delete device;
1405   return NULL;
1406 }
1407
1408
1409 // End Of File ///////////////////////////////////////////////////////////////