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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
xcaptest.c
资源名称：dvd-munitions.tar.gz　[点击查看]
上传用户：aoeyumen
上传日期：2007-01-06
资源大小：3329k
文件大小：15k
源码类别：

DVD

开发平台：

Unix_Linux

xcaptest.c：源码内容
  1. /* X Window Video Capture Testing Tool
  2.  *
  3.  * For testing a Video for Linux Two video capture driver
  4.  *
  5.  * This program was written by Bill Dirks.
  6.  * This program is in the public domain.
  7.  *
  8.  * gcc -o xcaptest -L/usr/X11R6/lib/ -lXt -lXaw -Wall xcaptest.c
  9.  *
  10.  * ./xcaptest [-b] [device-node]
  11.  *
  12.  * -b The X Window screen is 32 bits-per-pixel. */
  14. /*  This program does not properly detect when the X Windows desktop is
  15.  *  32 bits per pixel. (Some X functions use a value of 24 for the depth
  16.  *  when it is really 32 for reasons I don't understand.) As a workaround,
  17.  *  if you are running a 32-bpp X Windows screen, use -b on the command
  18.  *  line, or uncomment this line:  */
  19. //#define X_DEPTH  32
  22. /*  Set these according to your capture device set-up */
  23. #define MY_DEVICE "/dev/video0"
  24. //#define MY_STD   "NTSC" /*-> "PAL" or "NTSC" */
  25. #define MY_WIDTH  704
  26. #define MY_HEIGHT 240
  27. #define MY_INPUT  0
  29. /*  MY_PIXELFORMAT should match your X Window screen mode  */
  30. /*  If MY_PIXELFORMAT is not defined, capturing will be set to the
  31.     screen format automatically (I hope)  */
  32. //#define MY_PIXELFORMAT V4L2_PIX_FMT_BGR32
  33. /* V4L2_PIX_FMT_YUYV */
  34. /* V4L2_PIX_FMT_GREY */
  35. /* V4L2_PIX_FMT_YUV420 */
  36. /* V4L2_PIX_FMT_RGB555 */
  37. /* V4L2_PIX_FMT_RGB565 */
  38. /* V4L2_PIX_FMT_BGR24 */
  39. /* V4L2_PIX_FMT_BGR32 */
  41. /*  Uncomment the following to test stuff  */
  42. #define TEST_INPUTS      /* enumerate the inputs */
  43. #define TEST_FORMATS     /* enumerate the image formats */
  44. #define TEST_CONTROLS    /* enumerate the controls */
  45. #define TEST_CAPTURE     /* test video capture */
  46. #define TEST_STREAMING   /* test streaming capture */
  47. //#define TEST_FRAMERATE 400000  /* 10million / frames-per-second */
  50. #define STREAMBUFS 2
  52. #include <sys/time.h>
  53. #include <sys/types.h>
  54. #include <sys/stat.h>
  55. #include <sys/ioctl.h>
  56. #include <fcntl.h>
  57. #include <unistd.h>
  58. #include <stdlib.h>
  59. #include <stdio.h>
  60. #include <sys/mman.h>
  61. #include <errno.h>
  62. #define max(a,b) ((a) > (b) ? (a) : (b))
  64. /* These are needed to use the Videum driver */
  65. #include <linux/fs.h>
  66. #include <linux/kernel.h>
  67. #include <linux/videodev2.h>  /* Video for Linux Two */
  69. #include <X11/StringDefs.h>
  70. #include <X11/Intrinsic.h>
  71. #include <X11/Xaw/Box.h>
  72. #include <X11/Xaw/Command.h>
  73. #include <X11/Xaw/Porthole.h>
  74. #include <X11/Xaw/MenuButton.h>
  75. #include <X11/Xaw/SimpleMenu.h>
  76. #include <X11/Xaw/SmeBSB.h>
  79. typedef struct tag_vimage
  80. {
  81. struct v4l2_buffer vidbuf;
  82. char *data;
  83. XImage *ximage;
  84. } VIMAGE;
  86. VIMAGE vimage[STREAMBUFS];
  87. int vid;
  88. int x_depth;
  89. XtAppContext app;
  90. Widget w_toplevel;
  91. Widget w_topbox;
  92. Widget w_menubox;
  93. Widget w_quit;
  94. Widget w_viewport;
  95. Widget w_stdbutton;
  96. Widget w_stdmenu;
  97. struct v4l2_format fmt;
  99. void resize_window(Widget widget, XtPointer client_data, XEvent *event, Boolean *d);
  101. __u32 frame_buffer_format(Display *d, Window w)
  102. {
  103. int x;
  104. int y;
  105. int width;
  106. int height;
  107. int depth;
  108. int border;
  109. Window root;
  110. __u32 fbf = V4L2_PIX_FMT_RGB565;
  112. if (x_depth == 0)
  113. {
  114. #ifdef X_DEPTH
  115. x_depth = X_DEPTH;
  116. #else
  118. XWindowAttributes wa;
  119. XGetGeometry(d, w, &root, &x, &y, &width, &height, &border, &depth);
  120. XGetWindowAttributes(d, w, &wa);
  121. x_depth = wa.depth;
  122. #endif
  123. }
  124. if (x_depth == 15)
  125. fbf = V4L2_PIX_FMT_RGB555;
  126. else if (x_depth == 16)
  127. fbf = V4L2_PIX_FMT_RGB565;
  128. else if (x_depth == 24)
  129. fbf = V4L2_PIX_FMT_BGR24;
  130. else if (x_depth == 32)
  131. fbf = V4L2_PIX_FMT_BGR32;
  132. else
  133. {
  134. printf("Unrecognized display depth. You may get an "
  135.        "X Windows error.n");
  136. }
  137. return fbf;
  138. }
  141. void stop_capturing()
  142. {
  143. #ifdef TEST_STREAMING
  144. int i;
  145. #endif
  147. if (vid >= 0)
  148. {
  149. #ifdef TEST_STREAMING
  150. ioctl(vid, VIDIOC_STREAMOFF, V4L2_BUF_TYPE_CAPTURE);
  151. for (i = 0; i < STREAMBUFS; ++i)
  152. {
  153. if (vimage[i].data)
  154. munmap(vimage[i].data, 
  155.        vimage[i].vidbuf.length);
  156. vimage[i].data = NULL;
  157. if (vimage[i].ximage)
  158. // memory leak, but XDestroyImage always segfaults...
  159. // XDestroyImage(vimage[i].ximage);
  160. vimage[i].ximage = NULL;
  161. }
  162. #else
  163. if (vimage[0].data)
  164. free(vimage[0].data);
  165. vimage[0].data = NULL;
  166. if (vimage[0].ximage)
  167. // memory leak, but XDestroyImage always segfaults...
  168. // XDestroyImage(vimage[0].ximage);
  169. vimage[0].ximage = NULL;
  170. #endif
  171. }
  172. }
  175. int start_capturing(int width, int height)
  176. {
  177. struct v4l2_requestbuffers req;
  178. int err;
  179. int i;
  180. Arg arg[2];
  182. #ifdef MY_PIXELFORMAT
  183. fmt.pixelformat = MY_PIXELFORMAT;
  184. #else
  185. fmt.pixelformat = frame_buffer_format(XtDisplay(w_viewport),
  186. DefaultRootWindow(XtDisplay(w_viewport)));
  187. #endif
  188. fmt.width = width;
  189. fmt.height = height;
  190. err = ioctl(vid, VIDIOC_S_FMT, &fmt);
  191. if (err)
  192. {
  193. printf("S_FMT returned error %dn",errno);
  194. return 1;
  195. }
  196. fprintf(stderr, "new width = %d->%d height %d->%dn", width, fmt.width, height, fmt.height);
  197. #ifdef NEVER
  198. fmt.width = width & ~3;
  199. fmt.height = height & ~1;
  200. err = ioctl(vid, VIDIOC_S_FMT, &fmt);
  201. if (err)
  202. {
  203. printf("S_FMT returned error %dn",errno);
  204. return 1;
  205. }
  206. #endif
  208. req.count = 1;
  209. #ifdef TEST_STREAMING
  210. req.count = STREAMBUFS;
  211. req.type = V4L2_BUF_TYPE_CAPTURE;
  212. err = ioctl(vid, VIDIOC_REQBUFS, &req);
  213. if (err < 0 || req.count < 1)
  214. {
  215. printf("REQBUFS returned error %d, count %dn",
  216.        errno,req.count);
  217. return 1;
  218. }
  219. for (i = 0; i < req.count; ++i)
  220. {
  221. vimage[i].vidbuf.index = i;
  222. vimage[i].vidbuf.type = V4L2_BUF_TYPE_CAPTURE;
  223. err = ioctl(vid, VIDIOC_QUERYBUF, &vimage[i].vidbuf);
  224. if (err < 0)
  225. {
  226. printf("QUERYBUF returned error %dn",errno);
  227. return 1;
  228. }
  229. vimage[i].data = mmap(0, vimage[i].vidbuf.length, PROT_READ,
  230.       MAP_SHARED, vid, 
  231.       vimage[i].vidbuf.offset);
  232. if ((int)vimage[i].data == -1)
  233. {
  234. printf("mmap() returned error %dn", errno);
  235. return 1;
  236. }
  237. }
  238. #else
  239. vimage[0].data = malloc(fmt.sizeimage);
  240. if (vimage[0].data == NULL)
  241. {
  242. printf("malloc(%d) failedn", fmt.sizeimage);
  243. return 1;
  244. }
  245. #endif
  247. #ifdef TEST_STREAMING
  248. for (i = 0; i < req.count; ++i)
  249. if ((err = ioctl(vid, VIDIOC_QBUF, &vimage[i].vidbuf)))
  250. {
  251. printf("QBUF returned error %dn",errno);
  252. return 1;
  253. }
  254. err = ioctl(vid, VIDIOC_STREAMON, vimage[0].vidbuf.type);
  255. if (err)
  256. printf("STREAMON returned error %dn",errno);
  257. #endif
  258. fprintf(stderr, "default visual=%xn", DefaultVisual(XtDisplay(w_viewport), 0));
  259. for (i = 0; i < req.count; ++i)
  260. {
  261. vimage[i].ximage = XCreateImage(
  262. XtDisplay(w_viewport),
  263. DefaultVisual(XtDisplay(w_viewport), 0),
  264. (x_depth == 32) ? 24 : x_depth,
  265. ZPixmap,
  266. 0, vimage[i].data,
  267. #ifndef NEVER
  268. fmt.width, fmt.height, 
  269. #else
  270. 704, 240,
  271. #endif
  272. 16, 0);
  273. if (vimage[i].ximage == NULL)
  274. {
  275. printf("No XImagen");
  276. return 1;
  277. }
  278. }
  279. #ifdef NEVER
  280. XtSetArg(arg[0], XtNwidth, max(160, fmt.width));
  281. XtSetArg(arg[1], XtNheight, max(120, fmt.height));
  282. #endif
  283. XtSetArg(arg[0], XtNwidth, max(720, fmt.width));
  284. XtSetArg(arg[1], XtNheight, max(240, fmt.height));
  285. XtSetValues(w_viewport, arg, 2);
  287. XtSetValues(XtParent(w_viewport), arg, 2);
  289. #ifdef NEVER
  290. fmt.width = width & ~3;
  291. fmt.height = height & ~1;
  292. err = ioctl(vid, VIDIOC_S_FMT, &fmt);
  293. #endif
  294. return 0;
  295. }
  297. void quit(Widget w, XtPointer client, XtPointer call)
  298. {
  299. struct v4l2_performance perf;
  301. if (vid >= 0)
  302. {
  303. if (ioctl(vid, VIDIOC_G_PERF, &perf) != 0)
  304. printf("G_PERF returned error code %dn",errno);
  305. else
  306. printf("Captured %d framesn", perf.frames);
  307. stop_capturing();
  308. close(vid);
  309. }
  310. exit(0);
  311. }
  314. typedef struct
  315. {
  316. Widget w_item;
  317. struct v4l2_standard std;
  318. } StdMenuItem;
  319. #define MAXSTDS 10
  320. StdMenuItem stditem[MAXSTDS];
  322. void
  323. std_menu_callback(Widget w, XtPointer client, XtPointer call)
  324. {
  325. StdMenuItem *smi = (StdMenuItem *)client;
  327. stop_capturing();
  328. ioctl(vid, VIDIOC_S_STD, &smi->std);
  329. start_capturing(fmt.width, fmt.height);
  330. }
  334. void printctrl(struct v4l2_queryctrl *qc)
  335. {
  336. printf("  %-12s %-6s %8d %8d %7d %8d  %sn",
  337.        qc->name,
  338.        (qc->type == V4L2_CTRL_TYPE_MENU) ? "(menu)" : 
  339.        (qc->type == V4L2_CTRL_TYPE_BOOLEAN) ? "(bool)" :
  340.        "(int)",
  341.        qc->minimum, qc->maximum, qc->step, qc->default_value,
  342.        qc->catname);
  343. }
  345. int
  346. main(int argc, char *argv[])
  347. {
  348. char my_device[64];
  349. int err;
  350. int i;
  351. struct v4l2_capability cap;
  352. struct v4l2_captureparm parm;
  353. #ifdef MY_STD
  354. struct v4l2_standard std;
  355. #endif
  356. int input;
  357. #ifdef TEST_CONTROLS
  358. struct v4l2_queryctrl qc;
  359. #endif
  360. #ifdef TEST_STREAMING
  361. fd_set rdset;
  362. struct timeval timeout;
  363. int n;
  364. #endif
  365. GC imagegc;
  366. struct v4l2_buffer tempbuf;
  367. int argi;
  370. /*-> Put in the device node name */
  371. strcpy(my_device, MY_DEVICE);
  372. for (argi = 1; argi < argc; ++argi)
  373. {
  374. if (strcmp(argv[argi], "-b") == 0)
  375. {
  376. x_depth = 32;
  377. continue;
  378. }
  379. strcpy(my_device, argv[argi]);
  380. }
  382. vid = open(my_device, O_RDONLY);
  383. if (vid < 0)
  384. {
  385. printf("No video device "%s"n", my_device);
  386. return 1;
  387. }
  389. err = ioctl(vid, VIDIOC_QUERYCAP, &cap);
  390. if (err)
  391. {
  392. printf("QUERYCAP returned error %dn", errno);
  393. return 1;
  394. }
  395. printf("Device node:  %sn", my_device);
  396. printf("Device:       %sn", cap.name);
  397. printf("Capabilities:");
  398. if (cap.flags & V4L2_FLAG_READ)       printf(" capture via read();");
  399. if (cap.flags & V4L2_FLAG_STREAMING)  printf(" streaming capture;");
  400. if (cap.flags & V4L2_FLAG_PREVIEW)    printf(" automatic preview;");
  401. if (cap.flags & V4L2_FLAG_SELECT)     printf(" select() call;");
  402. if (cap.flags & V4L2_FLAG_TUNER)      printf(" tuner;");
  403. if (cap.flags & V4L2_FLAG_MONOCHROME) printf(" monochrome only;");
  404. printf("n");
  405. if (cap.type != V4L2_TYPE_CAPTURE)
  406. {
  407. printf("Not a capture device.n");
  408. return 1;
  409. }
  411. #ifdef TEST_INPUTS
  412. printf("Video inputs on this device:n");
  413. for (i = 0, err = 0; err == 0; ++i)
  414. {
  415. struct v4l2_input inp;
  416. inp.index = i;
  417. err = ioctl(vid, VIDIOC_ENUMINPUT, &inp);
  418. if (!err)
  419. printf("  %d: "%s" is a%s, %s audion", i,
  420.        inp.name,
  421.        (inp.type == V4L2_INPUT_TYPE_TUNER) ?
  422.        " TV tuner" : "n analog input",
  423.        (inp.capability & V4L2_INPUT_CAP_AUDIO) ? 
  424.        "has" : "no"
  425. );
  426. }
  427. #ifdef MY_INPUT
  428. input = MY_INPUT;
  429. err = ioctl(vid, VIDIOC_S_INPUT, input);
  430. if (err)
  431. printf("S_INPUT returned error %dn",errno);
  432. #endif
  433. #endif
  435. printf("Video standards supported:");
  436. for (i = 0, err = 0; err == 0; ++i)
  437. {
  438. struct v4l2_enumstd estd;
  439. estd.index = i;
  440. err = ioctl(vid, VIDIOC_ENUMSTD, &estd);
  441. if (!err)
  442. {
  443. printf("%c %s", i?',':' ', estd.std.name);
  444. #ifdef MY_STD
  445. if (strcmp(MY_STD, estd.std.name) == 0)
  446. std = estd.std;
  447. #endif
  448. }
  449. }
  450. printf("n");
  452. #ifdef TEST_FORMATS
  453. printf("Video capture image formats supported:n");
  454. for (i = 0, err = 0; err == 0; ++i)
  455. {
  456. struct v4l2_fmtdesc fmtd;
  457. fmtd.index = i;
  458. err = ioctl(vid, VIDIOC_ENUM_CAPFMT, &fmtd);
  459. if (!err)
  460. printf("  %d: %s  (%s)n", i,
  461.        fmtd.description,
  462.        (fmtd.flags & V4L2_FMT_FLAG_COMPRESSED) ?
  463. "compressed" : "uncompressed");
  464. }
  465. #endif
  467. #ifdef TEST_CONTROLS
  468. printf("Controls supported:n");
  469. printf("  Label        type    Minimum  Maximum    Step  Default"
  470.        "  Categoryn");
  471. qc.id = V4L2_CID_BRIGHTNESS;
  472. if (ioctl(vid, VIDIOC_QUERYCTRL, &qc) == 0)
  473. printctrl(&qc);
  474. qc.id = V4L2_CID_CONTRAST;
  475. if (ioctl(vid, VIDIOC_QUERYCTRL, &qc) == 0)
  476. printctrl(&qc);
  477. qc.id = V4L2_CID_SATURATION;
  478. if (ioctl(vid, VIDIOC_QUERYCTRL, &qc) == 0)
  479. printctrl(&qc);
  480. qc.id = V4L2_CID_HUE;
  481. if (ioctl(vid, VIDIOC_QUERYCTRL, &qc) == 0)
  482. printctrl(&qc);
  483. #endif
  485. #ifndef TEST_CAPTURE
  486. return 0;
  487. #endif
  489. #ifdef TEST_STREAMING
  490. if (!(cap.flags & V4L2_FLAG_STREAMING))
  491. {
  492. printf("Device does not support streaming capture.n");
  493. return 1;
  494. }
  495. #else
  496. if (!(cap.flags & V4L2_FLAG_READ))
  497. {
  498. printf("Device does not support the read() call.n");
  499. return 1;
  500. }
  501. #endif
  503. ioctl(vid, VIDIOC_G_PARM, &parm);
  504. #ifdef TEST_FRAMERATE
  505. parm.capturemode |= V4L2_CAP_TIMEPERFRAME;
  506. parm.timeperframe = TEST_FRAMERATE;
  507. #endif
  508. err = ioctl(vid, VIDIOC_S_PARM, &parm);
  509. if (err)
  510. printf("S_PARM returned error %dn",errno);
  512. #ifdef MY_STD
  513. err = ioctl(vid, VIDIOC_S_STD, &std);
  514. if (err)
  515. printf("S_STD returned error %dn",errno);
  516. #endif
  518. ioctl(vid, VIDIOC_G_FMT, &fmt);
  520. w_toplevel = XtAppInitialize(&app, "xvideum", NULL, 0,
  521.      &argc, argv, NULL, NULL, 0);
  522. w_topbox = XtVaCreateManagedWidget(
  523. "topbox",
  524. boxWidgetClass, w_toplevel,
  525. XtNorientation, XtorientVertical,
  526. XtNborderWidth, 0,
  527. XtNhSpace, 0,
  528. XtNvSpace, 0,
  529. NULL);
  530. w_menubox = XtVaCreateManagedWidget(
  531. "menubox",
  532. boxWidgetClass, w_topbox,
  533. XtNorientation, XtorientHorizontal,
  534. XtNborderWidth, 0,
  535. XtNhSpace, 4,
  536. XtNvSpace, 1,
  537. NULL);
  539. w_stdbutton = XtVaCreateManagedWidget(
  540. "menubutton",
  541. menuButtonWidgetClass, w_menubox,
  542. XtNlabel, "Standard...",
  543. XtNmenuName, "standard",
  544. XtNborderWidth, 0,
  545. NULL);
  546. w_stdmenu = XtVaCreatePopupShell(
  547. "standard", /* same as XtNmenuName and static */
  548. simpleMenuWidgetClass, w_stdbutton,
  549. NULL);
  550. for (i = 0; ; ++i)
  551. {
  552. struct v4l2_enumstd estd;
  553. estd.index = i;
  554. err = ioctl(vid, VIDIOC_ENUMSTD, &estd);
  555. if (err)
  556. break;
  557. stditem[i].std = estd.std;
  558. stditem[i].w_item = XtVaCreateManagedWidget(
  559. estd.std.name,
  560. smeBSBObjectClass, w_stdmenu,
  561. XtNlabel, estd.std.name,
  562. NULL);
  563. XtAddCallback(stditem[i].w_item,
  564.       XtNcallback, std_menu_callback,
  565.       &stditem[i]);
  566. }
  567. w_quit = XtVaCreateManagedWidget(
  568. "Quit!",
  569. commandWidgetClass, w_menubox,
  570. XtNborderWidth, 0,
  571. NULL);
  572. XtAddCallback(w_quit, XtNcallback, quit, NULL);
  573. w_viewport = XtVaCreateManagedWidget(
  574. "port",
  575. portholeWidgetClass, w_topbox,
  576. XtNwidth, MY_WIDTH,
  577. XtNheight, MY_HEIGHT,
  578. NULL);
  579. XtAddEventHandler(XtParent(w_viewport), StructureNotifyMask, True, resize_window, NULL);
  580. XtRealizeWidget(w_toplevel);
  581. imagegc = XCreateGC(
  582. XtDisplay(w_viewport),
  583. XtWindow(w_viewport),
  584. 0, NULL);
  585. if (imagegc == NULL)
  586. {
  587. printf("XCreateGC failed.n");
  588. return 1;
  589. }
  591. if (start_capturing(MY_WIDTH, MY_HEIGHT))
  592. {
  593. return 1;
  594. }
  596. printf("Capturing %dx%dx%d "%4.4s" imagesn", 
  597.        fmt.width, fmt.height,
  598.        fmt.depth, (char *)&fmt.pixelformat);
  599. printf("Images are %d bytes eachn", fmt.sizeimage);
  601. for (;;)
  602. {
  603. XEvent event;
  605. err = 0;
  606. if (XtIsRealized(w_viewport))
  607. {
  608. #if defined(TEST_STREAMING) || defined (TEST_SELECT)
  609. FD_ZERO(&rdset);
  610. FD_SET(vid, &rdset);
  611. timeout.tv_sec = 1;
  612. timeout.tv_usec = 0;
  613. n = select(vid + 1, &rdset, NULL, NULL, &timeout);
  614. err = -1;
  615. if (n == -1)
  616. fprintf(stderr, "select error.n");
  617. else if (n == 0)
  618. fprintf(stderr, "select timeoutn");
  619. else if (FD_ISSET(vid, &rdset))
  620. err = 0;
  621. #endif
  622. if (err == 0)
  623. {
  624. #ifdef TEST_STREAMING
  625. tempbuf.type = vimage[0].vidbuf.type;
  626. err = ioctl(vid, VIDIOC_DQBUF, &tempbuf);
  627. if (err)
  628. printf("DQBUF returned error %dn",
  629.        errno);
  630. #else
  631. tempbuf.index = 0;
  632. read(vid, vimage[0].data, fmt.sizeimage);
  633. #endif
  634. XPutImage(XtDisplay(w_viewport),
  635.   XtWindow(w_viewport),
  636.   imagegc,
  637.   vimage[tempbuf.index].ximage,
  638.   0, 0,
  639.   0, 0,
  640.   fmt.width, fmt.height);
  642. #ifdef TEST_STREAMING
  643. err = ioctl(vid, VIDIOC_QBUF, &tempbuf);
  644. if (err)
  645. printf("QBUF returned error %dn",
  646.        errno);
  647. #endif
  648. XFlush(XtDisplay(w_viewport));
  649. }
  650. }
  651. else
  652. {
  653. XtAppPeekEvent(app, &event);
  654. }
  656. while (XtAppPending(app))
  657. {
  658. XtAppNextEvent(app, &event);
  659. switch (event.type)
  660. {
  661. default:
  662. break;
  663. }
  664. XtDispatchEvent(&event);
  665. }
  666. }
  667. return 0;
  668. }
  670. void
  671. resize_window(Widget widget, XtPointer client_data, XEvent *event, Boolean *d)
  672. {
  673. switch(event->type) {
  674. case ConfigureNotify:
  675. fprintf(stderr, "window size = %d x %dn",
  676. event->xconfigure.width,
  677. event->xconfigure.height);
  678. stop_capturing();
  679. start_capturing(event->xconfigure.width, event->xconfigure.height);
  680. break;
  681. }
  683. }