plugins/vidinput_dc/video4dc1394.cxx

   1 /*
   2  * README for IEEE 1394 digital camera support routine in PWLib
   3  * ------------------------------------------------------------
   4  *
   5  * PWLib now contains preliminary support for the IEEE 1394 digital
   6  * cameras under Linux.
   7  *
   8  *
   9  * Supported cameras:
  10  *
  11  * There are two kind of the specifications of IEEE 1394 digital video
  12  * cameras, one is called "digital camera" and another is "AV/C camera".
  13  * A digital camera sends uncompressed video data while an AV/C camera
  14  * sends compressed data. Currently PWLib only supports digital
  15  * cameras. We can find a list of supported digital cameras by the Linux
  16  * device driver at:
  17  * http://www.tele.ucl.ac.be/PEOPLE/DOUXCHAMPS/ieee1394/cameras/
  18  *
  19  * AV/C cameras seem able to be used for video phone. You are welcome to
  20  * write supporting codes for AV/C cameras!
  21  *
  22  *
  23  * Installation and Use:
  24  *
  25  * To enable 1394 camera support, you have to define the "TRY_1394DC"
  26  * shell environment variable at compilation time of PWLib, OpenH323, and
  27  * ohphone. To select your 1394 camera for video input device instead of
  28  * usual Video4Linux devices, specify "/dev/raw1394" or "/dev/video1394"
  29  * as the filename of video input device. For example "ohphone
  30  * --videoinput /dev/raw1394" should use your 1394 camera as video input.
  31  *
  32  * "/dev/video1394" uses faster DMA transfer for video input.
  33  *
  34  * If you use DEVFS, the filename for DMA transfer may be /dev/video1394/0.
  35  *
  36  * Requirements for Installation:
  37  *
  38  * You needs the following softwares to compile the 1394 camera support
  39  * module in PWLib.
  40  *
  41  * - libdc1394 0.9.0 or later.
  42  * - Linux 2.4.19 or later, which is required by the above version of
  43  *   libdc1394
  44  * - libraw1394 0.9.0 or later
  45  *
  46  * You cannot compile it with older versions of libdc1394.
  47  *
  48  * Troubleshooting:
  49  *
  50  * If this module does not work for you, please verify the following
  51  * items before sending email:
  52  *
  53  * 1) Can you view image of your camera by other programs? A sample
  54  *    program called "grab_gray_image" is included in the example
  55  *    directory of libdc1394. Please run grab_gray_image and see what
  56  *    happens. You can also use Coriander instead.
  57  *    (http://www.tele.ucl.ac.be/PEOPLE/DOUXCHAMPS/ieee1394/coriander/).
  58  * 2) If you have make sure other programs can use the camera, but
  59  *    this module still does not work, please run the debbuging version
  60  *    of ohphone with option "-tttt -o log.txt". Examine the file "log.txt"
  61  *    and you may see what is wrong.
  62  *
  63  *
  64  * Problem Reports:
  65  * They should be send to Ryutaroh Matsumoto <ryutaroh@rmatsumoto.org>.
  66  *
  67  *
  68  * Acknowledgment:
  69  * R. Matsumoto thanks Dr. Derek Smithies for his kind support for making
  70  * this module.
  71  *
  72  *
  73  * Technical Notes for Programmers
  74  * ------------------------------------------------------------
  75  *
  76  * Test Environment:
  77  * This module was tested against:
  78  *
  79  * Pentium III
  80  * Linux 2.4.19
  81  * libraw1394 0.9.0
  82  * libdc1394 0.9.0
  83  *
  84  * Irez StealthFire Camera (http://www.irez.com)
  85  * OrangeMicro iBot Camera (http://www.orangemicro.com)
  86  *
  87  *
  88  * Internal Structure:
  89  * This module has been tested against the ohphone and GnomeMeeting
  90  * video phone programs. They use 352x288 and 176x144 resolutions in
  91  * YUV420P color format. So this module only supports these
  92  * resolutions and YUV420P.
  93  *
  94  * 1394 Digital Cameras has many resolutions and color formats. Among
  95  * them, this module uses:
  96  *      160x120 YUV(4:4:4)  for  176x144 PTlib resolution, and
  97  *      320x240 YUV(4:2:2)  for  352x288 PTlib resolution.
  98  * The bus speed is always set to P_DC1394_DEFAULT_SPEED (400 Mbps).
  99  * If transfer at P_DC1394_DEFAULT_SPEED is not supported by your
 100  * camera, this module does not capture images from yours. In such
 101  * a case please set P_DC1394_DEFAULT_SPEED to appropriate value.
 102  *
 103  * Conversion routines from above formats to YUV420P were added to
 104  * src/ptlib/common/vconvert.cxx
 105  *
 106  * ToDo or Bugs:
 107  * This module does not implement GetBrightness() etc.  1394 cameras
 108  * can do both automatic control and manual control of brightness
 109  * etc., and they are usually set to automatic
 110  * control. Get/SetBrightness() etc. cannot access manual/automatic
 111  * selection. So we cannot implement an interface that can fully
 112  * control all of 1394 camera features. I decided not to implement
 113  * controlling interface at all. Those features can be controlled by
 114  * Coriander program even when ohphone or GnomeMeeting is being used.
 115  * Please use Coriander.
 116  *
 117  * PVideoInput1394DcDevice does not allow creation of two or more instances.
 118  *
 119  * The bus speed is always set to P_DC1394_DEFAULT_SPEED (400 Mbps).
 120  * If transfer at P_DC1394_DEFAULT_SPEED is not supported by your
 121  * camera, this module does not capture images from yours. In such
 122  * a case please set P_DC1394_DEFAULT_SPEED to appropriate value.
 123  *
 124  * Copyright:
 125  * Copyright (c) 2002 Ryutaroh Matsumoto <ryutaroh@rmatsumoto.org>
 126  *
 127  * The contents of this file are subject to the Mozilla Public License
 128  * Version 1.0 (the "License"); you may not use this file except in
 129  * compliance with the License. You may obtain a copy of the License at
 130  * http://www.mozilla.org/MPL/
 131  *
 132  * Software distributed under the License is distributed on an "AS IS"
 133  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 134  * the License for the specific language governing rights and limitations
 135  * under the License.
 136  *
 137  *
 138  *
 139  * $Log$
 140  * Revision 1.2  2004/05/10 10:09:19  csoutheren
 141  * Removed printf that was interpreted as a trigraph
 142  *
 143  * Revision 1.1  2003/12/17 15:40:56  dominance
 144  * Added DC Plugin as provided by Julien Puydt <julien.puydt@laposte.net>. Needs manual patching of plugins/configure for now though. (i.e. disabled by default, run autoconf in plugins/)
 145  *
 146  * Revision 1.9  2003/03/17 07:53:04  robertj
 147  * Removed canCaptureVideo variable as this is really a virtual function to
 148  *   distinguish PVideoOutputDevice from PVideoInputDevice, it is not dynamic.
 149  *
 150  * Revision 1.8  2002/08/21 00:00:31  dereks
 151  * Patches from Ryutaroh, to improve firewire (linux only) support. Many thanks.
 152  *
 153  * Revision 1.7  2002/05/30 22:49:35  dereks
 154  * correct implementation of GetInputDeviceNames().
 155  *
 156  * Revision 1.6  2002/03/04 01:21:31  dereks
 157  * Add frame rate support to Firewire camera. Thanks Ryutaroh Matsumoto.
 158  *
 159  * Revision 1.5  2002/02/28 19:44:03  dereks
 160  * Add complete readme on Firewire usage. Thanks to Ryutaroh Matsumoto.
 161  *
 162  * Revision 1.4  2002/02/21 20:00:21  dereks
 163  * Fix memory leak. Thanks Ryutaroh Matsumoto.
 164  *
 165  * Revision 1.3  2002/02/21 19:49:57  dereks
 166  * Fix spelling mistake. Thanks Ryutaroh
 167  *
 168  * Revision 1.2  2002/02/20 20:27:28  dereks
 169  * updates to previous checkin.
 170  *
 171  * Revision 1.1  2002/02/20 02:37:26  dereks
 172  * Initial release of Firewire camera support for linux.
 173  * Many thanks to Ryutaroh Matsumoto <ryutaroh@rmatsumoto.org>.
 174  *
 175  *
 176  *
 177  *
 178  */
 179
 180 #pragma implementation "videoio1394dc.h"
 181
 182 #include <ptlib.h>
 183 #include <ptlib/videoio.h>
 184 #include <ptlib/vconvert.h>
 185 #include <ptlib/file.h>
 186 #include "videoio1394dc.h"
 187 #include <sys/utsname.h>
 188
 189 PCREATE_VIDINPUT_PLUGIN(DC, PVideoInput1394DcDevice);
 190
 191 #ifndef P_DC1394_DEFAULT_SPEED
 192 #define P_DC1394_DEFAULT_SPEED  SPEED_400
 193 #endif
 194
 195 //#define ESTIMATE_CAPTURE_PERFORMANCE
 196
 197 #ifdef ESTIMATE_CAPTURE_PERFORMANCE
 198 // for debugging
 199 static PInt64 start_time;
 200 static int num_captured;
 201 #endif
 202
 203
 204 ///////////////////////////////////////////////////////////////////////////////
 205 // PVideoInput1394DC
 206
 207 PVideoInput1394DcDevice::PVideoInput1394DcDevice()
 208 {
 209   handle = NULL;
 210   is_capturing = FALSE;
 211   capturing_duration = 10000; // arbitrary large value suffices
 212 }
 213
 214 PVideoInput1394DcDevice::~PVideoInput1394DcDevice()
 215 {
 216   Close();
 217 }
 218
 219 #define OK 1
 220 #define NG 0
 221 static int kernel_version_ok(void)
 222 {
 223   struct utsname utsbuf;
 224   unsigned major_ver, minor_ver, minorminor_ver;
 225
 226   if (uname(&utsbuf) == -1)
 227     return NG;
 228
 229   /* utsbuf.release looks like "2.4.19-pre8". */
 230   if (sscanf(utsbuf.release, "%u.%u.%u", &major_ver, &minor_ver,
 231              &minorminor_ver) < 3)
 232     return NG; /* Should we return OK? */
 233
 234   if (major_ver >= 3)
 235     return OK;
 236   else if (major_ver <= 1)
 237     return NG;
 238
 239   if (minor_ver >= 6)
 240     return OK;
 241   else if (minor_ver <= 3)
 242     return NG;
 243   else if (minor_ver == 4)
 244     return minorminor_ver >= 19;
 245   else /* if (minor_ver == 5) */
 246     return minorminor_ver >= 9;
 247 }
 248
 249 BOOL PVideoInput1394DcDevice::Open(const PString & devName, BOOL startImmediate)
 250 {
 251   if (!kernel_version_ok()) {
 252     PTRACE(0, "The Linux kernel version is too old.");
 253     return FALSE;
 254   }
 255
 256   if (IsOpen()) {
 257     PTRACE(0, "You cannot open PVideoInput1394DcDevice twice.");
 258     return FALSE;
 259   }
 260
 261   if (devName == "/dev/raw1394")
 262     UseDMA = FALSE;
 263   // Don't forget /dev/video1394/0
 264   else if (strncmp(devName, "/dev/video1394", 14) == 0)
 265     UseDMA = TRUE;
 266   else {
 267     PTRACE(0, "devName must be /dev/raw1394 or /dev/video1394");
 268     return FALSE;
 269   }
 270
 271   // See if devName is accessible.
 272   if (!PFile::Exists(devName)) {
 273     PTRACE(1, devName << " is not accessible.");
 274     return FALSE;
 275   }
 276
 277   /*-----------------------------------------------------------------------
 278    *  Open ohci and asign handle to it
 279    *-----------------------------------------------------------------------*/
 280   handle = dc1394_create_handle(0);
 281   if (handle==NULL)
 282   {
 283     PTRACE(0, "Unable to aquire a raw1394 handle\n"
 284            "did you insmod the drivers?\n");
 285     return FALSE;
 286   }
 287
 288   /*-----------------------------------------------------------------------
 289    *  get the camera nodes and describe them as we find them
 290    *-----------------------------------------------------------------------*/
 291   int numNodes = raw1394_get_nodecount(handle);
 292   camera_nodes = dc1394_get_camera_nodes(handle,&numCameras,0);
 293   if (numCameras<1)
 294   {
 295     PTRACE(0, "no cameras found :(\n");
 296     dc1394_destroy_handle(handle);
 297     handle = NULL;
 298     return FALSE;
 299   }
 300
 301   /*-----------------------------------------------------------------------
 302    *  to prevent the iso-transfer bug from raw1394 system, check if
 303    *  camera is highest node. For details see
 304    *  http://linux1394.sourceforge.net/faq.html#DCbusmgmt
 305    *  and
 306    *  http://sourceforge.net/tracker/index.php?func=detail&aid=435107&group_id=8157&atid=108157
 307    *-----------------------------------------------------------------------*/
 308   for (int i=0; i<numCameras; i++) {
 309     if( camera_nodes[i] == numNodes-1) {
 310       PTRACE(0,"Sorry, your camera is the highest numbered node\n"
 311              "of the bus, and has therefore become the root node.\n"
 312              "The root node is responsible for maintaining \n"
 313              "the timing of isochronous transactions on the IEEE \n"
 314              "1394 bus.  However, if the root node is not cycle master \n"
 315              "capable (it doesn't have to be), then isochronous \n"
 316              "transactions will not work.  The host controller card is \n"
 317              "cycle master capable, however, most cameras are not.\n"
 318              "\n"
 319              "The quick solution is to add the parameter \n"
 320              "attempt_root=1 when loading the OHCI driver as a \n"
 321              "module.  So please do (as root):\n"
 322              "\n"
 323              "   rmmod ohci1394\n"
 324              "   insmod ohci1394 attempt_root=1\n"
 325              "\n"
 326              "for more information see the FAQ at \n"
 327              "http://linux1394.sourceforge.net/faq.html#DCbusmgmt\n"
 328              "\n");
 329       dc1394_destroy_handle(handle);
 330       handle = NULL;
 331       return FALSE;
 332     }
 333   }
 334
 335   frameHeight = 240;
 336   frameWidth = 320;
 337   colourFormat = "UYVY422";
 338   desiredFrameHeight = CIFHeight;
 339   desiredFrameWidth = CIFWidth;
 340   desiredColourFormat = "YUV420P";
 341   capturing_duration = 10000; // arbitrary large value suffices
 342   deviceName = devName;
 343
 344   // select the specified input and video format
 345   if (!SetChannel(channelNumber) ||
 346       !SetVideoFormat(videoFormat)) {
 347     PTRACE(1, "SetChannel() or SetVideoFormat() failed");
 348     Close();
 349     return FALSE;
 350   }
 351
 352   if (startImmediate && !Start()) {
 353     Close();
 354     return FALSE;
 355   }
 356   PTRACE(3, "Successfully opended\n");
 357   return TRUE;
 358 }
 359
 360
 361 BOOL PVideoInput1394DcDevice::IsOpen()
 362 {
 363   return handle != NULL;
 364 }
 365
 366
 367 BOOL PVideoInput1394DcDevice::Close()
 368 {
 369   if (IsOpen()) {
 370     if (IsCapturing())
 371       Stop();
 372     dc1394_destroy_handle(handle);
 373     handle = NULL;
 374     return TRUE;
 375   } else
 376     return FALSE;
 377 }
 378
 379 BOOL PVideoInput1394DcDevice::Start()
 380 {
 381   int dc1394_mode;
 382   if (!IsOpen()) return FALSE;
 383   if (is_capturing) return TRUE;
 384   if (frameWidth == 320 && frameHeight == 240)
 385     dc1394_mode = MODE_320x240_YUV422;
 386   else if (frameWidth == 160 && frameHeight == 120)
 387     dc1394_mode = MODE_160x120_YUV444;
 388   else {
 389     PTRACE(1, "Frame size is neither 320x240 or 160x120" << frameWidth <<
 390            "x" << frameHeight);
 391     return FALSE;
 392   }
 393   PTRACE(1, deviceName << " " << channelNumber);
 394
 395   quadlet_t supported_framerates;
 396   if (dc1394_query_supported_framerates(handle, camera_nodes[channelNumber],
 397                                         FORMAT_VGA_NONCOMPRESSED, dc1394_mode,
 398                                         &supported_framerates) != DC1394_SUCCESS) {
 399     PTRACE(1, "dc1394_query_supported_framerates() failed.");
 400     return FALSE;
 401   }
 402
 403   int framerate;
 404
 405   // supported_framerates seems always in the network byte order.
 406   if (supported_framerates & (1U << (31-5)))
 407     framerate = FRAMERATE_60;
 408   else if (supported_framerates & (1U << (31-4)))
 409     framerate = FRAMERATE_30;
 410   else if (supported_framerates & (1U << (31-3)))
 411     framerate = FRAMERATE_15;
 412   else if (supported_framerates & (1U << (31-2)))
 413     framerate = FRAMERATE_7_5;
 414   else if (supported_framerates & (1U << (31-1)))
 415     framerate = FRAMERATE_3_75;
 416   else if (supported_framerates & (1U << (31-0)))
 417     framerate = FRAMERATE_1_875;
 418   else {
 419     PTRACE(1, "Frame rate " << supported_framerates << " is not supported");
 420     return FALSE;
 421   }
 422
 423   // In order to compile the following line, you need libdc1394 0.9.0 or later.
 424   if ((UseDMA &&dc1394_dma_setup_capture(handle,camera_nodes[channelNumber],
 425                            0, /* channel of IEEE 1394 */
 426                            FORMAT_VGA_NONCOMPRESSED,
 427                            dc1394_mode,
 428                            P_DC1394_DEFAULT_SPEED,
 429                            framerate, 4, 1, deviceName,
 430                          &camera)!=DC1394_SUCCESS) ||
 431       (!UseDMA && dc1394_setup_capture(handle,camera_nodes[channelNumber],
 432                            0, /* channel of IEEE 1394 */
 433                            FORMAT_VGA_NONCOMPRESSED,
 434                            dc1394_mode,
 435                            P_DC1394_DEFAULT_SPEED,
 436                            framerate,
 437                        &camera)!=DC1394_SUCCESS))
 438   {
 439     PTRACE(0,"unable to setup camera-\n"
 440              "check " __FILE__ " to make sure\n"
 441              "that the video mode,framerate and format are\n"
 442              "supported by your camera\n");
 443     return FALSE;
 444   }
 445
 446   /*-----------------------------------------------------------------------
 447    *  have the camera start sending us data
 448    *-----------------------------------------------------------------------*/
 449   if (dc1394_start_iso_transmission(handle,camera.node)
 450       !=DC1394_SUCCESS)
 451   {
 452     PTRACE(0, "unable to start camera iso transmission\n");
 453     if (UseDMA)
 454       dc1394_dma_release_camera(handle,&camera);
 455     else
 456       dc1394_release_camera(handle,&camera);
 457     return FALSE;
 458   }
 459   is_capturing = TRUE;
 460 #ifdef ESTIMATE_CAPTURE_PERFORMANCE
 461   PTime now;
 462   start_time = now.GetTimestamp();
 463   num_captured = 0;
 464 #endif
 465   return TRUE;
 466 }
 467
 468
 469 BOOL PVideoInput1394DcDevice::Stop()
 470 {
 471   if (IsCapturing()) {
 472     dc1394_stop_iso_transmission(handle,camera.node);
 473     if (UseDMA) {
 474     dc1394_dma_unlisten(handle, &camera);
 475     dc1394_dma_release_camera(handle,&camera);
 476     } else
 477       dc1394_release_camera(handle,&camera);
 478     is_capturing = FALSE;
 479     return TRUE;
 480   } else
 481     return FALSE;
 482 }
 483
 484
 485 BOOL PVideoInput1394DcDevice::IsCapturing()
 486 {
 487   return is_capturing;
 488 }
 489
 490 PStringList PVideoInput1394DcDevice::GetInputDeviceNames()
 491 {
 492   PStringList list;
 493
 494   if (PFile::Exists("/dev/raw1394"))
 495     list.AppendString("/dev/raw1394");
 496   if (PFile::Exists("/dev/video1394/0"))
 497     // DEVFS naming scheme
 498     for (int i=0; ; i++) {
 499       PString devname = PString("/dev/video1394/") + PString(i);
 500       if (PFile::Exists(devname))
 501         list.AppendString(devname);
 502       else
 503         break;
 504     }
 505   else if (PFile::Exists("/dev/video1394"))
 506     /* traditional naming */
 507     list.AppendString("/dev/video1394");
 508   return list;
 509 }
 510
 511
 512 BOOL PVideoInput1394DcDevice::SetVideoFormat(VideoFormat newFormat)
 513 {
 514   if (!PVideoDevice::SetVideoFormat(newFormat)) {
 515     PTRACE(3,"PVideoDevice::SetVideoFormat\t failed for format "<<newFormat);
 516     return FALSE;
 517   }
 518   return TRUE;
 519 }
 520
 521 int PVideoInput1394DcDevice::GetBrightness()
 522 {
 523   return -1;
 524 }
 525
 526
 527 BOOL PVideoInput1394DcDevice::SetBrightness(unsigned newBrightness)
 528 {
 529   return FALSE;
 530 }
 531
 532
 533 int PVideoInput1394DcDevice::GetHue()
 534 {
 535   return -1;
 536 }
 537
 538
 539 BOOL PVideoInput1394DcDevice::SetHue(unsigned newHue)
 540 {
 541   return FALSE;
 542 }
 543
 544
 545 int PVideoInput1394DcDevice::GetContrast()
 546 {
 547   return -1;
 548 }
 549
 550
 551 BOOL PVideoInput1394DcDevice::SetContrast(unsigned newContrast)
 552 {
 553   return FALSE;
 554 }
 555
 556 BOOL PVideoInput1394DcDevice::SetColour(unsigned newColour)
 557 {
 558   return -1;
 559 }
 560
 561 int PVideoInput1394DcDevice::GetColour()
 562 {
 563   return -1;
 564 }
 565
 566
 567 BOOL PVideoInput1394DcDevice::SetWhiteness(unsigned newWhiteness)
 568 {
 569   return FALSE;
 570 }
 571
 572 int PVideoInput1394DcDevice::GetWhiteness()
 573 {
 574   return -1;
 575 }
 576
 577
 578 BOOL PVideoInput1394DcDevice::GetParameters (int *whiteness, int *brightness,
 579                                        int *colour, int *contrast, int *hue)
 580 {
 581   *whiteness = -1;
 582   *brightness = -1;
 583   *colour = -1;
 584   *hue = -1;
 585   return FALSE;
 586 }
 587
 588
 589 int PVideoInput1394DcDevice::GetNumChannels()
 590 {
 591   return numCameras;
 592 }
 593
 594
 595 BOOL PVideoInput1394DcDevice::SetChannel(int newChannel)
 596 {
 597   if (PVideoDevice::SetChannel(newChannel) == FALSE)
 598     return FALSE;
 599   if(IsCapturing()) {
 600     Stop();
 601     Start();
 602   }
 603   return TRUE;
 604 }
 605
 606
 607
 608 BOOL PVideoInput1394DcDevice::SetFrameRate(unsigned rate)
 609 {
 610   return PVideoDevice::SetFrameRate(rate);
 611 }
 612
 613
 614 BOOL PVideoInput1394DcDevice::GetFrameSizeLimits(unsigned & minWidth,
 615                                            unsigned & minHeight,
 616                                            unsigned & maxWidth,
 617                                            unsigned & maxHeight)
 618 {
 619   minWidth = 160;
 620   maxWidth = 320;
 621   minHeight = 120;
 622   maxHeight = 240;
 623   return TRUE;
 624 }
 625
 626
 627
 628 PINDEX PVideoInput1394DcDevice::GetMaxFrameBytes()
 629 {
 630   if (converter != NULL) {
 631     PINDEX bytes = converter->GetMaxDstFrameBytes();
 632     if (bytes > frameBytes)
 633       return bytes;
 634   }
 635
 636   return frameBytes;
 637 }
 638
 639 BOOL PVideoInput1394DcDevice::GetFrame(PBYTEArray & frame)
 640 {
 641   PINDEX returned;
 642   if (!GetFrameData(frame.GetPointer(GetMaxFrameBytes()), &returned))
 643     return FALSE;
 644
 645   frame.SetSize(returned);
 646   return TRUE;
 647 }
 648
 649
 650 BOOL PVideoInput1394DcDevice::GetFrameDataNoDelay(BYTE * buffer, PINDEX * bytesReturned)
 651 {
 652   if (!IsCapturing()) return FALSE;
 653
 654   PTRACE(3, "We are going to single capture.\n");
 655   if ((UseDMA && dc1394_dma_single_capture(&camera)!=DC1394_SUCCESS) ||
 656       (!UseDMA && dc1394_single_capture(handle,&camera)!=DC1394_SUCCESS)){
 657     PTRACE(1, "dc1394_single_capture() failed.");
 658     return FALSE;
 659   }
 660
 661   PTRACE(3, "single captured, try to convert\n");
 662
 663   // If converting on the fly do it from frame store to output buffer, otherwise do
 664   // straight copy.
 665   if (converter != NULL)
 666     converter->Convert((const BYTE *)camera.capture_buffer, buffer, bytesReturned);
 667   else {
 668     PTRACE(1, "Converter must exist. Something goes wrong.");
 669     return FALSE;
 670   }
 671
 672 #ifdef ESTIMATE_CAPTURE_PERFORMANCE
 673   ++num_captured;
 674   PTime now;
 675   double capturing_time = (double)((now.GetTimestamp()-start_time))/1000000;
 676   ::fprintf(stderr, "time %f, num_captured=%d, fps=%f\n",
 677             capturing_time, num_captured, num_captured/capturing_time);
 678 #endif
 679
 680   if (UseDMA)
 681     dc1394_dma_done_with_buffer(&camera);
 682   return TRUE;
 683 }
 684
 685 BOOL PVideoInput1394DcDevice::GetFrameData(BYTE * buffer, PINDEX * bytesReturned)
 686 {
 687   if(frameRate>0) {
 688     if (msBetweenFrames > capturing_duration)
 689       PThread::Current()->Sleep(msBetweenFrames - capturing_duration);
 690     PTime start;
 691     if ( !GetFrameDataNoDelay(buffer, bytesReturned))
 692       return FALSE;
 693     PTime end;
 694     capturing_duration = (int)((end-start).GetMilliSeconds());
 695     return TRUE;
 696   }
 697   return GetFrameDataNoDelay(buffer,bytesReturned);
 698 }
 699
 700
 701 void PVideoInput1394DcDevice::ClearMapping()
 702 {
 703 }
 704
 705
 706 BOOL PVideoInput1394DcDevice::TestAllFormats()
 707 {
 708   return TRUE;
 709 }
 710
 711 BOOL PVideoInput1394DcDevice::SetColourFormat(const PString & newFormat)
 712 {
 713   if (newFormat != colourFormat) {
 714     return FALSE;
 715   }
 716   return TRUE;
 717 }
 718
 719
 720 BOOL PVideoInput1394DcDevice::SetFrameSize(unsigned width, unsigned height)
 721 {
 722   if ((!(width == 320 && height == 240)) &&
 723       (!(width == 160 && height == 120)))
 724     return FALSE;
 725
 726   frameWidth = width;
 727   frameHeight = height;
 728
 729   if (frameWidth == 320 && frameHeight == 240)
 730     colourFormat = "UYVY422";
 731   else if (frameWidth == 160 && frameHeight == 120)
 732     colourFormat = "UYV444";
 733
 734   frameBytes = PVideoDevice::CalculateFrameBytes(frameWidth, frameHeight, colourFormat);
 735
 736   if (IsCapturing()) {
 737     Stop(); Start();
 738   }
 739
 740   return TRUE;
 741 }
 742
 743
 744 BOOL PVideoInput1394DcDevice::SetFrameSizeConverter(unsigned width, unsigned height,
 745                                          BOOL bScaleNotCrop)
 746 {
 747   if (width == CIFWidth && height == CIFHeight)
 748     SetFrameSize(320, 240);
 749   else if (width == QCIFWidth && height == QCIFHeight)
 750     SetFrameSize(160, 120);
 751   else {
 752     PTRACE(1, width << "x" << height << " is not supported.");
 753     return FALSE;
 754   }
 755
 756   if (converter != NULL)
 757     delete converter;
 758
 759   desiredFrameWidth = width;
 760   desiredFrameHeight = height;
 761
 762   converter = PColourConverter::Create(colourFormat, desiredColourFormat, width, height);
 763   if (converter == NULL) {
 764     PTRACE(1, "Failed to make a converter.");
 765     return FALSE;
 766   }
 767   if (converter->SetSrcFrameSize(frameWidth, frameHeight) == FALSE) {
 768     PTRACE(1, "Failed to set source frame size of a converter.");
 769     return FALSE;
 770   }
 771   return TRUE;
 772 }
 773
 774 BOOL PVideoInput1394DcDevice::SetColourFormatConverter(const PString & colourFmt)
 775 {
 776   if (colourFmt != "YUV420P") {
 777     PTRACE(1, colourFmt << " is unsupported.");
 778     return FALSE;
 779   }
 780   desiredColourFormat = colourFmt;
 781   return SetFrameSizeConverter(desiredFrameWidth, desiredFrameHeight, FALSE);
 782 }
 783
 784
 785
 786 // End Of File ///////////////////////////////////////////////////////////////