annotate input/ar.c @ 33189:e137435bb751

Attempt to support attachements without filename.

/*
 * Apple Remote input interface
 *
 * Copyright (C) 2007 Zoltan Ponekker <pontscho at kac.poliod.hu>
 *
 * (modified a bit by Ulion <ulion2002 at gmail.com>)
 *
 * This file is part of MPlayer.
 *
 * MPlayer is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * MPlayer is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include <IOKit/IOCFPlugIn.h>
#include <IOKit/hid/IOHIDLib.h>
#include <Carbon/Carbon.h>

#include <sys/types.h>
#include <unistd.h>

#include "mplayer.h"
#include "input.h"
#include "ar.h"

extern const double NSAppKitVersionNumber;

typedef struct cookie_keycode_map {
    char *cookies;
    int seq_len;
    int keycode;
} cookie_keycode_map_t;

/* On tiger, 5 always follows 6; on leopard, 18 always follows 19.
 * On leopard, there seems to be no cookie value of 5 or 6.
 * Following is the shortened cookie sequence list
 * keycode      cookies_on_tiger cookies_on_leopard *down_state
 * AR_PREV_HOLD 14+6+3+2         31+19+3+2          yes
 * AR_NEXT_HOLD 14+6+4+2         31+19+4+2          yes
 * AR_MENU_HOLD 14+6+14+6        31+19+31+19
 * AR_VUP       14+12+11+6       31+29+28+19        yes
 * AR_VDOWN     14+13+11+6       31+30+28+19        yes
 * AR_MENU      14+7+6+14+7+6    31+20+19+31+20+19
 * AR_PLAY      14+8+6+14+8+6    31+21+19+31+21+19
 * AR_NEXT      14+9+6+14+9+6    31+22+19+31+22+19
 * AR_PREV      14+10+6+14+10+6  31+23+19+31+23+19
 * AR_PLAY_HOLD 18+14+6+18+14+6  35+31+19+35+31+19
 *
 * *down_state: A button with this feature has a pressed event and
 * a released event, with which we can trace the state of the button.
 * A button without this feature will only return one release event.
 *
 * hidden keys currently not implemented:
 * hold for 5 secs
 * MENU_NEXT_HOLD  15+14+6+15+14+6
 * MENU_PREV_HOLD  16+14+6+16+14+6
 * MENU_VUP_HOLD   20+14+6+20+14+6
 * MENU_VDOWN_HOLD 19+14+6+19+14+6
 *
 * It seems that pressing 'menu' and 'play' on the Apple Remote for
 * 5 seconds will trigger the make-pair function of the remote.
 * MENU_PLAY_HOLD  21+15+14+6+15+14+6
 */

static const cookie_keycode_map_t ar_codes_tiger[] = {
    { "\x0E\x06\x03\x02",         4, AR_PREV_HOLD     },
    { "\x0E\x06\x04\x02",         4, AR_NEXT_HOLD     },
    { "\x0E\x06\x0E\x06",         4, AR_MENU_HOLD     },
    { "\x0E\x0C\x0B\x06",         4, AR_VUP           },
    { "\x0E\x0D\x0B\x06",         4, AR_VDOWN         },
    { "\x0E\x07\x06\x0E\x07\x06", 6, AR_MENU          },
    { "\x0E\x08\x06\x0E\x08\x06", 6, AR_PLAY          },
    { "\x0E\x09\x06\x0E\x09\x06", 6, AR_NEXT          },
    { "\x0E\x0A\x06\x0E\x0A\x06", 6, AR_PREV          },
    { "\x12\x0E\x06\x12\x0E\x06", 6, AR_PLAY_HOLD     },
    { NULL,                       0, MP_INPUT_NOTHING },
};

static const cookie_keycode_map_t ar_codes_leopard[] = {
    { "\x1F\x13\x03\x02",         4, AR_PREV_HOLD     },
    { "\x1F\x13\x04\x02",         4, AR_NEXT_HOLD     },
    { "\x1F\x13\x1F\x13",         4, AR_MENU_HOLD     },
    { "\x1F\x1D\x1C\x13",         4, AR_VUP           },
    { "\x1F\x1E\x1C\x13",         4, AR_VDOWN         },
    { "\x1F\x14\x13\x1F\x14\x13", 6, AR_MENU          },
    { "\x1F\x15\x13\x1F\x15\x13", 6, AR_PLAY          },
    { "\x1F\x16\x13\x1F\x16\x13", 6, AR_NEXT          },
    { "\x1F\x17\x13\x1F\x17\x13", 6, AR_PREV          },
    { "\x23\x1F\x13\x23\x1F\x13", 6, AR_PLAY_HOLD     },
    { NULL,                       0, MP_INPUT_NOTHING },
};

static int is_leopard;
static const cookie_keycode_map_t *ar_codes;

static IOHIDQueueInterface **queue;
static IOHIDDeviceInterface **hidDeviceInterface = NULL;
static int initialized = 0;
static int hidDeviceIsOpen;

/* Maximum number of elements in queue before oldest elements
   in queue begin to be lost. Set to 16 to hold at least 2 events. */
static const int MAX_QUEUE_SIZE = 16;


static int FindHIDDevices(mach_port_t masterPort,
                          io_iterator_t *hidObjectIterator)
{
    CFMutableDictionaryRef hidMatchDictionary;
    IOReturn ioReturnValue;

    // Set up a matching dictionary to search the I/O Registry
    // by class name for all HID class devices.
    hidMatchDictionary = IOServiceMatching("AppleIRController");

    // Now search I/O Registry for matching devices.
    ioReturnValue = IOServiceGetMatchingServices(masterPort,
                                                 hidMatchDictionary,
                                                 hidObjectIterator);

    // If search is unsuccessful, print message and hang.
    if (ioReturnValue != kIOReturnSuccess ||
            !IOIteratorIsValid(*hidObjectIterator)) {
        return -1;
    }
    return 0;
}

static int getHIDCookies(IOHIDDeviceInterface122 **handle,
                         IOHIDElementCookie **cookies,
                         int *nr_cookies)
{
    CFTypeRef object;
    long number;
    CFArrayRef elements;
    CFDictionaryRef element;
    CFIndex i;

    *nr_cookies = 0;

    if (!handle || !(*handle))
        return -1;

    // Copy all elements, since we're grabbing most of the elements
    // for this device anyway, and thus, it's faster to iterate them
    // ourselves. When grabbing only one or two elements, a matching
    // dictionary should be passed in here instead of NULL.
    if (((*handle)->copyMatchingElements(handle, NULL, &elements)) != kIOReturnSuccess)
        return -1;

    // No elements, still a valid result.
    if (CFArrayGetCount(elements)==0)
        return 0;

    *cookies = calloc(CFArrayGetCount(elements), sizeof(IOHIDElementCookie));
    if (*cookies == NULL)
        return -1;

    for (i=0; i<CFArrayGetCount(elements); i++) {
        element = CFArrayGetValueAtIndex(elements, i);

        // Get cookie.
        object = CFDictionaryGetValue(element, CFSTR(kIOHIDElementCookieKey));
        if (object == 0 || CFGetTypeID(object) != CFNumberGetTypeID())
            continue;
        if (!CFNumberGetValue((CFNumberRef)object, kCFNumberLongType, &number))
            continue;
        (*cookies)[(*nr_cookies)++] = (IOHIDElementCookie)number;
    }

    return 0;
}

static int CreateHIDDeviceInterface(io_object_t hidDevice,
                                    IOHIDDeviceInterface ***hidDeviceInterface)
{
    io_name_t className;
    IOCFPlugInInterface **plugInInterface = NULL;
    SInt32 score = 0;

    if (IOObjectGetClass(hidDevice, className) != kIOReturnSuccess)
        return -1;

    if (IOCreatePlugInInterfaceForService(hidDevice,
                                          kIOHIDDeviceUserClientTypeID,
                                          kIOCFPlugInInterfaceID,
                                          &plugInInterface,
                                          &score) != kIOReturnSuccess)
        return -1;

    // Call a method of the intermediate plugin to create the device interface
    if ((*plugInInterface)->QueryInterface(plugInInterface,
                                   CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID),
                                   (LPVOID)hidDeviceInterface) != S_OK
            || *hidDeviceInterface == NULL || **hidDeviceInterface == NULL) {
        (*plugInInterface)->Release(plugInInterface);
        return -1;
    }

    (*plugInInterface)->Release(plugInInterface);

    return 0;
}

int mp_input_ar_init(void)
{
    io_iterator_t hidObjectIterator;
    io_object_t hidDevice;
    int i;
    IOHIDElementCookie *cookies = NULL;
    int nr_cookies = 0;

    if (initialized)
        mp_input_ar_close(-1);

    if (floor(NSAppKitVersionNumber) <= 824 /* NSAppKitVersionNumber10_4 */) {
        ar_codes = &ar_codes_tiger[0];
        is_leopard = 0;
    }
    else {
        ar_codes = &ar_codes_leopard[0];
        is_leopard = 1;
    }

    if (FindHIDDevices(kIOMasterPortDefault, &hidObjectIterator))
        return -1;

    // Multiple controls could be found, we only use the first usable one.
    while ((hidDevice = IOIteratorNext(hidObjectIterator))) {
        if (CreateHIDDeviceInterface(hidDevice, &hidDeviceInterface) < 0) {
            hidDeviceInterface = NULL;
            IOObjectRelease(hidDevice);
            continue;
        }
        if (getHIDCookies((IOHIDDeviceInterface122 **)hidDeviceInterface,
                          &cookies,
                          &nr_cookies) < 0) {
            (*hidDeviceInterface)->Release(hidDeviceInterface);
            hidDeviceInterface = NULL;
            IOObjectRelease(hidDevice);
            continue;
        }
        IOObjectRelease(hidDevice);
        break;
    }
    if (hidDeviceInterface == NULL)
        goto mp_input_ar_init_error;

    // Open the device.
    if ((*hidDeviceInterface)->open(hidDeviceInterface,
                              kIOHIDOptionsTypeSeizeDevice) != kIOReturnSuccess)
        goto mp_input_ar_init_error;
    hidDeviceIsOpen = 1;

    if ((queue = (*hidDeviceInterface)->allocQueue(hidDeviceInterface)) == NULL
            || *queue == NULL)
        goto mp_input_ar_init_error;

    // Create the queue.
    (*queue)->create(queue, 0, MAX_QUEUE_SIZE);

    // Add elements to the queue to make the queue work.
    // On tiger, it's a sequence from 1 to 21,
    // maybe it's the range of cookie values.
    for (i = 0;i < nr_cookies;i++)
        (*queue)->addElement(queue, cookies[i], 0);

    // not used anymore
    free(cookies);

    // Start data delivery to the queue.
    (*queue)->start(queue);

    // not useful anymore
    IOObjectRelease(hidObjectIterator);

    initialized = 1;
    return 0;

mp_input_ar_init_error:
    free(cookies);
    if (hidDeviceInterface != NULL) {
        if (*hidDeviceInterface != NULL) {
            (*hidDeviceInterface)->close(hidDeviceInterface);
            (*hidDeviceInterface)->Release(hidDeviceInterface);
        }
        hidDeviceInterface = NULL;
    }
    IOObjectRelease(hidObjectIterator);
    return -1;
}

static int is_mplayer_front(void)
{
    ProcessSerialNumber myProc, frProc;
    Boolean sameProc;
    pid_t parentPID;

    if (GetFrontProcess(&frProc) == noErr
            && GetCurrentProcess(&myProc) == noErr
            && SameProcess(&frProc, &myProc, &sameProc) == noErr) {
        if (sameProc)
            return 1;
        // If MPlayer is running in slave mode, also check parent process.
        if (slave_mode && GetProcessPID(&frProc, &parentPID) == noErr)
            return parentPID==getppid();
    }
    return 0;
}

int mp_input_ar_read(int fd)
{
    int i, down = 0;
    int ret = MP_INPUT_NOTHING;
    AbsoluteTime zeroTime = {0,0};
    IOHIDEventStruct event;
    static int prev_event = 0;
    IOReturn result = kIOReturnSuccess;

    const cookie_keycode_map_t *ar_code;
    int cookie_nr = 0;
    char cookie_queue[MAX_QUEUE_SIZE];
    int value_queue[MAX_QUEUE_SIZE];

    if (initialized == 0)
        return MP_INPUT_NOTHING;

    while ((result = (*queue)->getNextEvent(queue, &event, zeroTime, 0)) == kIOReturnSuccess) {
#ifdef TEST
        printf(" - event cookie: %d, value: %d, long value: %d\n",
              (int)event.elementCookie, (int)event.value, (int)event.longValue);
#endif
        // Shorten cookie sequence by removing cookies value 5 and 18,
        // since 5 always follows 6 (on tiger), 18 follows 19 (on leopard).
        if ((int)event.elementCookie == 5
                || ((int)event.elementCookie == 18 && is_leopard))
            continue;
        // Check valid cookie range.
        if ((int)event.elementCookie > 35 || (int)event.elementCookie < 2) {
            cookie_nr = 0;
            continue;
        }
        cookie_queue[cookie_nr] = (char)(int)event.elementCookie;
        value_queue[cookie_nr++] = event.value;
        // 4 cookies are necessary to make up a valid sequence.
        if (cookie_nr>=4) {
            // Find matching sequence.
            ar_code = ar_codes;
            while (ar_code->cookies != NULL &&
                    (cookie_nr < ar_code->seq_len ||
                     0 != memcmp(ar_code->cookies,
                                 &cookie_queue[cookie_nr-ar_code->seq_len],
                                 ar_code->seq_len)))
                ++ar_code;
            if (ar_code->cookies != NULL) {
                ret = ar_code->keycode;
                switch (ret) {
                    // For these 4 keys, the remote can keep a hold state.
                    case AR_VUP:
                    case AR_VDOWN:
                    case AR_NEXT_HOLD:
                    case AR_PREV_HOLD:
                        for (i = cookie_nr-ar_code->seq_len; i < cookie_nr; ++i) {
                            if (value_queue[i]) {
                                down = MP_KEY_DOWN;
                                break;
                            }
                        }
                        break;
                    default:
                        down = 0;
                }
            }
        }
    }

    if (!is_mplayer_front()) {
        if (hidDeviceIsOpen) {
            (*hidDeviceInterface)->close(hidDeviceInterface);
            hidDeviceIsOpen = 0;

            // Read out all pending events.
            while (result == kIOReturnSuccess)
                result = (*queue)->getNextEvent(queue, &event, zeroTime, 0);
        }
        return MP_INPUT_NOTHING;
    }
    // If we are switched from running as a foreground process to a
    // background process and back again, re-open the device to make
    // sure we are not affected by the system or other applications
    // using the Apple Remote.
    else if (!hidDeviceIsOpen) {
        if ((*hidDeviceInterface)->open(hidDeviceInterface,
                              kIOHIDOptionsTypeSeizeDevice) == kIOReturnSuccess)
            hidDeviceIsOpen = 1;
    }

    if (ret > 0)
        prev_event = ret;
    return ret | down;
}

void mp_input_ar_close(int fd)
{
    if (initialized == 0)
        return;

    // Close the device.
    (*hidDeviceInterface)->close(hidDeviceInterface);

    // Stop data delivery to queue.
    (*queue)->stop(queue);
    // Dispose of queue.
    (*queue)->dispose(queue);
    // Release the queue we allocated.
    (*queue)->Release(queue);

    // Release the interface.
    (*hidDeviceInterface)->Release(hidDeviceInterface);

    initialized = 0;
}

#ifdef TEST
int main(void)
{
    int ret;

    if (mp_input_ar_init() < 0) {
        printf("Unable to initialize Apple Remote.\n");
        return 1;
    }

    while (1) {
        switch ((ret = mp_input_ar_read(0)) & ~MP_KEY_DOWN) {
            case AR_PLAY:       printf(" - AR_PLAY."); break;
            case AR_PLAY_HOLD:  printf(" - AR_PLAY_HOLD."); break;
            case AR_NEXT:       printf(" - AR_NEXT."); break;
            case AR_NEXT_HOLD:  printf(" - AR_NEXT_HOLD."); break;
            case AR_PREV:       printf(" - AR_PREV."); break;
            case AR_PREV_HOLD:  printf(" - AR_PREV_HOLD."); break;
            case AR_MENU:       printf(" - AR_MENU."); break;
            case AR_MENU_HOLD:  printf(" - AR_MENU_HOLD."); break;
            case AR_VUP:        printf(" - AR_VUP."); break;
            case AR_VDOWN:      printf(" - AR_VDOWN."); break;
        }
        if ((ret > 0 )&&(ret & MP_KEY_DOWN))
            printf(" [hold]");
        if (ret > 0)
            printf("\n");
    }

    mp_input_ar_close(0);
    return 0;
}
#endif