input/ar.c

   1 /*
   2  * Apple Remote input interface
   3  *
   4  * Copyright (C) 2007 Zoltan Ponekker <pontscho at kac.poliod.hu>
   5  *
   6  * (modified a bit by Ulion <ulion2002 at gmail.com>)
   7  *
   8  * This file is part of MPlayer.
   9  *
  10  * MPlayer is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * MPlayer is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License along
  21  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  23  */
  24
  25 #include <IOKit/IOCFPlugIn.h>
  26 #include <IOKit/hid/IOHIDLib.h>
  27 #include <Carbon/Carbon.h>
  28
  29 #include <sys/types.h>
  30 #include <unistd.h>
  31
  32 #include "input.h"
  33 #include "ar.h"
  34
  35 extern int slave_mode;
  36
  37 extern const double NSAppKitVersionNumber;
  38
  39 typedef struct cookie_keycode_map {
  40     char *cookies;
  41     int seq_len;
  42     int keycode;
  43 } cookie_keycode_map_t;
  44
  45 /* On tiger, 5 always follows 6; on leopard, 18 always follows 19.
  46  * On leopard, there seems to be no cookie value of 5 or 6.
  47  * Following is the shortened cookie sequence list
  48  * keycode      cookies_on_tiger cookies_on_leopard *down_state
  49  * AR_PREV_HOLD 14+6+3+2         31+19+3+2          yes
  50  * AR_NEXT_HOLD 14+6+4+2         31+19+4+2          yes
  51  * AR_MENU_HOLD 14+6+14+6        31+19+31+19
  52  * AR_VUP       14+12+11+6       31+29+28+19        yes
  53  * AR_VDOWN     14+13+11+6       31+30+28+19        yes
  54  * AR_MENU      14+7+6+14+7+6    31+20+19+31+20+19
  55  * AR_PLAY      14+8+6+14+8+6    31+21+19+31+21+19
  56  * AR_NEXT      14+9+6+14+9+6    31+22+19+31+22+19
  57  * AR_PREV      14+10+6+14+10+6  31+23+19+31+23+19
  58  * AR_PLAY_HOLD 18+14+6+18+14+6  35+31+19+35+31+19
  59  *
  60  * *down_state: A button with this feature has a pressed event and
  61  * a released event, with which we can trace the state of the button.
  62  * A button without this feature will only return one release event.
  63  *
  64  * hidden keys currently not implemented:
  65  * hold for 5 secs
  66  * MENU_NEXT_HOLD  15+14+6+15+14+6
  67  * MENU_PREV_HOLD  16+14+6+16+14+6
  68  * MENU_VUP_HOLD   20+14+6+20+14+6
  69  * MENU_VDOWN_HOLD 19+14+6+19+14+6
  70  *
  71  * It seems that pressing 'menu' and 'play' on the Apple Remote for
  72  * 5 seconds will trigger the make-pair function of the remote.
  73  * MENU_PLAY_HOLD  21+15+14+6+15+14+6
  74  */
  75
  76 static const cookie_keycode_map_t ar_codes_tiger[] = {
  77     { "\x0E\x06\x03\x02",         4, AR_PREV_HOLD     },
  78     { "\x0E\x06\x04\x02",         4, AR_NEXT_HOLD     },
  79     { "\x0E\x06\x0E\x06",         4, AR_MENU_HOLD     },
  80     { "\x0E\x0C\x0B\x06",         4, AR_VUP           },
  81     { "\x0E\x0D\x0B\x06",         4, AR_VDOWN         },
  82     { "\x0E\x07\x06\x0E\x07\x06", 6, AR_MENU          },
  83     { "\x0E\x08\x06\x0E\x08\x06", 6, AR_PLAY          },
  84     { "\x0E\x09\x06\x0E\x09\x06", 6, AR_NEXT          },
  85     { "\x0E\x0A\x06\x0E\x0A\x06", 6, AR_PREV          },
  86     { "\x12\x0E\x06\x12\x0E\x06", 6, AR_PLAY_HOLD     },
  87     { NULL,                       0, MP_INPUT_NOTHING },
  88 };
  89
  90 static const cookie_keycode_map_t ar_codes_leopard[] = {
  91     { "\x1F\x13\x03\x02",         4, AR_PREV_HOLD     },
  92     { "\x1F\x13\x04\x02",         4, AR_NEXT_HOLD     },
  93     { "\x1F\x13\x1F\x13",         4, AR_MENU_HOLD     },
  94     { "\x1F\x1D\x1C\x13",         4, AR_VUP           },
  95     { "\x1F\x1E\x1C\x13",         4, AR_VDOWN         },
  96     { "\x1F\x14\x13\x1F\x14\x13", 6, AR_MENU          },
  97     { "\x1F\x15\x13\x1F\x15\x13", 6, AR_PLAY          },
  98     { "\x1F\x16\x13\x1F\x16\x13", 6, AR_NEXT          },
  99     { "\x1F\x17\x13\x1F\x17\x13", 6, AR_PREV          },
 100     { "\x23\x1F\x13\x23\x1F\x13", 6, AR_PLAY_HOLD     },
 101     { NULL,                       0, MP_INPUT_NOTHING },
 102 };
 103
 104 static int is_leopard;
 105 static const cookie_keycode_map_t *ar_codes;
 106
 107 static IOHIDQueueInterface **queue;
 108 static IOHIDDeviceInterface **hidDeviceInterface = NULL;
 109 static int initialized = 0;
 110 static int hidDeviceIsOpen;
 111
 112 /* Maximum number of elements in queue before oldest elements
 113    in queue begin to be lost. Set to 16 to hold at least 2 events. */
 114 static const int MAX_QUEUE_SIZE = 16;
 115
 116
 117 static int FindHIDDevices(mach_port_t masterPort,
 118                           io_iterator_t *hidObjectIterator)
 119 {
 120     CFMutableDictionaryRef hidMatchDictionary;
 121     IOReturn ioReturnValue;
 122
 123     // Set up a matching dictionary to search the I/O Registry
 124     // by class name for all HID class devices.
 125     hidMatchDictionary = IOServiceMatching("AppleIRController");
 126
 127     // Now search I/O Registry for matching devices.
 128     ioReturnValue = IOServiceGetMatchingServices(masterPort,
 129                                                  hidMatchDictionary,
 130                                                  hidObjectIterator);
 131
 132     // If search is unsuccessful, print message and hang.
 133     if (ioReturnValue != kIOReturnSuccess ||
 134             !IOIteratorIsValid(*hidObjectIterator)) {
 135         return -1;
 136     }
 137     return 0;
 138 }
 139
 140 static int getHIDCookies(IOHIDDeviceInterface122 **handle,
 141                          IOHIDElementCookie **cookies,
 142                          int *nr_cookies)
 143 {
 144     CFTypeRef object;
 145     long number;
 146     CFArrayRef elements;
 147     CFDictionaryRef element;
 148     CFIndex i;
 149
 150     *nr_cookies = 0;
 151
 152     if (!handle || !(*handle))
 153         return -1;
 154
 155     // Copy all elements, since we're grabbing most of the elements
 156     // for this device anyway, and thus, it's faster to iterate them
 157     // ourselves. When grabbing only one or two elements, a matching
 158     // dictionary should be passed in here instead of NULL.
 159     if (((*handle)->copyMatchingElements(handle, NULL, &elements)) != kIOReturnSuccess)
 160         return -1;
 161
 162     // No elements, still a valid result.
 163     if (CFArrayGetCount(elements)==0)
 164         return 0;
 165
 166     *cookies = calloc(CFArrayGetCount(elements), sizeof(IOHIDElementCookie));
 167     if (*cookies == NULL)
 168         return -1;
 169
 170     for (i=0; i<CFArrayGetCount(elements); i++) {
 171         element = CFArrayGetValueAtIndex(elements, i);
 172
 173         // Get cookie.
 174         object = CFDictionaryGetValue(element, CFSTR(kIOHIDElementCookieKey));
 175         if (object == 0 || CFGetTypeID(object) != CFNumberGetTypeID())
 176             continue;
 177         if (!CFNumberGetValue((CFNumberRef)object, kCFNumberLongType, &number))
 178             continue;
 179         (*cookies)[(*nr_cookies)++] = (IOHIDElementCookie)number;
 180     }
 181
 182     return 0;
 183 }
 184
 185 static int CreateHIDDeviceInterface(io_object_t hidDevice,
 186                                     IOHIDDeviceInterface ***hidDeviceInterface)
 187 {
 188     io_name_t className;
 189     IOCFPlugInInterface **plugInInterface = NULL;
 190     SInt32 score = 0;
 191
 192     if (IOObjectGetClass(hidDevice, className) != kIOReturnSuccess)
 193         return -1;
 194
 195     if (IOCreatePlugInInterfaceForService(hidDevice,
 196                                           kIOHIDDeviceUserClientTypeID,
 197                                           kIOCFPlugInInterfaceID,
 198                                           &plugInInterface,
 199                                           &score) != kIOReturnSuccess)
 200         return -1;
 201
 202     // Call a method of the intermediate plugin to create the device interface
 203     if ((*plugInInterface)->QueryInterface(plugInInterface,
 204                                    CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID),
 205                                    (LPVOID)hidDeviceInterface) != S_OK
 206             || *hidDeviceInterface == NULL || **hidDeviceInterface == NULL) {
 207         (*plugInInterface)->Release(plugInInterface);
 208         return -1;
 209     }
 210
 211     (*plugInInterface)->Release(plugInInterface);
 212
 213     return 0;
 214 }
 215
 216 int mp_input_ar_init(void)
 217 {
 218     io_iterator_t hidObjectIterator;
 219     io_object_t hidDevice;
 220     int i;
 221     IOHIDElementCookie *cookies = NULL;
 222     int nr_cookies = 0;
 223
 224     if (initialized)
 225         mp_input_ar_close(-1);
 226
 227     if (floor(NSAppKitVersionNumber) <= 824 /* NSAppKitVersionNumber10_4 */) {
 228         ar_codes = &ar_codes_tiger[0];
 229         is_leopard = 0;
 230     }
 231     else {
 232         ar_codes = &ar_codes_leopard[0];
 233         is_leopard = 1;
 234     }
 235
 236     if (FindHIDDevices(kIOMasterPortDefault, &hidObjectIterator))
 237         return -1;
 238
 239     // Multiple controls could be found, we only use the first usable one.
 240     while ((hidDevice = IOIteratorNext(hidObjectIterator))) {
 241         if (CreateHIDDeviceInterface(hidDevice, &hidDeviceInterface) < 0) {
 242             hidDeviceInterface = NULL;
 243             IOObjectRelease(hidDevice);
 244             continue;
 245         }
 246         if (getHIDCookies((IOHIDDeviceInterface122 **)hidDeviceInterface,
 247                           &cookies,
 248                           &nr_cookies) < 0) {
 249             (*hidDeviceInterface)->Release(hidDeviceInterface);
 250             hidDeviceInterface = NULL;
 251             IOObjectRelease(hidDevice);
 252             continue;
 253         }
 254         IOObjectRelease(hidDevice);
 255         break;
 256     }
 257     if (hidDeviceInterface == NULL)
 258         goto mp_input_ar_init_error;
 259
 260     // Open the device.
 261     if ((*hidDeviceInterface)->open(hidDeviceInterface,
 262                               kIOHIDOptionsTypeSeizeDevice) != kIOReturnSuccess)
 263         goto mp_input_ar_init_error;
 264     hidDeviceIsOpen = 1;
 265
 266     if ((queue = (*hidDeviceInterface)->allocQueue(hidDeviceInterface)) == NULL
 267             || *queue == NULL)
 268         goto mp_input_ar_init_error;
 269
 270     // Create the queue.
 271     (*queue)->create(queue, 0, MAX_QUEUE_SIZE);
 272
 273     // Add elements to the queue to make the queue work.
 274     // On tiger, it's a sequence from 1 to 21,
 275     // maybe it's the range of cookie values.
 276     for (i = 0;i < nr_cookies;i++)
 277         (*queue)->addElement(queue, cookies[i], 0);
 278
 279     // not used anymore
 280     free(cookies);
 281
 282     // Start data delivery to the queue.
 283     (*queue)->start(queue);
 284
 285     // not useful anymore
 286     IOObjectRelease(hidObjectIterator);
 287
 288     initialized = 1;
 289     return 0;
 290
 291 mp_input_ar_init_error:
 292     free(cookies);
 293     if (hidDeviceInterface != NULL) {
 294         if (*hidDeviceInterface != NULL) {
 295             (*hidDeviceInterface)->close(hidDeviceInterface);
 296             (*hidDeviceInterface)->Release(hidDeviceInterface);
 297         }
 298         hidDeviceInterface = NULL;
 299     }
 300     IOObjectRelease(hidObjectIterator);
 301     return -1;
 302 }
 303
 304 static int is_mplayer_front(void)
 305 {
 306     ProcessSerialNumber myProc, frProc;
 307     Boolean sameProc;
 308     pid_t parentPID;
 309
 310     if (GetFrontProcess(&frProc) == noErr
 311             && GetCurrentProcess(&myProc) == noErr
 312             && SameProcess(&frProc, &myProc, &sameProc) == noErr) {
 313         if (sameProc)
 314             return 1;
 315         // If MPlayer is running in slave mode, also check parent process.
 316         if (slave_mode && GetProcessPID(&frProc, &parentPID) == noErr)
 317             return parentPID==getppid();
 318     }
 319     return 0;
 320 }
 321
 322 int mp_input_ar_read(void *ctx, int fd)
 323 {
 324     int i, down = 0;
 325     int ret = MP_INPUT_NOTHING;
 326     AbsoluteTime zeroTime = {0,0};
 327     IOHIDEventStruct event;
 328     static int prev_event = 0;
 329     IOReturn result = kIOReturnSuccess;
 330
 331     const cookie_keycode_map_t *ar_code;
 332     int cookie_nr = 0;
 333     char cookie_queue[MAX_QUEUE_SIZE];
 334     int value_queue[MAX_QUEUE_SIZE];
 335
 336     if (initialized == 0)
 337         return MP_INPUT_NOTHING;
 338
 339     while ((result = (*queue)->getNextEvent(queue, &event, zeroTime, 0)) == kIOReturnSuccess) {
 340 #ifdef TEST
 341         printf(" - event cookie: %d, value: %d, long value: %d\n",
 342               (int)event.elementCookie, (int)event.value, (int)event.longValue);
 343 #endif
 344         // Shorten cookie sequence by removing cookies value 5 and 18,
 345         // since 5 always follows 6 (on tiger), 18 follows 19 (on leopard).
 346         if ((int)event.elementCookie == 5
 347                 || ((int)event.elementCookie == 18 && is_leopard))
 348             continue;
 349         // Check valid cookie range.
 350         if ((int)event.elementCookie > 35 || (int)event.elementCookie < 2) {
 351             cookie_nr = 0;
 352             continue;
 353         }
 354         cookie_queue[cookie_nr] = (char)(int)event.elementCookie;
 355         value_queue[cookie_nr++] = event.value;
 356         // 4 cookies are necessary to make up a valid sequence.
 357         if (cookie_nr>=4) {
 358             // Find matching sequence.
 359             ar_code = ar_codes;
 360             while (ar_code->cookies != NULL &&
 361                     (cookie_nr < ar_code->seq_len ||
 362                      0 != memcmp(ar_code->cookies,
 363                                  &cookie_queue[cookie_nr-ar_code->seq_len],
 364                                  ar_code->seq_len)))
 365                 ++ar_code;
 366             if (ar_code->cookies != NULL) {
 367                 ret = ar_code->keycode;
 368                 switch (ret) {
 369                     // For these 4 keys, the remote can keep a hold state.
 370                     case AR_VUP:
 371                     case AR_VDOWN:
 372                     case AR_NEXT_HOLD:
 373                     case AR_PREV_HOLD:
 374                         for (i = cookie_nr-ar_code->seq_len; i < cookie_nr; ++i) {
 375                             if (value_queue[i]) {
 376                                 down = MP_KEY_DOWN;
 377                                 break;
 378                             }
 379                         }
 380                         break;
 381                     default:
 382                         down = 0;
 383                 }
 384             }
 385         }
 386     }
 387
 388     if (!is_mplayer_front()) {
 389         if (hidDeviceIsOpen) {
 390             (*hidDeviceInterface)->close(hidDeviceInterface);
 391             hidDeviceIsOpen = 0;
 392
 393             // Read out all pending events.
 394             while (result == kIOReturnSuccess)
 395                 result = (*queue)->getNextEvent(queue, &event, zeroTime, 0);
 396         }
 397         return MP_INPUT_NOTHING;
 398     }
 399     // If we are switched from running as a foreground process to a
 400     // background process and back again, re-open the device to make
 401     // sure we are not affected by the system or other applications
 402     // using the Apple Remote.
 403     else if (!hidDeviceIsOpen) {
 404         if ((*hidDeviceInterface)->open(hidDeviceInterface,
 405                               kIOHIDOptionsTypeSeizeDevice) == kIOReturnSuccess)
 406             hidDeviceIsOpen = 1;
 407     }
 408
 409     if (ret > 0)
 410         prev_event = ret;
 411     return ret | down;
 412 }
 413
 414 void mp_input_ar_close(int fd)
 415 {
 416     if (initialized == 0)
 417         return;
 418
 419     // Close the device.
 420     (*hidDeviceInterface)->close(hidDeviceInterface);
 421
 422     // Stop data delivery to queue.
 423     (*queue)->stop(queue);
 424     // Dispose of queue.
 425     (*queue)->dispose(queue);
 426     // Release the queue we allocated.
 427     (*queue)->Release(queue);
 428
 429     // Release the interface.
 430     (*hidDeviceInterface)->Release(hidDeviceInterface);
 431
 432     initialized = 0;
 433 }
 434
 435 #ifdef TEST
 436 int main(void)
 437 {
 438     int ret;
 439
 440     if (mp_input_ar_init() < 0) {
 441         printf("Unable to initialize Apple Remote.\n");
 442         return 1;
 443     }
 444
 445     while (1) {
 446         switch ((ret = mp_input_ar_read(NULL, 0)) & ~MP_KEY_DOWN) {
 447             case AR_PLAY:       printf(" - AR_PLAY."); break;
 448             case AR_PLAY_HOLD:  printf(" - AR_PLAY_HOLD."); break;
 449             case AR_NEXT:       printf(" - AR_NEXT."); break;
 450             case AR_NEXT_HOLD:  printf(" - AR_NEXT_HOLD."); break;
 451             case AR_PREV:       printf(" - AR_PREV."); break;
 452             case AR_PREV_HOLD:  printf(" - AR_PREV_HOLD."); break;
 453             case AR_MENU:       printf(" - AR_MENU."); break;
 454             case AR_MENU_HOLD:  printf(" - AR_MENU_HOLD."); break;
 455             case AR_VUP:        printf(" - AR_VUP."); break;
 456             case AR_VDOWN:      printf(" - AR_VDOWN."); break;
 457         }
 458         if ((ret > 0 )&&(ret & MP_KEY_DOWN))
 459             printf(" [hold]");
 460         if (ret > 0)
 461             printf("\n");
 462     }
 463
 464     mp_input_ar_close(0);
 465     return 0;
 466 }
 467 #endif