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

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

DVD

开发平台：

Unix_Linux

vidpanel.c：源码内容
  1. /* X Window Video for Linux Two Control Panel Tool
  2.  *
  3.  * For testing a Video for Linux Two driver
  4.  *
  5.  * This program was written by Bill Dirks.
  6.  * This program is in the public domain.
  7.  *
  8.  * gcc -o vidpanel -L/usr/X11R6/lib/ -lXt -lXaw -Wall vidpanel.c
  9.  */
  11. /*  Set these according to your set-up */
  12. #define MY_DEVICE "/dev/video0"
  15. #include <sys/time.h>
  16. #include <sys/types.h>
  17. #include <sys/stat.h>
  18. #include <sys/ioctl.h>
  19. #include <fcntl.h>
  20. #include <unistd.h>
  21. #include <stdlib.h>
  22. #include <stdio.h>
  23. #include <sys/mman.h>
  24. #include <errno.h>
  26. /* These are needed to use the V4L2 driver */
  27. #include <linux/fs.h>
  28. #include <linux/kernel.h>
  29. #include <linux/videodev2.h>  /* Video for Linux Two */
  31. #include <X11/StringDefs.h>
  32. #include <X11/Intrinsic.h>
  33. #include <X11/Xaw/Command.h>
  34. #include <X11/Xaw/Box.h>
  35. #include <X11/Xaw/Scrollbar.h>
  36. #include <X11/Xaw/MenuButton.h>
  37. #include <X11/Xaw/SimpleMenu.h>
  38. #include <X11/Xaw/SmeBSB.h>
  39. #include <X11/Xaw/Toggle.h>
  41. typedef struct
  42. {
  43. int index;
  44. int ctrl_id;
  45. Widget menuitem;
  46. } MenuEntry;
  47. #define MAXMENU 12
  49. typedef struct
  50. {
  51. struct v4l2_queryctrl qc;
  52. Widget box;
  53. Widget label;
  54. Widget widget;
  55. Widget menu;
  56. MenuEntry menuentry[MAXMENU];
  57. } GuiCtrl;
  59. typedef struct
  60. {
  61. XtAppContext xtapp;
  62. Widget w_toplevel;
  63. Widget w_mainbox;
  64. Widget w_menubox;
  65. Widget w_videobox;
  66. Widget w_inputmb;
  67. Widget w_inputmenu;
  68. Widget w_quit;
  69. Widget w_videodefault;
  70. Widget w_device;
  71. } PanelApp;
  74. int vid;
  75. GuiCtrl ctrl[12];
  76. PanelApp app;
  79. #define SLIDERLEN 160
  80. void init_all_controls();
  83. void quit(Widget w, XtPointer client, XtPointer call)
  84. {
  85. exit(0);
  86. }
  88. /*
  89.  *  Scrollbar-type widgets for V4L2 INTEGER controls
  90.  */
  92. void
  93. scroll_jump_proc(Widget w, XtPointer client, XtPointer call)
  94. {
  95. struct v4l2_control vc;
  96. GuiCtrl *ctrl = (GuiCtrl *)client;
  97. float percent = *(float *)call;
  99. vc.id = ctrl->qc.id;
  100. vc.value = ctrl->qc.minimum
  101.  + (int)(percent * (ctrl->qc.maximum - ctrl->qc.minimum + 1));
  102. if (vc.value > ctrl->qc.maximum)
  103. vc.value = ctrl->qc.maximum;
  104. ioctl(vid, VIDIOC_S_CTRL, &vc);
  105. }
  107. void
  108. scroll_proc(Widget w, XtPointer client, XtPointer call)
  109. {
  110. Arg arg[1];
  111. XtArgVal *p;
  112. int d = (int)call;
  113. static float f;
  115. XtVaGetValues(w, XtNtopOfThumb, &f, NULL);
  116. f += (float)d / (float)SLIDERLEN;
  117. if (f < 0) f = 0;
  118. if (f > 1) f = 1;
  120. p = (XtArgVal *)&f;
  121. if (sizeof(float) > sizeof(XtArgVal))
  122. XtSetArg(arg[0], XtNtopOfThumb, &f);
  123. else
  124. XtSetArg(arg[0], XtNtopOfThumb, *p);
  125. XtSetValues(w, arg, 1);
  126. scroll_jump_proc(w, client, &f);/* to change the control */
  127. }
  129. void
  130. init_scroll_control(GuiCtrl *ctrl)
  131. {
  132. struct v4l2_control vc;
  133. int d;
  134. static float f;
  135. Arg arg[1];
  136. XtArgVal *p;
  138. /*  Initialize the thumb position  */
  139. vc.id = ctrl->qc.id;
  140. if (ioctl(vid, VIDIOC_G_CTRL, &vc))
  141. return;
  142. d = (SLIDERLEN * (vc.value - ctrl->qc.minimum)
  143.      + ((ctrl->qc.maximum - ctrl->qc.minimum) >> 1))
  144. / (ctrl->qc.maximum - ctrl->qc.minimum);
  146. f = 0;
  147. p = (XtArgVal *)&f;
  148. if (sizeof(float) > sizeof(XtArgVal))
  149. XtSetArg(arg[0], XtNtopOfThumb, &f);
  150. else
  151. XtSetArg(arg[0], XtNtopOfThumb, *p);
  152. XtSetValues(ctrl->widget, arg, 1);
  153. scroll_proc(ctrl->widget, ctrl, (XtPointer)d);
  154. }
  156. void
  157. add_scroll_control(GuiCtrl *ctrl)
  158. {
  159. ctrl->widget =
  160. XtVaCreateManagedWidget("scroll",
  161. scrollbarWidgetClass,
  162. ctrl->box,
  163. XtNorientation, XtorientHorizontal,
  164. XtNlength, SLIDERLEN,
  165. XtNminimumThumb, 14,
  166. XtNthickness, 18,
  167. NULL);
  168. ctrl->label = 
  169. XtVaCreateManagedWidget("label",
  170. labelWidgetClass, ctrl->box,
  171. XtNlabel, ctrl->qc.name,
  172. XtNborderWidth, 0,
  173. NULL);
  174. XtAddCallback(ctrl->widget, XtNscrollProc, scroll_proc, ctrl);
  175. XtAddCallback(ctrl->widget, XtNjumpProc, scroll_jump_proc, ctrl);
  176. }
  179. /*
  180.  *  Toggle-type widgets for V4L2 BOOLEAN controls
  181.  */
  183. void
  184. boolproc(Widget w, XtPointer client, XtPointer call)
  185. {
  186. GuiCtrl *ctrl = (GuiCtrl *)client;
  187. int d = (int)call;
  188. struct v4l2_control vc;
  190. vc.id = ctrl->qc.id;
  191. vc.value = d;
  192. ioctl(vid, VIDIOC_S_CTRL, &vc);
  193. }
  195. void
  196. init_bool_control(GuiCtrl *ctrl)
  197. {
  198. struct v4l2_control vc;
  199. Arg arg[1];
  201. vc.id = ctrl->qc.id;
  202. if (ioctl(vid, VIDIOC_G_CTRL, &vc))
  203. return;
  204. XtSetArg(arg[0], XtNstate, vc.value);
  205. XtSetValues(ctrl->widget, arg, 1);
  206. }
  208. void
  209. add_bool_control(GuiCtrl *ctrl)
  210. {
  211. ctrl->widget =
  212. XtVaCreateManagedWidget("bool",
  213. toggleWidgetClass,
  214. ctrl->box,
  215. XtNlabel, ctrl->qc.name,
  216. XtNorientation, XtorientHorizontal,
  217. XtNwidth, SLIDERLEN,
  218. NULL);
  219. XtAddCallback(ctrl->widget, XtNcallback, boolproc, ctrl);
  220. }
  223. /*
  224.  *  Menu-type widgets for V4L2 MENU controls
  225.  */
  227. #define VIDIN_ID 1010
  229. void
  230. menu_proc(Widget w, XtPointer client, XtPointer call)
  231. {
  232. MenuEntry *menuentry = (MenuEntry *)client;
  233. struct v4l2_control vc;
  235. if (menuentry->ctrl_id == VIDIN_ID)
  236. {
  237. ioctl(vid, VIDIOC_S_INPUT, menuentry->index);
  238. init_all_controls();
  239. return;
  240. }
  241. vc.id = menuentry->ctrl_id;
  242. vc.value = menuentry->index;
  243. ioctl(vid, VIDIOC_S_CTRL, &vc);
  244. }
  246. void
  247. add_menu_control(GuiCtrl *ctrl)
  248. {
  249. int i, n;
  250. struct v4l2_querymenu qm;
  251. struct v4l2_input vi;
  252. char itemlabel[40];
  253. char menulabel[40];
  255. strcpy(menulabel, ctrl->qc.name);
  256. strcat(menulabel, "...");
  257. ctrl->widget = XtVaCreateManagedWidget(
  258. "menubutton",
  259. menuButtonWidgetClass, ctrl->box,
  260. XtNlabel, menulabel,
  261. XtNmenuName, ctrl->qc.name,
  262. XtNborderWidth, 1,
  263. XtNorientation, XtorientHorizontal,
  264. XtNwidth, SLIDERLEN,
  265. NULL);
  266. ctrl->menu = XtVaCreatePopupShell(
  267. ctrl->qc.name,
  268. simpleMenuWidgetClass, ctrl->widget,
  269. NULL);
  271. for (i = n = 0; i < MAXMENU && i <= ctrl->qc.maximum; ++i)
  272. {
  273. if (ctrl->qc.id == VIDIN_ID)
  274. {
  275. vi.index = i;
  276. if (ioctl(vid, VIDIOC_ENUMINPUT, &vi) != 0)
  277. continue;
  278. strcpy(itemlabel, vi.name);
  279. }
  280. else
  281. {
  282. qm.id = ctrl->qc.id;
  283. qm.index = i;
  284. if (ioctl(vid, VIDIOC_QUERYMENU, &qm) != 0)
  285. break;
  286. strcpy(itemlabel, qm.name);
  287. }
  288. ctrl->menuentry[n].index = i;
  289. ctrl->menuentry[n].ctrl_id = ctrl->qc.id;
  290. ctrl->menuentry[n].menuitem = XtVaCreateManagedWidget(
  291. "item",
  292. smeBSBObjectClass, ctrl->menu,
  293. XtNlabel, itemlabel,
  294. XtNwidth, SLIDERLEN,
  295. NULL);
  296. XtAddCallback(ctrl->menuentry[n].menuitem, 
  297.       XtNcallback, menu_proc, &ctrl->menuentry[n]);
  298. ++n;
  299. }
  300. }
  303. /*
  304.  *  Action Button-type widgets for V4L2 BUTTON controls
  305.  */
  307. void
  308. button_proc(Widget w, XtPointer client, XtPointer call)
  309. {
  310. GuiCtrl *ctrl = (GuiCtrl *)client;
  311. struct v4l2_control vc;
  313. vc.id = ctrl->qc.id;
  314. vc.value = 0;
  315. ioctl(vid, VIDIOC_S_CTRL, &vc);
  316. }
  318. void
  319. add_button_control(GuiCtrl *ctrl)
  320. {
  321. ctrl->widget = XtVaCreateManagedWidget(
  322. ctrl->qc.name,
  323. commandWidgetClass, ctrl->box,
  324. XtNborderWidth, 2,
  325. XtNorientation, XtorientHorizontal,
  326. XtNwidth, SLIDERLEN,
  327. NULL);
  328. XtAddCallback(ctrl->widget, XtNcallback, button_proc, ctrl);
  329. }
  332. /*
  333.  *  Top-level control-handling functions
  334.  */
  336. void
  337. init_control(GuiCtrl *ctrl)
  338. {
  339. if (ctrl->widget == 0)
  340. return;
  341. if (ctrl->qc.type == V4L2_CTRL_TYPE_INTEGER)
  342. init_scroll_control(ctrl);
  343. if (ctrl->qc.type == V4L2_CTRL_TYPE_BOOLEAN)
  344. init_bool_control(ctrl);
  345. }
  347. void
  348. add_control(GuiCtrl *ctrl, Widget parent)
  349. {
  350. ctrl->box =
  351. XtVaCreateManagedWidget("ctrlbox",
  352. boxWidgetClass, parent,
  353. XtNorientation, XtorientHorizontal,
  354. XtNhSpace, 2,
  355. XtNvSpace, 2,
  356. XtNborderWidth, 0,
  357. NULL);
  358. if (ctrl->qc.type == V4L2_CTRL_TYPE_INTEGER)
  359. add_scroll_control(ctrl);
  360. if (ctrl->qc.type == V4L2_CTRL_TYPE_BOOLEAN)
  361. add_bool_control(ctrl);
  362. if (ctrl->qc.type == V4L2_CTRL_TYPE_MENU)
  363. add_menu_control(ctrl);
  364. if (ctrl->qc.type == V4L2_CTRL_TYPE_BUTTON)
  365. add_button_control(ctrl);
  366. init_control(ctrl);
  367. }
  369. void
  370. init_all_controls()
  371. {
  372. int i;
  373. for (i = 0; i < sizeof(ctrl)/sizeof(ctrl[0]); ++i)
  374. init_control(&ctrl[i]);
  375. }
  377. void
  378. default_all_controls()
  379. {
  380. struct v4l2_control vc;
  381. int i;
  383. for (i = 0; i < sizeof(ctrl)/sizeof(ctrl[0]); ++i)
  384. {
  385. if (ctrl[i].widget == 0)
  386. continue;
  387. if (ctrl[i].qc.type == V4L2_CTRL_TYPE_BUTTON)
  388. continue;
  389. vc.id = ctrl[i].qc.id;
  390. vc.value = ctrl[i].qc.default_value;
  391. ioctl(vid, VIDIOC_S_CTRL, &vc);
  392. }
  393. init_all_controls();
  394. }
  396. void
  397. create_video_controls(Widget parent)
  398. {
  399. int i, id, err;
  401. app.w_videobox = XtVaCreateManagedWidget(
  402. "Video Controls",
  403. boxWidgetClass, parent,
  404. XtNorientation, XtorientVertical,
  405. XtNvSpace, 5,
  406. XtNborderWidth, 0,
  407. NULL);
  408. i = 0;
  410. /*  Video Input menu first (handled special)  */
  411. ctrl[i].qc.id = VIDIN_ID;
  412. ctrl[i].qc.type = V4L2_CTRL_TYPE_MENU;
  413. ctrl[i].qc.minimum = 0;
  414. ctrl[i].qc.maximum = 10;
  415. strcpy(ctrl[i].qc.name, "Video Input");
  416. add_control(&ctrl[i], app.w_videobox);
  417. ++i;
  418. for (id = 0; id < 100; ++id)
  419. {
  420. ctrl[i].qc.id = V4L2_CID_BASE + id;
  421. err = ioctl(vid, VIDIOC_QUERYCTRL, &ctrl[i].qc);
  422. if (err && errno == EDOM)
  423. break;
  424. if (err == 0 && ctrl[i].qc.category == V4L2_CTRL_CAT_VIDEO)
  425. {
  426. add_control(&ctrl[i], app.w_videobox);
  427. ++i;
  428. }
  429. }
  430. for (id = 0; id < 100; ++id)
  431. {
  432. ctrl[i].qc.id = V4L2_CID_PRIVATE_BASE + id;
  433. err = ioctl(vid, VIDIOC_QUERYCTRL, &ctrl[i].qc);
  434. if (err && errno == EDOM)
  435. break;
  436. if (err == 0 && ctrl[i].qc.category == V4L2_CTRL_CAT_VIDEO)
  437. {
  438. add_control(&ctrl[i], app.w_videobox);
  439. ++i;
  440. }
  441. }
  442. app.w_videodefault = XtVaCreateManagedWidget(
  443. "Default All Controls",
  444. commandWidgetClass, app.w_videobox,
  445. XtNborderWidth, 2,
  446. XtNorientation, XtorientHorizontal,
  447. XtNwidth, SLIDERLEN,
  448. NULL);
  449. XtAddCallback(app.w_videodefault, 
  450.       XtNcallback, default_all_controls, 
  451.       NULL);
  454. }
  458. /*
  459.  *  Main
  460.  */
  461. int
  462. main(int argc, char *argv[])
  463. {
  464. char my_device[64];
  465. struct v4l2_capability caps;
  466. char device_label[96];
  469. /*-> Put in the device node name */
  470. strcpy(my_device, MY_DEVICE);
  471. if (argc >= 2)
  472. strcpy(my_device, argv[1]);
  473. vid = open(my_device, O_NONCAP);
  474. if (vid < 0)
  475. {
  476. printf("No video device "%s"n", my_device);
  477. return 1;
  478. }
  479. ioctl(vid, VIDIOC_QUERYCAP, &caps);
  482. app.w_toplevel = XtAppInitialize(
  483. &app.xtapp, "V4L2 Control Panel", NULL, 0,
  484. &argc, argv, NULL, NULL, 0);
  486. app.w_mainbox = XtVaCreateManagedWidget(
  487. "mainbox",
  488. boxWidgetClass, app.w_toplevel,
  489. XtNorientation, XtorientVertical,
  490. XtNhSpace, 0,
  491. XtNvSpace, 0,
  492. NULL);
  494. sprintf(device_label, "%s: %s", my_device, caps.name);
  495. app.w_device = XtVaCreateManagedWidget(
  496. "device",
  497. labelWidgetClass, app.w_mainbox,
  498. XtNlabel, device_label,
  499. XtNborderWidth, 0,
  500. NULL);
  502. app.w_menubox = XtVaCreateManagedWidget(
  503. "menubox",
  504. boxWidgetClass, app.w_mainbox,
  505. XtNorientation, XtorientHorizontal,
  506. XtNhSpace, 7,
  507. XtNvSpace, 2,
  508. XtNborderWidth, 0,
  509. NULL);
  511. app.w_quit = XtVaCreateManagedWidget(
  512. "Quit!",
  513. commandWidgetClass, app.w_menubox,
  514. XtNborderWidth, 2,
  515. NULL);
  516. XtAddCallback(app.w_quit, XtNcallback, quit, NULL);
  518. create_video_controls(app.w_mainbox);
  520. XtRealizeWidget(app.w_toplevel);
  521. XtAppMainLoop(app.xtapp);
  522. return 0;
  523. }