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

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

流媒体/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@libsdl.org
  21. */
  23. /* SDL joystick driver for Darwin / MacOS X, based on the IOKit HID API */
  24. /* Written 2001 by Max Horn */
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28. #include <unistd.h>
  29. #include <ctype.h>
  30. #include <sys/errno.h>
  31. #include <sysexits.h>
  32. #include <mach/mach.h>
  33. #include <mach/mach_error.h>
  34. #include <IOKit/IOKitLib.h>
  35. #include <IOKit/IOCFPlugIn.h>
  36. #ifdef MACOS_10_0_4
  37. #include <IOKit/hidsystem/IOHIDUsageTables.h>
  38. #else
  39. /* The header was moved here in MacOS X 10.1 */
  40. #include <Kernel/IOKit/hidsystem/IOHIDUsageTables.h>
  41. #endif
  42. #include <IOKit/hid/IOHIDLib.h>
  43. #include <IOKit/hid/IOHIDKeys.h>
  44. #include <CoreFoundation/CoreFoundation.h>
  46. #include "SDL_error.h"
  47. #include "SDL_joystick.h"
  48. #include "SDL_sysjoystick.h"
  49. #include "SDL_joystick_c.h"
  51. struct recElement
  52. {
  53. IOHIDElementCookie cookie; // unique value which identifies element, will NOT change
  54. long min; // reported min value possible
  55. long max; // reported max value possible
  56. /*
  57. TODO: maybe should handle the following stuff somehow?
  59. long scaledMin; // reported scaled min value possible
  60. long scaledMax; // reported scaled max value possible
  61. long size; // size in bits of data return from element
  62. Boolean relative; // are reports relative to last report (deltas)
  63. Boolean wrapping; // does element wrap around (one value higher than max is min)
  64. Boolean nonLinear; // are the values reported non-linear relative to element movement
  65. Boolean preferredState; // does element have a preferred state (such as a button)
  66. Boolean nullState; // does element have null state
  67. */
  69. /* runtime variables used for auto-calibration */
  70. long minReport; // min returned value
  71. long maxReport; // max returned value
  73. struct recElement * pNext; // next element in list
  74. };
  75. typedef struct recElement recElement;
  77. struct joystick_hwdata
  78. {
  79. IOHIDDeviceInterface ** interface; // interface to device, NULL = no interface
  81. char product[256]; // name of product
  82. long usage; // usage page from IOUSBHID Parser.h which defines general usage
  83. long usagePage; // usage within above page from IOUSBHID Parser.h which defines specific usage
  85. long axes; // number of axis (calculated, not reported by device)
  86. long buttons; // number of buttons (calculated, not reported by device)
  87. long hats; // number of hat switches (calculated, not reported by device)
  88. long elements; // number of total elements (shouldbe total of above) (calculated, not reported by device)
  90. recElement* firstAxis;
  91. recElement* firstButton;
  92. recElement* firstHat;
  94. struct joystick_hwdata* pNext; // next device
  95. };
  96. typedef struct joystick_hwdata recDevice;
  99. /* Linked list of all available devices */
  100. static recDevice *gpDeviceList = NULL;
  103. void HIDReportErrorNum (char * strError, long numError)
  104. {
  105. SDL_SetError(strError);
  106. }
  108. static void HIDGetCollectionElements (CFMutableDictionaryRef deviceProperties, recDevice *pDevice);
  110. /* returns current value for element, polling element
  111.  * will return 0 on error conditions which should be accounted for by application
  112.  */
  114. SInt32 HIDGetElementValue (recDevice *pDevice, recElement *pElement)
  115. {
  116. IOReturn result = kIOReturnSuccess;
  117. IOHIDEventStruct hidEvent;
  118. hidEvent.value = 0;
  120. if (NULL != pDevice && NULL != pElement && NULL != pDevice->interface)
  121. {
  122. result = (*(pDevice->interface))->getElementValue(pDevice->interface, pElement->cookie, &hidEvent);
  123. if (kIOReturnSuccess == result)
  124. {
  125. /* record min and max for auto calibration */
  126. if (hidEvent.value < pElement->minReport)
  127. pElement->minReport = hidEvent.value;
  128. if (hidEvent.value > pElement->maxReport)
  129. pElement->maxReport = hidEvent.value;
  130. }
  131. }
  133. // auto user scale
  134. return hidEvent.value;
  135. }
  137. /* similiar to HIDGetElementValue, but auto-calibrates the value before returning it */
  139. SInt32 HIDCalibratedValue (recDevice *pDevice, recElement *pElement)
  140. {
  141. float deviceScale = pElement->max - pElement->min;
  142. float readScale = pElement->maxReport - pElement->minReport;
  143. SInt32 value = HIDGetElementValue(pDevice, pElement);
  144. if (readScale == 0)
  145. return value; // no scaling at all
  146. else
  147. return ((value - pElement->minReport) * deviceScale / readScale) + pElement->min;
  148. }
  150. /* similiar to HIDCalibratedValue but calibrates to an arbitrary scale instead of the elements default scale */
  152. SInt32 HIDScaledCalibratedValue (recDevice *pDevice, recElement *pElement, long min, long max)
  153. {
  154. float deviceScale = max - min;
  155. float readScale = pElement->maxReport - pElement->minReport;
  156. SInt32 value = HIDGetElementValue(pDevice, pElement);
  157. if (readScale == 0)
  158. return value; // no scaling at all
  159. else
  160. return ((value - pElement->minReport) * deviceScale / readScale) + min;
  161. }
  163. /* Create and open an interface to device, required prior to extracting values or building queues.
  164.  * Note: appliction now owns the device and must close and release it prior to exiting
  165.  */
  167. IOReturn HIDCreateOpenDeviceInterface (io_object_t hidDevice, recDevice *pDevice)
  168. {
  169. IOReturn result = kIOReturnSuccess;
  170. HRESULT plugInResult = S_OK;
  171. SInt32 score = 0;
  172. IOCFPlugInInterface ** ppPlugInInterface = NULL;
  174. if (NULL == pDevice->interface)
  175. {
  176. result = IOCreatePlugInInterfaceForService (hidDevice, kIOHIDDeviceUserClientTypeID,
  177. kIOCFPlugInInterfaceID, &ppPlugInInterface, &score);
  178. if (kIOReturnSuccess == result)
  179. {
  180. // Call a method of the intermediate plug-in to create the device interface
  181. plugInResult = (*ppPlugInInterface)->QueryInterface (ppPlugInInterface,
  182. CFUUIDGetUUIDBytes (kIOHIDDeviceInterfaceID), (void *) &(pDevice->interface));
  183. if (S_OK != plugInResult)
  184. HIDReportErrorNum ("Couldn誸 query HID class device interface from plugInInterface", plugInResult);
  185. (*ppPlugInInterface)->Release (ppPlugInInterface);
  186. }
  187. else
  188. HIDReportErrorNum ("Failed to create **plugInInterface via IOCreatePlugInInterfaceForService.", result);
  189. }
  190. if (NULL != pDevice->interface)
  191. {
  192. result = (*(pDevice->interface))->open (pDevice->interface, 0);
  193. if (kIOReturnSuccess != result)
  194. HIDReportErrorNum ("Failed to open pDevice->interface via open.", result);
  195. }
  196. return result;
  197. }
  199. /* Closes and releases interface to device, should be done prior to exting application
  200.  * Note: will have no affect if device or interface do not exist
  201.  * application will "own" the device if interface is not closed
  202.  * (device may have to be plug and re-plugged in different location to get it working again without a restart)
  203.  */
  205. IOReturn HIDCloseReleaseInterface (recDevice *pDevice)
  206. {
  207. IOReturn result = kIOReturnSuccess;
  209. if ((NULL != pDevice) && (NULL != pDevice->interface))
  210. {
  211. // close the interface
  212. result = (*(pDevice->interface))->close (pDevice->interface);
  213. if (kIOReturnNotOpen == result)
  214. {
  215. //  do nothing as device was not opened, thus can't be closed
  216. }
  217. else if (kIOReturnSuccess != result)
  218. HIDReportErrorNum ("Failed to close IOHIDDeviceInterface.", result);
  219. //release the interface
  220. result = (*(pDevice->interface))->Release (pDevice->interface);
  221. if (kIOReturnSuccess != result)
  222. HIDReportErrorNum ("Failed to release IOHIDDeviceInterface.", result);
  223. pDevice->interface = NULL;
  224. }
  225. return result;
  226. }
  228. /* extracts actual specific element information from each element CF dictionary entry */
  230. static void HIDGetElementInfo (CFTypeRef refElement, recElement *pElement)
  231. {
  232. long number;
  233. CFTypeRef refType;
  235. refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementCookieKey));
  236. if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
  237. pElement->cookie = (IOHIDElementCookie) number;
  238. refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementMinKey));
  239. if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
  240. pElement->min = number;
  241. pElement->maxReport = pElement->min;
  242. refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementMaxKey));
  243. if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
  244. pElement->max = number;
  245. pElement->minReport = pElement->max;
  246. /*
  247. TODO: maybe should handle the following stuff somehow?
  249. refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementScaledMinKey));
  250. if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
  251. pElement->scaledMin = number;
  252. refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementScaledMaxKey));
  253. if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
  254. pElement->scaledMax = number;
  255. refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementSizeKey));
  256. if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
  257. pElement->size = number;
  258. refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementIsRelativeKey));
  259. if (refType)
  260. pElement->relative = CFBooleanGetValue (refType);
  261. refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementIsWrappingKey));
  262. if (refType)
  263. pElement->wrapping = CFBooleanGetValue (refType);
  264. refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementIsNonLinearKey));
  265. if (refType)
  266. pElement->nonLinear = CFBooleanGetValue (refType);
  267. refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementHasPreferedStateKey));
  268. if (refType)
  269. pElement->preferredState = CFBooleanGetValue (refType);
  270. refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementHasNullStateKey));
  271. if (refType)
  272. pElement->nullState = CFBooleanGetValue (refType);
  273. */
  274. }
  276. /* examines CF dictionary vlaue in device element hierarchy to determine if it is element of interest or a collection of more elements
  277.  * if element of interest allocate storage, add to list and retrieve element specific info
  278.  * if collection then pass on to deconstruction collection into additional individual elements
  279.  */
  281. static void HIDAddElement (CFTypeRef refElement, recDevice* pDevice)
  282. {
  283. recElement* element = NULL;
  284. recElement** headElement = NULL;
  285. long elementType, usagePage, usage;
  286. CFTypeRef refElementType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementTypeKey));
  287. CFTypeRef refUsagePage = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementUsagePageKey));
  288. CFTypeRef refUsage = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementUsageKey));
  291. if ((refElementType) && (CFNumberGetValue (refElementType, kCFNumberLongType, &elementType)))
  292. {
  293. /* look at types of interest */
  294. if ((elementType == kIOHIDElementTypeInput_Misc) || (elementType == kIOHIDElementTypeInput_Button) ||
  295. (elementType == kIOHIDElementTypeInput_Axis))
  296. {
  297. if (refUsagePage && CFNumberGetValue (refUsagePage, kCFNumberLongType, &usagePage) &&
  298. refUsage && CFNumberGetValue (refUsage, kCFNumberLongType, &usage))
  299. {
  300. switch (usagePage) /* only interested in kHIDPage_GenericDesktop and kHIDPage_Button */
  301. {
  302. case kHIDPage_GenericDesktop:
  303. {
  304. switch (usage) /* look at usage to determine function */
  305. {
  306. case kHIDUsage_GD_X:
  307. case kHIDUsage_GD_Y:
  308. case kHIDUsage_GD_Z:
  309. case kHIDUsage_GD_Rx:
  310. case kHIDUsage_GD_Ry:
  311. case kHIDUsage_GD_Rz:
  312. element = (recElement *) NewPtrClear (sizeof (recElement));
  313. if (element)
  314. {
  315. pDevice->axes++;
  316. headElement = &(pDevice->firstAxis);
  317. }
  318. break;
  319. case kHIDUsage_GD_Hatswitch:
  320. element = (recElement *) NewPtrClear (sizeof (recElement));
  321. if (element)
  322. {
  323. pDevice->hats++;
  324. headElement = &(pDevice->firstHat);
  325. }
  326. break;
  327. }
  328. }
  329. break;
  330. case kHIDPage_Button:
  331. element = (recElement *) NewPtrClear (sizeof (recElement));
  332. if (element)
  333. {
  334. pDevice->buttons++;
  335. headElement = &(pDevice->firstButton);
  336. }
  337. break;
  338. default:
  339. break;
  340. }
  341. }
  342. }
  343. else if (kIOHIDElementTypeCollection == elementType)
  344. HIDGetCollectionElements ((CFMutableDictionaryRef) refElement, pDevice);
  345. }
  347. if (element && headElement) /* add to list */
  348. {
  349. pDevice->elements++;
  350. if (NULL == *headElement)
  351. *headElement = element;
  352. else
  353. {
  354. recElement *elementPrevious, *elementCurrent;
  355. elementCurrent = *headElement;
  356. while (elementCurrent)
  357. {
  358. elementPrevious = elementCurrent;
  359. elementCurrent = elementPrevious->pNext;
  360. }
  361. elementPrevious->pNext = element;
  362. }
  363. element->pNext = NULL;
  364. HIDGetElementInfo (refElement, element);
  365. }
  366. }
  368. /* collects information from each array member in device element list (each array memeber = element) */
  370. static void HIDGetElementsCFArrayHandler (const void * value, void * parameter)
  371. {
  372. if (CFGetTypeID (value) == CFDictionaryGetTypeID ())
  373. HIDAddElement ((CFTypeRef) value, (recDevice *) parameter);
  374. }
  376. /* handles retrieval of element information from arrays of elements in device IO registry information */
  378. static void HIDGetElements (CFTypeRef refElementCurrent, recDevice *pDevice)
  379. {
  380. CFTypeID type = CFGetTypeID (refElementCurrent);
  381. if (type == CFArrayGetTypeID()) /* if element is an array */
  382. {
  383. CFRange range = {0, CFArrayGetCount (refElementCurrent)};
  384. /* CountElementsCFArrayHandler called for each array member */
  385. CFArrayApplyFunction (refElementCurrent, range, HIDGetElementsCFArrayHandler, pDevice);
  386. }
  387. }
  389. /* handles extracting element information from element collection CF types
  390.  * used from top level element decoding and hierarchy deconstruction to flatten device element list
  391.  */
  393. static void HIDGetCollectionElements (CFMutableDictionaryRef deviceProperties, recDevice *pDevice)
  394. {
  395. CFTypeRef refElementTop = CFDictionaryGetValue (deviceProperties, CFSTR(kIOHIDElementKey));
  396. if (refElementTop)
  397. HIDGetElements (refElementTop, pDevice);
  398. }
  400. /* use top level element usage page and usage to discern device usage page and usage setting appropriate vlaues in device record */
  402. static void HIDTopLevelElementHandler (const void * value, void * parameter)
  403. {
  404. CFTypeRef refCF = 0;
  405. if (CFGetTypeID (value) != CFDictionaryGetTypeID ())
  406. return;
  407. refCF = CFDictionaryGetValue (value, CFSTR(kIOHIDElementUsagePageKey));
  408. if (!CFNumberGetValue (refCF, kCFNumberLongType, &((recDevice *) parameter)->usagePage))
  409. SDL_SetError ("CFNumberGetValue error retrieving pDevice->usagePage.");
  410. refCF = CFDictionaryGetValue (value, CFSTR(kIOHIDElementUsageKey));
  411. if (!CFNumberGetValue (refCF, kCFNumberLongType, &((recDevice *) parameter)->usage))
  412. SDL_SetError ("CFNumberGetValue error retrieving pDevice->usage.");
  413. }
  415. /* extracts device info from CF dictionary records in IO registry */
  417. static void HIDGetDeviceInfo (io_object_t hidDevice, CFMutableDictionaryRef hidProperties, recDevice *pDevice)
  418. {
  419. CFMutableDictionaryRef usbProperties = 0;
  420. io_registry_entry_t parent1, parent2;
  422. /* Mac OS X currently is not mirroring all USB properties to HID page so need to look at USB device page also
  423.  * get dictionary for usb properties: step up two levels and get CF dictionary for USB properties
  424.  */
  425. if ((KERN_SUCCESS == IORegistryEntryGetParentEntry (hidDevice, kIOServicePlane, &parent1)) &&
  426. (KERN_SUCCESS == IORegistryEntryGetParentEntry (parent1, kIOServicePlane, &parent2)) &&
  427. (KERN_SUCCESS == IORegistryEntryCreateCFProperties (parent2, &usbProperties, kCFAllocatorDefault, kNilOptions)))
  428. {
  429. if (usbProperties)
  430. {
  431. CFTypeRef refCF = 0;
  432. /* get device info
  433.  * try hid dictionary first, if fail then go to usb dictionary
  434.  */
  437. /* get product name */
  438. refCF = CFDictionaryGetValue (hidProperties, CFSTR(kIOHIDProductKey));
  439. if (!refCF)
  440. refCF = CFDictionaryGetValue (usbProperties, CFSTR("USB Product Name"));
  441. if (refCF)
  442. {
  443. if (!CFStringGetCString (refCF, pDevice->product, 256, CFStringGetSystemEncoding ()))
  444. SDL_SetError ("CFStringGetCString error retrieving pDevice->product.");
  445. }
  447. /* get usage page and usage */
  448. refCF = CFDictionaryGetValue (hidProperties, CFSTR(kIOHIDPrimaryUsagePageKey));
  449. if (refCF)
  450. {
  451. if (!CFNumberGetValue (refCF, kCFNumberLongType, &pDevice->usagePage))
  452. SDL_SetError ("CFNumberGetValue error retrieving pDevice->usagePage.");
  453. refCF = CFDictionaryGetValue (hidProperties, CFSTR(kIOHIDPrimaryUsageKey));
  454. if (refCF)
  455. if (!CFNumberGetValue (refCF, kCFNumberLongType, &pDevice->usage))
  456. SDL_SetError ("CFNumberGetValue error retrieving pDevice->usage.");
  457. }
  459. if (NULL == refCF) /* get top level element HID usage page or usage */
  460. {
  461. /* use top level element instead */
  462. CFTypeRef refCFTopElement = 0;
  463. refCFTopElement = CFDictionaryGetValue (hidProperties, CFSTR(kIOHIDElementKey));
  464. {
  465. /* refCFTopElement points to an array of element dictionaries */
  466. CFRange range = {0, CFArrayGetCount (refCFTopElement)};
  467. CFArrayApplyFunction (refCFTopElement, range, HIDTopLevelElementHandler, pDevice);
  468. }
  469. }
  471. CFRelease (usbProperties);
  472. }
  473. else
  474. SDL_SetError ("IORegistryEntryCreateCFProperties failed to create usbProperties.");
  476. if (kIOReturnSuccess != IOObjectRelease (parent2))
  477. SDL_SetError ("IOObjectRelease error with parent2.");
  478. if (kIOReturnSuccess != IOObjectRelease (parent1))
  479. SDL_SetError ("IOObjectRelease error with parent1.");
  480. }
  481. }
  484. static recDevice *HIDBuildDevice (io_object_t hidDevice)
  485. {
  486. recDevice *pDevice = (recDevice *) NewPtrClear (sizeof (recDevice));
  487. if (pDevice)
  488. {
  489. /* get dictionary for HID properties */
  490. CFMutableDictionaryRef hidProperties = 0;
  491. kern_return_t result = IORegistryEntryCreateCFProperties (hidDevice, &hidProperties, kCFAllocatorDefault, kNilOptions);
  492. if ((result == KERN_SUCCESS) && hidProperties)
  493. {
  494. /* create device interface */
  495. result = HIDCreateOpenDeviceInterface (hidDevice, pDevice);
  496. if (kIOReturnSuccess == result)
  497. {
  498. HIDGetDeviceInfo (hidDevice, hidProperties, pDevice); /* hidDevice used to find parents in registry tree */
  499. HIDGetCollectionElements (hidProperties, pDevice);
  500. }
  501. else
  502. {
  503. DisposePtr((Ptr)pDevice);
  504. pDevice = NULL;
  505. }
  506. CFRelease (hidProperties);
  507. }
  508. else
  509. {
  510. DisposePtr((Ptr)pDevice);
  511. pDevice = NULL;
  512. }
  513. }
  514. return pDevice;
  515. }
  517. /* disposes of the element list associated with a device and the memory associated with the list
  518.  */
  520. static void HIDDisposeElementList (recElement **elementList)
  521. {
  522. recElement *pElement = *elementList;
  523. while (pElement)
  524. {
  525. recElement *pElementNext = pElement->pNext;
  526. DisposePtr ((Ptr) pElement);
  527. pElement = pElementNext;
  528. }
  529. *elementList = NULL;
  530. }
  532. /* disposes of a single device, closing and releaseing interface, freeing memory fro device and elements, setting device pointer to NULL
  533.  * all your device no longer belong to us... (i.e., you do not 'own' the device anymore)
  534.  */
  536. static recDevice *HIDDisposeDevice (recDevice **ppDevice)
  537. {
  538. kern_return_t result = KERN_SUCCESS;
  539. recDevice *pDeviceNext = NULL;
  540. if (*ppDevice)
  541. {
  542. // save next device prior to disposing of this device
  543. pDeviceNext = (*ppDevice)->pNext;
  545. /* free element lists */
  546. HIDDisposeElementList (&(*ppDevice)->firstAxis);
  547. HIDDisposeElementList (&(*ppDevice)->firstButton);
  548. HIDDisposeElementList (&(*ppDevice)->firstHat);
  550. result = HIDCloseReleaseInterface (*ppDevice); /* function sanity checks interface value (now application does not own device) */
  551. if (kIOReturnSuccess != result)
  552. HIDReportErrorNum ("HIDCloseReleaseInterface failed when trying to dipose device.", result);
  553. DisposePtr ((Ptr)*ppDevice);
  554. *ppDevice = NULL;
  555. }
  556. return pDeviceNext;
  557. }
  560. /* Function to scan the system for joysticks.
  561.  * Joystick 0 should be the system default joystick.
  562.  * This function should return the number of available joysticks, or -1
  563.  * on an unrecoverable fatal error.
  564.  */
  565. int SDL_SYS_JoystickInit(void)
  566. {
  567. IOReturn result = kIOReturnSuccess;
  568. mach_port_t masterPort = NULL;
  569. io_iterator_t hidObjectIterator = NULL;
  570. CFMutableDictionaryRef hidMatchDictionary = NULL;
  571. recDevice *device, *lastDevice;
  572. io_object_t ioHIDDeviceObject = NULL;
  573. UInt32 usagePage = kHIDPage_GenericDesktop;
  574. UInt32 usage = kHIDUsage_GD_Joystick; /* We probably also should check for gamepads? */
  576. SDL_numjoysticks = 0;
  578. if (NULL != gpDeviceList)
  579. {
  580. SDL_SetError("Joystick: Device list already inited.");
  581. return -1;
  582. }
  584. result = IOMasterPort (bootstrap_port, &masterPort);
  585. if (kIOReturnSuccess != result)
  586. {
  587. SDL_SetError("Joystick: IOMasterPort error with bootstrap_port.");
  588. return -1;
  589. }
  591. /* Set up a matching dictionary to search I/O Registry by class name for all HID class devices. */
  592. hidMatchDictionary = IOServiceMatching (kIOHIDDeviceKey);
  593. if ((hidMatchDictionary != NULL) && (usagePage) && (usage))
  594. {
  595. /* Add key for device type (joystick, in this case) to refine the matching dictionary. */
  596. CFNumberRef refUsage = NULL, refUsagePage = NULL;
  598. refUsage = CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &usagePage);
  599. CFDictionarySetValue (hidMatchDictionary, CFSTR (kIOHIDPrimaryUsageKey), refUsage);
  600. refUsagePage = CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &usage);
  601. CFDictionarySetValue (hidMatchDictionary, CFSTR (kIOHIDPrimaryUsagePageKey), refUsagePage);
  602. }
  603. else
  604. {
  605. SDL_SetError("Joystick: Failed to get HID CFMutableDictionaryRef via IOServiceMatching.");
  606. return -1;
  607. }
  609. /*/ Now search I/O Registry for matching devices. */
  610. result = IOServiceGetMatchingServices (masterPort, hidMatchDictionary, &hidObjectIterator);
  611. /* Check for errors */
  612. if ((kIOReturnSuccess != result) || (NULL == hidObjectIterator))
  613. {
  614. SDL_SetError("Joystick: Couldn't create a HID object iterator.");
  615. return -1;
  616. }
  617. /* IOServiceGetMatchingServices consumes a reference to the dictionary, so we don't need to release the dictionary ref. */
  619. /* build flat linked list of devices from device iterator */
  621. gpDeviceList = lastDevice = NULL;
  623. while ((ioHIDDeviceObject = IOIteratorNext (hidObjectIterator)))
  624. {
  625. /* build a device record */
  626. device = HIDBuildDevice (ioHIDDeviceObject);
  627. if (!device)
  628. continue;
  630. /* dump device object, it is no longer needed */
  631. result = IOObjectRelease (ioHIDDeviceObject);
  632. // if (KERN_SUCCESS != result)
  633. // HIDReportErrorNum ("IOObjectRelease error with ioHIDDeviceObject.", result);
  634. /* Add device to the end of the list */
  635. if (lastDevice)
  636. lastDevice->pNext = device;
  637. else
  638. gpDeviceList = device;
  639. lastDevice = device;
  640. }
  641. result = IOObjectRelease (hidObjectIterator); /* release the iterator */
  643. /* Count the total number of devices we found */
  644. device = gpDeviceList;
  645. while (device)
  646. {
  647. SDL_numjoysticks++;
  648. device = device->pNext;
  649. }
  651. return SDL_numjoysticks;
  652. }
  654. /* Function to get the device-dependent name of a joystick */
  655. const char *SDL_SYS_JoystickName(int index)
  656. {
  657. recDevice *device = gpDeviceList;
  659. for (; index > 0; index--)
  660. device = device->pNext;
  662. return device->product;
  663. }
  665. /* Function to open a joystick for use.
  666.  * The joystick to open is specified by the index field of the joystick.
  667.  * This should fill the nbuttons and naxes fields of the joystick structure.
  668.  * It returns 0, or -1 if there is an error.
  669.  */
  670. int SDL_SYS_JoystickOpen(SDL_Joystick *joystick)
  671. {
  672. recDevice *device = gpDeviceList;
  673. int index;
  675. for (index = joystick->index; index > 0; index--)
  676. device = device->pNext;
  678. joystick->hwdata = device;
  679. joystick->name = device->product;
  681. joystick->naxes = device->axes;
  682. joystick->nhats = device->hats;
  683. joystick->nballs = 0;
  684. joystick->nbuttons = device->buttons;
  686. return 0;
  687. }
  689. /* Function to update the state of a joystick - called as a device poll.
  690.  * This function shouldn't update the joystick structure directly,
  691.  * but instead should call SDL_PrivateJoystick*() to deliver events
  692.  * and update joystick device state.
  693.  */
  694. void SDL_SYS_JoystickUpdate(SDL_Joystick *joystick)
  695. {
  696. recDevice *device = joystick->hwdata;
  697. recElement *element;
  698. SInt32 value;
  699. int i;
  701. element = device->firstAxis;
  702. i = 0;
  703. while (element)
  704. {
  705. value = HIDScaledCalibratedValue(device, element, -32768, 32767);
  706. if ( value != joystick->axes[i] )
  707. SDL_PrivateJoystickAxis(joystick, i, value);
  708. element = element->pNext;
  709. ++i;
  710. }
  712. element = device->firstButton;
  713. i = 0;
  714. while (element)
  715. {
  716. value = HIDGetElementValue(device, element);
  717. if ( value != joystick->buttons[i] )
  718. SDL_PrivateJoystickButton(joystick, i, value);
  719. element = element->pNext;
  720. ++i;
  721. }
  723. element = device->firstHat;
  724. i = 0;
  725. while (element)
  726. {
  727. Uint8 pos = 0;
  729. value = HIDGetElementValue(device, element);
  730. switch(value)
  731. {
  732. case 0:
  733. pos = SDL_HAT_CENTERED;
  734. break;
  735. case 1:
  736. pos = SDL_HAT_UP;
  737. break;
  738. case 2:
  739. pos = SDL_HAT_RIGHTUP;
  740. break;
  741. case 3:
  742. pos = SDL_HAT_RIGHT;
  743. break;
  744. case 4:
  745. pos = SDL_HAT_RIGHTDOWN;
  746. break;
  747. case 5:
  748. pos = SDL_HAT_DOWN;
  749. break;
  750. case 6:
  751. pos = SDL_HAT_LEFTDOWN;
  752. break;
  753. case 7:
  754. pos = SDL_HAT_LEFT;
  755. break;
  756. case 8:
  757. pos = SDL_HAT_LEFTUP;
  758. break;
  759. }
  760. if ( pos != joystick->hats[i] )
  761. SDL_PrivateJoystickHat(joystick, i, pos);
  762. element = element->pNext;
  763. ++i;
  764. }
  766. return;
  767. }
  769. /* Function to close a joystick after use */
  770. void SDL_SYS_JoystickClose(SDL_Joystick *joystick)
  771. {
  772. /* Should we do anything here? */
  773. return;
  774. }
  776. /* Function to perform any system-specific joystick related cleanup */
  777. void SDL_SYS_JoystickQuit(void)
  778. {
  779. while (NULL != gpDeviceList)
  780. gpDeviceList = HIDDisposeDevice (&gpDeviceList);
  781. }