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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
SDL_sysjoystick.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：8k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

SDL_sysjoystick.c：源码内容
  1. /*
  2.     SDL - Simple DirectMedia Layer
  3.     Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002  Sam Lantinga
  5.     This library is free software; you can redistribute it and/or
  6.     modify it under the terms of the GNU Library General Public
  7.     License as published by the Free Software Foundation; either
  8.     version 2 of the License, or (at your option) any later version.
  10.     This library is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.     Library General Public License for more details.
  15.     You should have received a copy of the GNU Library General Public
  16.     License along with this library; if not, write to the Free
  17.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.     Sam Lantinga
  20.     slouken@devolution.com
  21. */
  23. /*
  24.  * Joystick driver for the uhid(4) interface found in OpenBSD,
  25.  * NetBSD and FreeBSD.
  26.  *
  27.  * Maintainer: <vedge at csoft.org>
  28.  */
  30. #ifdef SAVE_RCSID
  31. static char rcsid =
  32.  "@(#) $Id $";
  33. #endif
  35. #include <stdio.h>
  36. #include <stdlib.h>
  37. #include <unistd.h>
  38. #include <fcntl.h>
  39. #include <string.h>
  40. #include <errno.h>
  42. #include <dev/usb/usb.h>
  43. #include <dev/usb/usbhid.h>
  44. #include <usbhid.h>
  46. #include "SDL_error.h"
  47. #include "SDL_joystick.h"
  48. #include "SDL_sysjoystick.h"
  49. #include "SDL_joystick_c.h"
  51. #define MAX_UHID_JOYS 4
  52. #define MAX_JOY_JOYS 2
  53. #define MAX_JOYS (MAX_UHID_JOYS + MAX_JOY_JOYS)
  55. struct report {
  56. struct usb_ctl_report *buf; /* Buffer */
  57. size_t size; /* Buffer size */
  58. int rid; /* Report ID */
  59. enum {
  60. SREPORT_UNINIT,
  61. SREPORT_CLEAN,
  62. SREPORT_DIRTY
  63. } status;
  64. };
  66. static struct {
  67. int uhid_report;
  68. enum hid_kind kind;
  69. const char *name;
  70. } const repinfo[] = {
  71. { UHID_INPUT_REPORT, hid_input, "input" },
  72. { UHID_OUTPUT_REPORT, hid_output, "output" },
  73. { UHID_FEATURE_REPORT, hid_feature, "feature" }
  74. };
  76. enum {
  77. REPORT_INPUT = 0,
  78. REPORT_OUTPUT = 1,
  79. REPORT_FEATURE = 2
  80. };
  82. enum {
  83. JOYAXE_X,
  84. JOYAXE_Y,
  85. JOYAXE_Z,
  86. JOYAXE_SLIDER,
  87. JOYAXE_WHEEL
  88. };
  90. struct joystick_hwdata {
  91. int fd;
  92. char *path;
  93. enum {
  94. BSDJOY_UHID, /* uhid(4) */
  95. BSDJOY_JOY /* joy(4) */
  96. } type;
  97. struct report_desc *repdesc;
  98. struct report inreport;
  99. #if 0
  100. int axismin[];
  101. int axismax[];
  102. #endif
  103. };
  105. static char *joynames[MAX_JOYS];
  106. static char *joydevnames[MAX_JOYS];
  108. static int report_alloc(struct report *, struct report_desc *, int);
  109. static void report_free(struct report *);
  111. int
  112. SDL_SYS_JoystickInit(void)
  113. {
  114. char s[10];
  115. int i, fd;
  117. SDL_numjoysticks = 0;
  119. memset(joynames, NULL, sizeof(joynames));
  120. memset(joydevnames, NULL, sizeof(joydevnames));
  122. for (i = 0; i < MAX_UHID_JOYS; i++) {
  123. sprintf(s, "/dev/uhid%d", i);
  124. fd = open(s, O_RDWR);
  125. if (fd > 0) {
  126. joynames[SDL_numjoysticks++] = strdup(s);
  127. close(fd);
  128. }
  129. }
  130. for (i = 0; i < MAX_JOY_JOYS; i++) {
  131. sprintf(s, "/dev/joy%d", i);
  132. fd = open(s, O_RDWR);
  133. if (fd > 0) {
  134. joynames[SDL_numjoysticks++] = strdup(s);
  135. close(fd);
  136. }
  137. }
  139. /* Read the default USB HID usage table. */
  140. hid_init(NULL);
  142. return (SDL_numjoysticks);
  143. }
  145. const char *
  146. SDL_SYS_JoystickName(int index)
  147. {
  148. if (joydevnames[index] != NULL) {
  149. return (joydevnames[index]);
  150. }
  151. return (joynames[index]);
  152. }
  154. int
  155. SDL_SYS_JoystickOpen(SDL_Joystick *joy)
  156. {
  157. char *path = joynames[joy->index];
  158. struct joystick_hwdata *hw;
  159. struct hid_item hitem;
  160. struct hid_data *hdata;
  161. struct report *rep;
  162. int fd;
  164. fd = open(path, O_RDWR);
  165. if (fd < 0) {
  166. SDL_SetError("%s: %s", path, strerror(errno));
  167. return (-1);
  168. }
  170. hw = (struct joystick_hwdata *)malloc(sizeof(struct joystick_hwdata));
  171. if (hw == NULL) {
  172. SDL_OutOfMemory();
  173. close(fd);
  174. return (-1);
  175. }
  176. joy->hwdata = hw;
  177. hw->fd = fd;
  178. hw->path = strdup(path);
  179. hw->type = BSDJOY_UHID;
  180. hw->repdesc = hid_get_report_desc(fd);
  181. if (hw->repdesc == NULL) {
  182. SDL_SetError("%s: USB_GET_REPORT_DESC: %s", hw->path,
  183.     strerror(errno));
  184. goto usberr;
  185. }
  187. rep = &hw->inreport;
  188. if (report_alloc(rep, hw->repdesc, REPORT_INPUT) < 0) {
  189. goto usberr;
  190. }
  191. if (rep->size <= 0) {
  192. SDL_SetError("%s: Input report descriptor has invalid length",
  193.     hw->path);
  194. goto usberr;
  195. }
  197. hdata = hid_start_parse(hw->repdesc, 1 << hid_input);
  198. if (hdata == NULL) {
  199. SDL_SetError("%s: Cannot start HID parser", hw->path);
  200. goto usberr;
  201. }
  202. joy->naxes = 0;
  203. joy->nbuttons = 0;
  204. joy->nhats = 0;
  205. joy->nballs = 0;
  207. while (hid_get_item(hdata, &hitem) > 0) {
  208. char *s, *sp;
  210. switch (hitem.kind) {
  211. case hid_collection:
  212. switch (HID_PAGE(hitem.usage)) {
  213. case HUP_GENERIC_DESKTOP:
  214. switch (HID_USAGE(hitem.usage)) {
  215. case HUG_JOYSTICK:
  216. case HUG_GAME_PAD:
  217. s = hid_usage_in_page(hitem.usage);
  218. sp = malloc(strlen(s) + 5);
  219. sprintf(sp, "%s (%d)", s,
  220.     joy->index);
  221. joydevnames[joy->index] = sp;
  222. }
  223. }
  224. break;
  225. case hid_input:
  226. switch (HID_PAGE(hitem.usage)) {
  227. case HUP_UNDEFINED:
  228. break;
  229. case HUP_GENERIC_DESKTOP:
  230. switch (HID_USAGE(hitem.usage)) {
  231. case HUG_X:
  232. case HUG_Y:
  233. case HUG_Z:
  234. case HUG_SLIDER:
  235. case HUG_WHEEL:
  236. #if 0
  237. hw->axismin[joy->naxes] =
  238.     hitem.logical_minimum;
  239. hw->axismax[joy->naxes] =
  240.     hitem.logical_maximum;
  241. #endif
  242. joy->naxes++;
  243. break;
  244. }
  245. break;
  246. case HUP_BUTTON:
  247. joy->nbuttons++;
  248. break;
  249. }
  250. break;
  251. default:
  252. break;
  253. }
  254. }
  255. hid_end_parse(hdata);
  257. /* The poll blocks the event thread. */
  258. fcntl(fd, F_SETFL, O_NONBLOCK);
  260. return (0);
  261. usberr:
  262. close(hw->fd);
  263. free(hw->path);
  264. free(hw);
  265. return (-1);
  266. }
  268. void
  269. SDL_SYS_JoystickUpdate(SDL_Joystick *joy)
  270. {
  271. static struct hid_item hitem;
  272. static struct hid_data *hdata;
  273. static struct report *rep;
  274. int nbutton, naxe;
  275. Sint32 v;
  277. rep = &joy->hwdata->inreport;
  278. if (read(joy->hwdata->fd, rep->buf->data, rep->size) != rep->size) {
  279. return;
  280. }
  281. hdata = hid_start_parse(joy->hwdata->repdesc, 1 << hid_input);
  282. if (hdata == NULL) {
  283. fprintf(stderr, "%s: Cannot start HID parsern",
  284.     joy->hwdata->path);
  285. return;
  286. }
  288. for (nbutton = 0; hid_get_item(hdata, &hitem) > 0;) {
  289. switch (hitem.kind) {
  290. case hid_input:
  291. switch (HID_PAGE(hitem.usage)) {
  292. case HUP_UNDEFINED:
  293. continue;
  294. case HUP_GENERIC_DESKTOP:
  295. switch (HID_USAGE(hitem.usage)) {
  296. case HUG_X:
  297. naxe = JOYAXE_X;
  298. goto scaleaxe;
  299. case HUG_Y:
  300. naxe = JOYAXE_Y;
  301. goto scaleaxe;
  302. case HUG_Z:
  303. naxe = JOYAXE_Z;
  304. goto scaleaxe;
  305. case HUG_SLIDER:
  306. naxe = JOYAXE_SLIDER;
  307. goto scaleaxe;
  308. case HUG_WHEEL:
  309. naxe = JOYAXE_WHEEL;
  310. goto scaleaxe;
  311. }
  312. scaleaxe:
  313. v = (Sint32)hid_get_data(rep->buf->data, &hitem);
  314. if (v != 127) {
  315. if (v < 127) {
  316. v = -(256 - v);
  317. v <<= 7;
  318. v++;
  319. } else {
  320. v++;
  321. v <<= 7;
  322. v--;
  323. }
  324. } else {
  325. v = 0;
  326. }
  327. if (v != joy->axes[naxe]) {
  328. SDL_PrivateJoystickAxis(joy, naxe, v);
  329. }
  330. break;
  331. case HUP_BUTTON:
  332. v = (Sint32)hid_get_data(rep->buf->data,
  333.     &hitem);
  334. if (joy->buttons[nbutton] != v) {
  335. SDL_PrivateJoystickButton(joy,
  336.     nbutton, v);
  337. }
  338. nbutton++;
  339. break;
  340. }
  341. break;
  342. default:
  343. break;
  344. }
  345. }
  346. hid_end_parse(hdata);
  348. return;
  349. }
  351. /* Function to close a joystick after use */
  352. void
  353. SDL_SYS_JoystickClose(SDL_Joystick *joy)
  354. {
  355. report_free(&joy->hwdata->inreport);
  356. hid_dispose_report_desc(joy->hwdata->repdesc);
  357. close(joy->hwdata->fd);
  358. free(joy->hwdata->path);
  359. free(joy->hwdata);
  361. return;
  362. }
  364. void
  365. SDL_SYS_JoystickQuit(void)
  366. {
  367. int i;
  369. for (i = 0; i < MAX_JOYS; i++) {
  370. if (joynames[i] != NULL)
  371. free(joynames[i]);
  372. if (joydevnames[i] != NULL)
  373. free(joydevnames[i]);
  374. }
  376. return;
  377. }
  379. static int
  380. report_alloc(struct report *r, struct report_desc *rd, int repind)
  381. {
  382. int len;
  384. len = hid_report_size(rd, repinfo[repind].kind, &r->rid);
  385. if (len < 0) {
  386. SDL_SetError("Negative HID report size");
  387. return (-1);
  388. }
  389. r->size = len;
  391. if (r->size > 0) {
  392. r->buf = malloc(sizeof(*r->buf) - sizeof(r->buf->data) +
  393.     r->size);
  394. if (r->buf == NULL) {
  395. SDL_OutOfMemory();
  396. return (-1);
  397. }
  398. } else {
  399. r->buf = NULL;
  400. }
  402. r->status = SREPORT_CLEAN;
  403. return (0);
  404. }
  406. static void
  407. report_free(struct report *r)
  408. {
  409. if (r->buf != NULL) {
  410. free(r->buf);
  411. }
  412. r->status = SREPORT_UNINIT;
  413. }