开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
hv_dc1394.cpp
资源名称：handvu-beta3.tar.gz　[点击查看]
上传用户：lijia5631
上传日期：2008-11-10
资源大小：1214k
文件大小：20k
源码类别：

视频捕捉/采集

开发平台：

MultiPlatform

hv_dc1394.cpp：源码内容
  1. /**
  2.   * HandVu - a library for computer vision-based hand gesture
  3.   * recognition.
  4.   * Copyright (C) 2004 Mathias Kolsch, matz@cs.ucsb.edu
  5.   *
  6.   * This program is free software; you can redistribute it and/or
  7.   * modify it under the terms of the GNU General Public License
  8.   * as published by the Free Software Foundation; either version 2
  9.   * of the License, or (at your option) any later version.
  10.   *
  11.   * This program is distributed in the hope that it will be useful,
  12.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.   * GNU General Public License for more details.
  15.   *
  16.   * You should have received a copy of the GNU General Public License
  17.   * along with this program; if not, write to the Free Software
  18.   * Foundation, Inc., 59 Temple Place - Suite 330, 
  19.   * Boston, MA  02111-1307, USA.
  20.   *
  21.   * $Id: hv_dc1394.cpp,v 1.7 2005/12/08 23:25:41 matz Exp $
  22. **/
  24. // hv_dc1394.c: frame capture from Linux' libdc1394 interface.  This
  25. // code started from Rev 1.4 of dc1394_multiview.c
  26. //
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30. #include <string>
  31. #include <sys/time.h>
  32. #include <sys/mman.h>
  33. #include <sys/ioctl.h>
  34. #include <sys/types.h>
  35. #include <unistd.h>
  36. #include <signal.h>
  37. #include <X11/Xlib.h>
  38. #include <X11/Xutil.h>
  39. #include <X11/extensions/Xvlib.h>
  40. #include <X11/keysym.h>
  41. #include <getopt.h>
  43. #include <libraw1394/raw1394.h>
  44. #include <libdc1394/dc1394_control.h>
  46. // OpenCV
  47. #include <cxcore.h>
  48. #include <cv.h>
  50. // HandVu
  51. #include "Common.h"
  52. #include "HandVu.h"
  54. /* uncomment the following to drop frames to prevent delays */
  55. #define DROP_FRAMES 1
  56. #define MAX_PORTS 3
  57. #define MAX_CAMERAS 8
  58. #define NUM_BUFFERS 8
  60. /* ok the following constant should be by right included thru in Xvlib.h */
  61. #ifndef XV_YV12
  62. #define XV_YV12 0x32315659
  63. #endif
  65. #ifndef XV_YUY2
  66. #define XV_YUY2 0x32595559
  67. #endif
  69. #ifndef XV_UYVY
  70. #define XV_UYVY 0x59565955
  71. #endif
  74. /* declarations for libdc1394 */
  75. int                       numPorts = MAX_PORTS;
  76. raw1394handle_t           handles[MAX_PORTS];
  77. int                       numCameras = 0;
  78. dc1394_cameracapture      cameras[MAX_CAMERAS];
  79. nodeid_t                 *camera_nodes;
  80. dc1394_feature_set        features;
  82. /* declarations for video1394 */
  83. char                     *device_name = NULL;
  85. /* declarations for Xwindows */
  86. Display                  *display = NULL;
  87. Window                    window = (Window) NULL;
  88. long                      width, height;
  89. long                      device_width, device_height;
  90. int                       connection = -1;
  91. XvImage                  *xv_image = NULL;
  92. XvAdaptorInfo            *info;
  93. long                      format = 0;
  94. GC                        gc;
  96. /* declarations for OpenCV and HandVu */
  97. IplImage                 *iplImages[MAX_CAMERAS];
  98. IplImage                 *readOnlyImg = NULL;
  99. char* conductor_fname = "../config/default.conductor";
  101. bool async_processing = false;
  102. int num_async_bufs = 30;
  103. int m_async_bufID = -1;
  104. IplImage *m_async_image = 0;
  105. bool sync_display = async_processing && true;
  106. IplImage* async_display_image = 0;
  108. /* Other declarations */
  109. long                      frame_length;
  110. long                      frame_free;
  111. int                       frame = 0;
  112. int                       adaptor = -1;
  114. int                       freeze = 0;
  115. int                       average = 0;
  116. int                       fps;
  117. int                       res;
  118. int                       fullscreen;
  119. unsigned char            *frame_buffer = NULL;
  120. int                       verbose = 0;
  123. static struct option      long_options[] = {
  124.   {"device", 1, NULL, 0},
  125.   {"fps", 1, NULL, 0},
  126.   {"res", 1, NULL, 0},
  127.   {"fullscreen", 1, NULL, 0},
  128.   {"conductor", 1, NULL, 0},
  129.   {"help", 0, NULL, 0},
  130.   {NULL, 0, 0, 0}
  131. };
  133. void
  134. get_options(int argc, char *argv[])
  135. {
  136.   int option_index = 0;
  137.   fps = 15;
  138.   res = 2;
  139.   fullscreen = 0;
  141.   while (getopt_long(argc, argv, "", long_options, &option_index) >= 0) {
  142.     if (optarg) {
  143.       switch (option_index) {
  144.         /* case values must match long_options */
  145.       case 0:
  146.         device_name = strdup(optarg);
  147.         break;
  148.       case 1:
  149.         fps = atoi(optarg);
  150.         break;
  151.       case 2:
  152.         res = atoi(optarg);
  153.         break;
  154.       case 3:
  155.         fullscreen = atoi(optarg);
  156.         break;
  157.       case 4:
  158.         conductor_fname = strdup(optarg);
  159.         break;
  160.       }
  161.     }
  162.     if (option_index == 5) {
  163.       printf("n"
  164.              "        %s - multi-cam monitor for libdc1394 and XVideonn"
  165.              "Usage:n"
  166.              "        %s [--fps=[1,3,7,15,30]] [--res=[0,1,2]] [--device=/dev/video1394/x]n"
  167.              "             --fps    - frames per second. default=15,n"
  168.              "                        30 not compatible with --res=2n"
  169.              "             --res    - resolution. 0 = 320x240,n"
  170.              "                        1 = 640x480 YUV4:1:1, 2 = 640x480 RGB8 (default)n"
  171.              "             --device - specifies video1394 device to use (optional)n"
  172.              "                        default = /dev/video1394/<port#>n"
  173.              "             --fullscreenn"
  174.              "             --conductor   - handvu configuration filen"
  175.              "             --help   - prints this messagenn"
  176.              "Keyboard Commands:n"
  177.              "        r = reset detectionn"
  178.              "        u = toggle undistortion on/offn"
  179.              "        0-3 = set overlay leveln"
  180.              "        ESC/q = quitn"
  181.              "        < -or- , = decrease scalen"
  182.              "        > -or- . = increase scalen", argv[0], argv[0]);
  183.       exit(0);
  184.     }
  185.   }
  187. }
  189. /* image format conversion functions */
  191. static inline void
  192. iyu12yuy2(unsigned char *src, unsigned char *dest, int NumPixels)
  193. {
  194.   int                       i = 0, j = 0;
  195.   register int              y0, y1, y2, y3, u, v;
  196.   while (i < NumPixels * 3 / 2) {
  197.     u = src[i++];
  198.     y0 = src[i++];
  199.     y1 = src[i++];
  200.     v = src[i++];
  201.     y2 = src[i++];
  202.     y3 = src[i++];
  204.     dest[j++] = y0;
  205.     dest[j++] = u;
  206.     dest[j++] = y1;
  207.     dest[j++] = v;
  209.     dest[j++] = y2;
  210.     dest[j++] = u;
  211.     dest[j++] = y3;
  212.     dest[j++] = v;
  213.   }
  214. }
  217. /* macro by Bart Nabbe */
  218. #define RGB2YUV(r, g, b, y, u, v)
  219.   y = (9798*r + 19235*g + 3736*b)  / 32768;
  220.   u = (-4784*r - 9437*g + 14221*b)  / 32768 + 128;
  221.   v = (20218*r - 16941*g - 3277*b) / 32768 + 128;
  222.   y = y < 0 ? 0 : y;
  223.   u = u < 0 ? 0 : u;
  224.   v = v < 0 ? 0 : v;
  225.   y = y > 255 ? 255 : y;
  226.   u = u > 255 ? 255 : u;
  227.   v = v > 255 ? 255 : v
  229. static inline void
  230. rgb2yuy2(unsigned char *RGB, unsigned char *YUV, int NumPixels)
  231. {
  232.   int                       i, j;
  233.   register int              y0, y1, u0, u1, v0, v1;
  234.   register int              r, g, b;
  236.   for (i = 0, j = 0; i < 3 * NumPixels; i += 6, j += 4) {
  237.     r = RGB[i + 0];
  238.     g = RGB[i + 1];
  239.     b = RGB[i + 2];
  240.     RGB2YUV(r, g, b, y0, u0, v0);
  241.     r = RGB[i + 3];
  242.     g = RGB[i + 4];
  243.     b = RGB[i + 5];
  244.     RGB2YUV(r, g, b, y1, u1, v1);
  245.     YUV[j + 0] = y0;
  246.     YUV[j + 1] = (u0 + u1) / 2;
  247.     YUV[j + 2] = y1;
  248.     YUV[j + 3] = (v0 + v1) / 2;
  249.   }
  250. }
  252. /* helper functions */
  254. void
  255. set_frame_length(long size, int numCameras)
  256. {
  257.   frame_length = size;
  258.   if (verbose) 
  259.     fprintf(stderr, "Setting frame size to %ld kbn", size / 1024);
  260.   frame_free = 0;
  261.   frame_buffer = (unsigned char *) malloc(size * numCameras);
  262. }
  265. void
  266. capture_frame()
  267. {
  268.   static int                have_warned = 0;
  270.   dc1394_dma_multi_capture(cameras, numCameras);
  272.   if (!freeze && adaptor >= 0) {
  273.     for (int i = 0; i < numCameras; i++) {
  274.       // create OpenCV image
  275.       switch (res) {
  276.       case MODE_640x480_YUV411:
  277. if (!have_warned) {
  278.   have_warned = 1;
  279.   printf("WARNING: no OpenCV conversion available for this formatn");
  280. }
  281.         //iyu12yuy2((unsigned char *) cameras[i].capture_buffer,
  282. //        frame_buffer + (i * frame_length),
  283. //        (device_width * device_height));
  284.         break;
  286.       case MODE_320x240_YUV422:
  287.       case MODE_640x480_YUV422:
  288. if (!have_warned) {
  289.   have_warned = 1;
  290.   printf("WARNING: no OpenCV conversion available for this formatn");
  291. }
  292. //        memcpy(frame_buffer + (i * frame_length),
  293. //     cameras[i].capture_buffer, device_width * device_height * 2);
  294.         break;
  296.       case MODE_640x480_RGB:
  297. // don't convert for OpenCV, this is the correct format
  298. readOnlyImg->imageData = (char *) cameras[i].capture_buffer;
  299.         if (async_processing) {
  300.           if (i==0) {
  301.             hvAsyncGetImageBuffer(&m_async_image, &m_async_bufID);
  302.             cvCopy(readOnlyImg, m_async_image);
  303.           }
  304.         } else {
  305.           cvCopy(readOnlyImg, iplImages[i]);
  306.         }
  307.         break;
  308.       }
  309.       
  310.       if (verbose) {
  311.         CvFont                    font;
  312.         cvInitFont(&font, CV_FONT_VECTOR0, 0.5f /* hscale */ ,
  313.                    0.5f /* vscale */ , 0.1f /*italic_scale */ ,
  314.                    1 /* thickness */ , 8);
  315.         char                      str[256];
  316.         sprintf(str, "camera id: %d", i);
  317.         CvSize                    textsize;
  318.         int                       underline;
  319.         cvGetTextSize(str, &font, &textsize, &underline);
  320.         CvPoint                   pos =
  321.           cvPoint(iplImages[i]->width - textsize.width - 5,
  322.                   textsize.height + 10);
  323.         cvPutText(iplImages[i], str, pos, &font, CV_RGB(0, 255, 0));
  325. //        cvRectangle(iplImages[i], cvPoint(10, 10), cvPoint(100, 100),
  326.         //            cvScalar(255, 255, 255, 255), CV_FILLED, 8, 0);
  327.       }
  328.     }
  329.   }
  331.   for (int i = 0; i < numCameras; i++) {
  332.     dc1394_dma_done_with_buffer(&cameras[i]);
  333.   }
  334. }
  336. void process_frame()
  337. {
  338.   if (!freeze && adaptor >= 0) {
  339.     // main HandVu call
  340.     if (async_processing) {
  341.       hvAsyncProcessFrame(m_async_bufID);
  342.     } else {
  343.       hvProcessFrame(iplImages[0], iplImages[1]);
  344.     }
  345.   }
  346. }
  349. void display_frame()
  350. {
  351.   if (!freeze && adaptor >= 0) {
  352.     // copy into frame buffer for display
  353.     for (int i = 0; i < numCameras; i++) {
  354.       if (sync_display && i==0) {
  355.         rgb2yuy2((unsigned char *) async_display_image->imageData,
  356.                  frame_buffer + (i * frame_length),
  357.                  (device_width * device_height));
  358.       } else {
  359.         rgb2yuy2((unsigned char *) iplImages[i]->imageData,
  360.                  frame_buffer + (i * frame_length),
  361.                  (device_width * device_height));
  362.       }
  363.    }
  365.     xv_image =
  366.       XvCreateImage(display, info[adaptor].base_id, format, 
  367.     (char*) frame_buffer,
  368.                     device_width, device_height * numCameras);
  369.     XvPutImage(display, info[adaptor].base_id, window, gc, xv_image, 0, 0,
  370.                device_width, device_height * numCameras, 0, 0, width, height);
  372.     xv_image = NULL;
  373.   }
  375.   XFlush(display);
  376. }
  379. void displayCallback(IplImage* image, hvAction action)
  380. {
  381.   if (sync_display) {
  382.     cvCopy(image, async_display_image);
  383.   } else {
  384.     cvCopy(image, iplImages[0]);
  385.     display_frame();
  386.   }
  387. }
  390. void
  391. cleanup(void)
  392. {
  393.   int                       i;
  394.   for (i = 0; i < numCameras; i++) {
  395.     dc1394_dma_unlisten(handles[cameras[i].port], &cameras[i]);
  396.     dc1394_dma_release_camera(handles[cameras[i].port], &cameras[i]);
  397.   }
  398.   for (i = 0; i < numPorts; i++)
  399.     raw1394_destroy_handle(handles[i]);
  400.   if ((void *) window != NULL)
  401.     XUnmapWindow(display, window);
  402.   if (display != NULL)
  403.     XFlush(display);
  404.   if (frame_buffer != NULL)
  405.     free(frame_buffer);
  407.   // OpenCV cleanup
  408.   for (i = 0; i < numCameras; i++) {
  409.     cvReleaseImageHeader(&iplImages[i]);
  410.   }
  411. }
  414. void
  415. handle_events()
  416. {
  417.   XEvent                    xev;
  419.   while (XPending(display) > 0) {
  420.     XNextEvent(display, &xev);
  421.     switch (xev.type) {
  422.     case ConfigureNotify:
  423.       width = xev.xconfigure.width;
  424.       height = xev.xconfigure.height;
  425.       //      capture_frame();
  426.       //      process_frame();
  427.       display_frame();
  428.       break;
  429.     case KeyPress:
  430.       switch (XKeycodeToKeysym(display, xev.xkey.keycode, 0)) {
  431.       case XK_q:
  432.       case XK_Q:
  433.       case XK_Escape:
  434.         cleanup();
  435.         exit(0);
  436.         break;
  437.       case XK_r:
  438.       case XK_R:
  439. hvStopRecognition();
  440. hvStartRecognition();
  441.         break;
  442.       case XK_u:
  443.       case XK_U:
  444.         if (hvCanCorrectDistortion()) {
  445.           hvCorrectDistortion(!hvIsCorrectingDistortion());
  446.         }
  447.         break;
  448.       case XK_comma:
  449.       case XK_less:
  450.         width = (width*3)/4;
  451.         height = (height*3)/4;
  452.         XResizeWindow(display, window, width, height);
  453.         //        capture_frame();
  454.         //        process_frame();
  455.         display_frame();
  456.         break;
  457.       case XK_period:
  458.       case XK_greater:
  459.         width = (int) (1.25 * width);
  460.         height = (int) (1.25 * height);
  461.         XResizeWindow(display, window, width, height);
  462.         //        capture_frame();
  463.         //        process_frame();
  464.         display_frame();
  465.         break;
  466.       case XK_0:
  467. hvSetOverlayLevel(0);
  468.         break;
  469.       case XK_1:
  470. hvSetOverlayLevel(1);
  471.         break;
  472.       case XK_2:
  473. hvSetOverlayLevel(2);
  474.         break;
  475.       case XK_3:
  476. hvSetOverlayLevel(3);
  477.         break;
  478.       }
  479.       break;
  480.     }
  481.   }
  482. }
  484. void
  485. QueryXv()
  486. {
  487.   int                       num_adaptors;
  488.   int                       num_formats;
  489.   XvImageFormatValues      *formats = NULL;
  490.   int                       i, j;
  491.   char                      xv_name[5];
  493.   XvQueryAdaptors(display, DefaultRootWindow(display),
  494.   (unsigned int*) &num_adaptors, &info);
  496.   for (i = 0; i < num_adaptors; i++) {
  497.     formats = XvListImageFormats(display, info[i].base_id, &num_formats);
  498.     for (j = 0; j < num_formats; j++) {
  499.       xv_name[4] = 0;
  500.       memcpy(xv_name, &formats[j].id, 4);
  501.       if (formats[j].id == format) {
  502.         if (verbose) 
  503.   fprintf(stderr, "using Xv format 0x%x %s %sn", formats[j].id,
  504.   xv_name,
  505.   (formats[j].format == XvPacked) ? "packed" : "planar");
  506.         if (adaptor < 0)
  507.           adaptor = i;
  508.       }
  509.     }
  510.   }
  511.   XFree(formats);
  512.   if (adaptor < 0)
  513.     fprintf(stderr, "No suitable Xv adaptor found");
  515. }
  518. /* trap ctrl-c */
  519. void
  520. signal_handler(int sig)
  521. {
  522.   signal(SIGINT, SIG_IGN);
  523.   cleanup();
  524.   exit(0);
  525. }
  527. void
  528. set_manual_exposure_gain(int camID, int exposure, int gain)
  529. {
  530.   int                       success =
  531.     dc1394_auto_on_off(handles[cameras[camID].port], cameras[camID].node,
  532.                        FEATURE_EXPOSURE, DC1394_FALSE);
  533.   if (success != DC1394_SUCCESS) {
  534.     fprintf(stderr, "can not turn off camera auto exposuren");
  535.     return;
  536.   }
  538.   success =
  539.     dc1394_set_exposure(handles[cameras[camID].port], cameras[camID].node,
  540.                         exposure);
  541.   if (success != DC1394_SUCCESS) {
  542.     fprintf(stderr, "set_exposure returned %dn", success);
  543.     return;
  544.   }
  546.   success =
  547.     dc1394_set_gain(handles[cameras[camID].port], cameras[camID].node, gain);
  548.   if (success != DC1394_SUCCESS) {
  549.     fprintf(stderr, "set_gain returned %dn", success);
  550.     return;
  551.   }
  552. }
  554. int
  555. main(int argc, char *argv[])
  556. {
  557.   XGCValues                 xgcv;
  558.   long                      background = 0x010203;
  559.   unsigned int              channel;
  560.   unsigned int              speed;
  561.   int                       i, p, cn;
  562.   raw1394handle_t           raw_handle;
  563.   struct raw1394_portinfo   ports[MAX_PORTS];
  565.   get_options(argc, argv);
  566.   /* process options */
  567.   switch (fps) {
  568.   case 1:
  569.     fps = FRAMERATE_1_875;
  570.     break;
  571.   case 3:
  572.     fps = FRAMERATE_3_75;
  573.     break;
  574.   case 15:
  575.     fps = FRAMERATE_15;
  576.     break;
  577.   case 30:
  578.     fps = FRAMERATE_30;
  579.     break;
  580.   case 60:
  581.     fps = FRAMERATE_60;
  582.     break;
  583.   default:
  584.     fps = FRAMERATE_7_5;
  585.     break;
  586.   }
  587.   switch (res) {
  588.   case 1:
  589.     res = MODE_640x480_YUV411;
  590.     device_width = 640;
  591.     device_height = 480;
  592.     format = XV_YUY2;
  593.     break;
  594.   case 2:
  595.     res = MODE_640x480_RGB;
  596.     device_width = 640;
  597.     device_height = 480;
  598.     format = XV_YUY2;
  599.     break;
  600.   default:
  601.     res = MODE_320x240_YUV422;
  602.     device_width = 320;
  603.     device_height = 240;
  604.     format = XV_UYVY;
  605.     break;
  606.   }
  608.   /* get the number of ports (cards) */
  609.   raw_handle = raw1394_new_handle();
  610.   if (raw_handle == NULL) {
  611.     perror("Unable to aquire a raw1394 handlen");
  612.     perror("did you load the drivers?n");
  613.     exit(-1);
  614.   }
  616.   numPorts = raw1394_get_port_info(raw_handle, ports, numPorts);
  617.   raw1394_destroy_handle(raw_handle);
  618.   if (verbose) printf("number of ports = %dn", numPorts);
  620.   /* get dc1394 handle to each port */
  621.   for (p = 0; p < numPorts; p++) {
  622.     int                       camCount;
  624.     handles[p] = dc1394_create_handle(p);
  625.     if (handles[p] == NULL) {
  626.       perror("Unable to aquire a raw1394 handlen");
  627.       perror("did you load the drivers?n");
  628.       cleanup();
  629.       exit(-1);
  630.     }
  632.     /* get the camera nodes and describe them as we find them */
  633.     camera_nodes = dc1394_get_camera_nodes(handles[p], &camCount, verbose);
  635.     /* setup cameras for capture */
  636.     for (i = 0; i < camCount; i++) {
  637.       cameras[numCameras].node = camera_nodes[i];
  639.       if (dc1394_get_camera_feature_set
  640.           (handles[p], cameras[numCameras].node,
  641.            &features) != DC1394_SUCCESS) {
  642.         printf("unable to get feature setn");
  643.       } else if (verbose) {
  644.         dc1394_print_feature_set(&features);
  645.       }
  647.       if (dc1394_get_iso_channel_and_speed
  648.           (handles[p], cameras[numCameras].node, &channel,
  649.            &speed) != DC1394_SUCCESS) {
  650.         printf("unable to get the iso channel numbern");
  651.         cleanup();
  652.         exit(-1);
  653.       }
  655.       if (dc1394_dma_setup_capture
  656.           (handles[p], cameras[numCameras].node, i + 1 /*channel */ ,
  657.            FORMAT_VGA_NONCOMPRESSED, res, SPEED_400, fps, NUM_BUFFERS,
  658.            DROP_FRAMES, device_name,
  659.            &cameras[numCameras]) != DC1394_SUCCESS) {
  660.         fprintf(stderr,
  661.                 "unable to setup camera - check line %d of %s to make suren",
  662.                 __LINE__, __FILE__);
  663.         perror("that the video mode, framerate and format are supportedn");
  664.         printf("by your camera(s)n");
  665.         cleanup();
  666.         exit(-1);
  667.       }
  670.       /*have the camera start sending us data */
  671.       if (dc1394_start_iso_transmission
  672.           (handles[p], cameras[numCameras].node) != DC1394_SUCCESS) {
  673.         perror("unable to start camera iso transmissionn");
  674.         cleanup();
  675.         exit(-1);
  676.       }
  677.       numCameras++;
  678.     }
  679.   }
  681.   fflush(stdout);
  682.   if (numCameras < 1) {
  683.     perror("no cameras found :(n");
  684.     cleanup();
  685.     exit(-1);
  686.   }
  689.   //set_manual_exposure_gain(0, 440, 30);
  691.   switch (format) {
  692.   case XV_YV12:
  693.     set_frame_length(device_width * device_height * 3 / 2, numCameras);
  694.     break;
  695.   case XV_YUY2:
  696.   case XV_UYVY:
  697.     set_frame_length(device_width * device_height * 2, numCameras);
  698.     break;
  699.   default:
  700.     fprintf(stderr, "Unknown format set (internal error)n");
  701.     exit(255);
  702.   }
  704.   /* create OpenCV image wrappers */
  705.   for (cn = 0; cn < MAX_CAMERAS; cn++) {
  706.     if (cn < numCameras) {
  707.       iplImages[cn] =
  708.         cvCreateImage(cvSize(device_width, device_height),
  709.       IPL_DEPTH_8U, 3);
  710.       readOnlyImg =
  711.         cvCreateImageHeader(cvSize(device_width, device_height),
  712.                             IPL_DEPTH_8U, 3);
  713.     } else {
  714.       iplImages[cn] = NULL;
  715.     }
  716.   }
  718.   /* initialize handvu */
  719.   hvInitialize(device_width, device_height);
  720.   hvLoadConductor(string(conductor_fname));
  721.   hvStartRecognition();
  722.   hvSetOverlayLevel(3);
  723.   if (async_processing) {
  724.     hvAsyncSetup(num_async_bufs, displayCallback);
  725.     hvAsyncGetImageBuffer(&m_async_image, &m_async_bufID);
  726.     if (sync_display) async_display_image = cvCloneImage(iplImages[0]);
  727.   }  
  729.   /* make the window */
  730.   display = XOpenDisplay(getenv("DISPLAY"));
  731.   if (display == NULL) {
  732.     fprintf(stderr, "Could not open display "%s"n", getenv("DISPLAY"));
  733.     cleanup();
  734.     exit(-1);
  735.   }
  737.   QueryXv();
  739.   if (adaptor < 0) {
  740.     cleanup();
  741.     exit(-1);
  742.   }
  744.   width = device_width;
  745.   height = device_height * numCameras;
  747.   window =
  748.     XCreateSimpleWindow(display, DefaultRootWindow(display), 0, 0,
  749.                         width, height, 0, WhitePixel(display,
  750.                                                      DefaultScreen
  751.                                                      (display)), background);
  753.   XSelectInput(display, window, StructureNotifyMask | KeyPressMask);
  754.   XMapWindow(display, window);
  755.   connection = ConnectionNumber(display);
  757.   gc = XCreateGC(display, window, 0, &xgcv);
  759.   /* local main event loop */
  760.   while (1) {
  762.     if (async_processing) {
  763.       // asynchronous processing in HandVu
  765.       capture_frame();
  766.       process_frame();
  767.       if (sync_display) display_frame();
  768.       handle_events();
  769.       
  770.     } else {
  771.       // synchronous processing in HandVu
  772.       capture_frame();
  773.       process_frame();
  774.       display_frame();
  775.       handle_events();
  776.     }
  778.     /* XPending */
  780.   }                             /* while not interrupted */
  782.   exit(0);
  783. }