// Async processing thread for keyboard events: void* KbQueueWorkerThreadMain(void* dummy) { int rc; // Try to raise our priority: We ask to switch ourselves (NULL) to priority class 1 aka // realtime scheduling, with a tweakPriority of +1, ie., raise the relative // priority level by +1 wrt. to the current level: if ((rc = PsychSetThreadPriority(NULL, 1, 1)) > 0) { printf("PsychHID: KbQueueStart: Failed to switch to realtime priority [%s].\n", strerror(rc)); } while (1) { PsychLockMutex(&KbQueueMutex); // Check if we should terminate: if (KbQueueThreadTerminate) break; PsychUnlockMutex(&KbQueueMutex); // Perform event processing until no more events are pending: KbQueueProcessEvents(TRUE); } // Done. Unlock the mutex: PsychUnlockMutex(&KbQueueMutex); // printf("DEBUG: THREAD TERMINATING...\n"); fflush(NULL); // Return and terminate: return(NULL); }
/* Return number of events in buffer for 'deviceIndex': * flags == 0 -> All events. * flags & 1 -> Only keypress events with valid mapped ASCII CookedKey keycode. */ unsigned int PsychHIDAvailEventBuffer(int deviceIndex, unsigned int flags) { unsigned int navail, i, j; if (deviceIndex < 0) deviceIndex = PsychHIDGetDefaultKbQueueDevice(); if (!hidEventBuffer[deviceIndex]) return(0); PsychLockMutex(&hidEventBufferMutex[deviceIndex]); // Compute total number of available events by default: navail = hidEventBufferWritePos[deviceIndex] - hidEventBufferReadPos[deviceIndex]; // Only count of valid "CookedKey" mapped keypress events, e.g., for use by CharAvail(), requested? if (flags & 1) { // Yes: Iterate over all available events and only count number of keypress events // with meaningful 'CookedKey' field: navail = 0; for (i = hidEventBufferReadPos[deviceIndex]; i < hidEventBufferWritePos[deviceIndex]; i++) { j = i % hidEventBufferCapacity[deviceIndex]; if ((hidEventBuffer[deviceIndex][j].status & (1<<0)) && (hidEventBuffer[deviceIndex][j].cookedEventCode > 0)) navail++; } } PsychUnlockMutex(&hidEventBufferMutex[deviceIndex]); return(navail); }
PsychHIDEventRecord* PsychHIDLastTouchEventFromEventBuffer(int deviceIndex, int touchID) { int nend, current; PsychHIDEventRecord *evt; if (!hidEventBuffer[deviceIndex]) return(0); PsychLockMutex(&hidEventBufferMutex[deviceIndex]); nend = (hidEventBufferWritePos[deviceIndex] - 1) % hidEventBufferCapacity[deviceIndex]; current = nend; // Go backwards through all touch events until the most recent one with touchID is found: do { if ((hidEventBuffer[deviceIndex][current].type >= 2) && (hidEventBuffer[deviceIndex][current].type <= 4) && (hidEventBuffer[deviceIndex][current].rawEventCode == touchID)) break; current = (current - 1) % hidEventBufferCapacity[deviceIndex]; } while ((current != nend) && (current >= 0)); if (hidEventBuffer[deviceIndex][current].rawEventCode == touchID) evt = &(hidEventBuffer[deviceIndex][current]); else evt = NULL; PsychUnlockMutex(&hidEventBufferMutex[deviceIndex]); return (evt); }
int PsychHIDAddEventToEventBuffer(int deviceIndex, PsychHIDEventRecord* evt) { unsigned int navail; if (deviceIndex < 0) deviceIndex = PsychHIDGetDefaultKbQueueDevice(); if (!hidEventBuffer[deviceIndex]) return(0); PsychLockMutex(&hidEventBufferMutex[deviceIndex]); navail = hidEventBufferWritePos[deviceIndex] - hidEventBufferReadPos[deviceIndex]; if (navail < hidEventBufferCapacity[deviceIndex]) { memcpy(&(hidEventBuffer[deviceIndex][hidEventBufferWritePos[deviceIndex] % hidEventBufferCapacity[deviceIndex]]), evt, sizeof(PsychHIDEventRecord)); hidEventBufferWritePos[deviceIndex]++; // Announce new event to potential waiters: PsychSignalCondition(&hidEventBufferCondition[deviceIndex]); } else { printf("PsychHID: WARNING: KbQueue event buffer is full! Maximum capacity of %i elements reached, will discard future events.\n", hidEventBufferCapacity[deviceIndex]); } PsychUnlockMutex(&hidEventBufferMutex[deviceIndex]); return(navail - 1); }
/* Called at each end-of-stream event at end of playback: */ static void PsychEOSCallback(GstAppSink *sink, gpointer user_data) { PsychMovieRecordType* movie = (PsychMovieRecordType*) user_data; PsychLockMutex(&movie->mutex); //printf("PTB-DEBUG: Videosink reached EOS.\n"); PsychUnlockMutex(&movie->mutex); PsychSignalCondition(&movie->condition); return; }
/* Not used by us, but needs to be defined as no-op anyway: */ static GstFlowReturn PsychNewBufferListCallback(GstAppSink *sink, gpointer user_data) { PsychMovieRecordType* movie = (PsychMovieRecordType*) user_data; PsychLockMutex(&movie->mutex); //printf("PTB-DEBUG: New Bufferlist received.\n"); PsychUnlockMutex(&movie->mutex); PsychSignalCondition(&movie->condition); return(GST_FLOW_OK); }
psych_bool PsychHIDFlushEventBuffer(int deviceIndex) { if (deviceIndex < 0) deviceIndex = PsychHIDGetDefaultKbQueueDevice(); if (!hidEventBuffer[deviceIndex]) return(FALSE); PsychLockMutex(&hidEventBufferMutex[deviceIndex]); hidEventBufferReadPos[deviceIndex] = hidEventBufferWritePos[deviceIndex] = 0; PsychUnlockMutex(&hidEventBufferMutex[deviceIndex]); return(TRUE); }
void PsychHIDOSKbQueueRelease(int deviceIndex) { // Get true keyboardqueue index assigned to deviceIndex from original user provided deviceIndex: deviceIndex = PsychHIDOSGetKbQueueDevice(deviceIndex, NULL); // Keyboard queue for this deviceIndex already exists? if (NULL == psychHIDKbQueueFirstPress[deviceIndex]) { // No. Nothing to do then. return; } // Ok, we have a keyboard queue. Stop any operation on it first: PsychHIDOSKbQueueStop(deviceIndex); // The mutex will be automatically unlocked and destroyed by the CFRunLoop thread // so it isn't even declared in this routine if (psychHIDKbQueueCFRunLoopRef[deviceIndex]) { // Shutdown the processing thread for this queue: PsychLockMutex(&KbQueueMutex); // Stop the CFRunLoop, which will allow its associated thread to exit: CFRunLoopStop(psychHIDKbQueueCFRunLoopRef[deviceIndex]); // Done. PsychUnlockMutex(&KbQueueMutex); // Shutdown the thread, wait for its termination: PsychDeleteThread(&KbQueueThread[deviceIndex]); KbQueueThread[deviceIndex] = NULL; // Release the CFRunLoop for this queue: CFRelease(psychHIDKbQueueCFRunLoopRef[deviceIndex]); psychHIDKbQueueCFRunLoopRef[deviceIndex] = NULL; // Release queue object: CFRelease(queue[deviceIndex]); queue[deviceIndex] = NULL; } // Release its data structures: free(psychHIDKbQueueFirstPress[deviceIndex]); psychHIDKbQueueFirstPress[deviceIndex] = NULL; free(psychHIDKbQueueFirstRelease[deviceIndex]); psychHIDKbQueueFirstRelease[deviceIndex] = NULL; free(psychHIDKbQueueLastPress[deviceIndex]); psychHIDKbQueueLastPress[deviceIndex] = NULL; free(psychHIDKbQueueLastRelease[deviceIndex]); psychHIDKbQueueLastRelease[deviceIndex] = NULL; free(psychHIDKbQueueScanKeys[deviceIndex]); psychHIDKbQueueScanKeys[deviceIndex] = NULL; // Release kbqueue event buffer: PsychHIDDeleteEventBuffer(deviceIndex); // Done. return; }
unsigned int PsychHIDAvailEventBuffer(int deviceIndex) { unsigned int navail; if (deviceIndex < 0) deviceIndex = PsychHIDGetDefaultKbQueueDevice(); if (!hidEventBuffer[deviceIndex]) return(0); PsychLockMutex(&hidEventBufferMutex[deviceIndex]); navail = hidEventBufferWritePos[deviceIndex] - hidEventBufferReadPos[deviceIndex]; PsychUnlockMutex(&hidEventBufferMutex[deviceIndex]); return(navail); }
/* Video data arrived callback: Purely for documentation, because only used if oldstyle == true, that is *never*. */ static gboolean PsychHaveVideoDataCallback(GstPad *pad, GstBuffer *buffer, gpointer dataptr) { unsigned int alloc_size; PsychMovieRecordType* movie = (PsychMovieRecordType*) dataptr; PsychLockMutex(&movie->mutex); if (movie->rate == 0) { PsychUnlockMutex(&movie->mutex); return(TRUE); } /* Perform onetime-init for the buffer */ if (NULL == movie->imageBuffer) { // Allocate the buffer: alloc_size = buffer->size; if ((int) buffer->size < movie->width * movie->height * 4) { alloc_size = movie->width * movie->height * 4; printf("PTB-DEBUG: Overriding unsafe buffer size of %d bytes with %d bytes.\n", buffer->size, alloc_size); } // printf("PTB-DEBUG: Allocating image buffer of %d bytes.\n", alloc_size); movie->imageBuffer = calloc(1, alloc_size); } // Copy new image data to our buffer: memcpy(movie->imageBuffer, buffer->data, buffer->size); movie->frameAvail++; // printf("PTB-DEBUG: New frame %d [size %d] %lf.\n", movie->frameAvail, buffer->size, (double) buffer->timestamp / (double) 1e9); // Fetch presentation timestamp and convert to seconds: movie->pts = (double) buffer->timestamp / (double) 1e9; PsychUnlockMutex(&movie->mutex); PsychSignalCondition(&movie->condition); return(TRUE); }
void PsychHIDOSKbQueueStart(int deviceIndex) { psych_bool queueActive; int i; // Get true keyboardqueue index assigned to deviceIndex from original user provided deviceIndex: deviceIndex = PsychHIDOSGetKbQueueDevice(deviceIndex, NULL); // Does Keyboard queue for this deviceIndex already exist? if (NULL == psychHIDKbQueueFirstPress[deviceIndex]) { // No. Bad bad... printf("PsychHID-ERROR: Tried to start processing on non-existent keyboard queue for deviceIndex %i! Call KbQueueCreate first!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Invalid keyboard 'deviceIndex' specified. No queue for that device yet!"); } // Keyboard queue already stopped? Then we ain't nothing to do: if (psychHIDKbQueueActive[deviceIndex]) return; // Queue is inactive. Start it: // Will this be the first active queue, ie., aren't there any queues running so far? queueActive = FALSE; for (i = 0; i < PSYCH_HID_MAX_DEVICES; i++) { queueActive |= psychHIDKbQueueActive[i]; } PsychLockMutex(&KbQueueMutex); // Clear out current state for this queue: memset(psychHIDKbQueueFirstPress[deviceIndex] , 0, (256 * sizeof(double))); memset(psychHIDKbQueueFirstRelease[deviceIndex] , 0, (256 * sizeof(double))); memset(psychHIDKbQueueLastPress[deviceIndex] , 0, (256 * sizeof(double))); memset(psychHIDKbQueueLastRelease[deviceIndex] , 0, (256 * sizeof(double))); modifierKeyState[deviceIndex] = 0; // Start event collection in the queue: IOHIDQueueStart(queue[deviceIndex]); // Mark this queue as logically started: psychHIDKbQueueActive[deviceIndex] = TRUE; // Queue started. PsychUnlockMutex(&KbQueueMutex); return; }
int PsychHIDReturnEventFromEventBuffer(int deviceIndex, int outArgIndex, double maxWaitTimeSecs) { unsigned int navail; PsychHIDEventRecord evt; PsychGenericScriptType *retevent; double* foo = NULL; const char *FieldNames[] = { "Time", "Pressed", "Keycode", "CookedKey" }; if (deviceIndex < 0) deviceIndex = PsychHIDGetDefaultKbQueueDevice(); if (!hidEventBuffer[deviceIndex]) return(0); PsychLockMutex(&hidEventBufferMutex[deviceIndex]); navail = hidEventBufferWritePos[deviceIndex] - hidEventBufferReadPos[deviceIndex]; // If nothing available and we're asked to wait for something, then wait: if ((navail == 0) && (maxWaitTimeSecs > 0)) { // Wait for something: PsychTimedWaitCondition(&hidEventBufferCondition[deviceIndex], &hidEventBufferMutex[deviceIndex], maxWaitTimeSecs); // Recompute number of available events: navail = hidEventBufferWritePos[deviceIndex] - hidEventBufferReadPos[deviceIndex]; } // Check if anything available, copy it if so: if (navail) { memcpy(&evt, &(hidEventBuffer[deviceIndex][hidEventBufferReadPos[deviceIndex] % hidEventBufferCapacity[deviceIndex]]), sizeof(PsychHIDEventRecord)); hidEventBufferReadPos[deviceIndex]++; } PsychUnlockMutex(&hidEventBufferMutex[deviceIndex]); if (navail) { // Return event struct: PsychAllocOutStructArray(outArgIndex, kPsychArgOptional, 1, 4, FieldNames, &retevent); PsychSetStructArrayDoubleElement("Time", 0, evt.timestamp, retevent); PsychSetStructArrayDoubleElement("Pressed", 0, (double) (evt.status & (1<<0)) ? 1 : 0, retevent); PsychSetStructArrayDoubleElement("Keycode", 0, (double) evt.rawEventCode, retevent); PsychSetStructArrayDoubleElement("CookedKey", 0, (double) evt.cookedEventCode, retevent); return(navail - 1); } else { // Return empty matrix: PsychCopyOutDoubleMatArg(outArgIndex, kPsychArgOptional, 0, 0, 0, foo); return(0); } }
void PsychHIDOSKbQueueFlush(int deviceIndex) { LPDIRECTINPUTDEVICE8 kb; HRESULT rc; DWORD dwItems = INFINITE; if (deviceIndex < 0) { deviceIndex = PsychHIDGetDefaultKbQueueDevice(); // Ok, deviceIndex now contains our default keyboard to use - The first suitable keyboard. } if ((deviceIndex < 0) || (deviceIndex >= ndevices)) { // Out of range index: PsychErrorExitMsg(PsychError_user, "Invalid 'deviceIndex' specified. No such device!"); } // Does Keyboard queue for this deviceIndex already exist? if (NULL == psychHIDKbQueueFirstPress[deviceIndex]) { // No. Bad bad... printf("PsychHID-ERROR: Tried to flush non-existent keyboard queue for deviceIndex %i! Call KbQueueCreate first!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Invalid 'deviceIndex' specified. No queue for that device yet!"); } kb = GetXDevice(deviceIndex); // Clear out current state for this queue: PsychLockMutex(&KbQueueMutex); // Flush device buffer: rc = kb->GetDeviceData(sizeof(DIDEVICEOBJECTDATA), NULL, &dwItems, 0); // Clear our buffer: memset(psychHIDKbQueueFirstPress[deviceIndex] , 0, (256 * sizeof(double))); memset(psychHIDKbQueueFirstRelease[deviceIndex] , 0, (256 * sizeof(double))); memset(psychHIDKbQueueLastPress[deviceIndex] , 0, (256 * sizeof(double))); memset(psychHIDKbQueueLastRelease[deviceIndex] , 0, (256 * sizeof(double))); PsychUnlockMutex(&KbQueueMutex); return; }
// Display link callback: Needed so we can actually start the display link: // Gets apparently called from a separate high-priority thread, close to vblank // time. "inNow" is the timestamp of last vblank. static CVReturn PsychCVDisplayLinkOutputCallback(CVDisplayLinkRef displayLink, const CVTimeStamp *inNow, const CVTimeStamp *inOutputTime, CVOptionFlags flagsIn, CVOptionFlags *flagsOut, void *displayLinkContext) { double tVBlank; CVTimeStamp tVbl; double tHost; // Retrieve screenId of associated display screen: int screenId = (int) (long int) displayLinkContext; // Extra guard against shutdown races: if (NULL == cvDisplayLink[screenId]) return(kCVReturnSuccess); // Translate CoreVideo inNow timestamp with time of last vbl from gpu time // to host system time, aka our GetSecs() timebase: memset(&tVbl, 0, sizeof(tVbl)); tVbl.version = 0; tVbl.flags = kCVTimeStampHostTimeValid; CVDisplayLinkTranslateTime(displayLink, inNow, &tVbl); tVBlank = (double) tVbl.hostTime / (double) 1000000000; // Store timestamp in our shared data structure, also increment virtual vblank counter: PsychLockMutex(&(cvDisplayLinkData[screenId].mutex)); cvDisplayLinkData[screenId].vblCount++; cvDisplayLinkData[screenId].vblTimestamp = tVBlank; PsychUnlockMutex(&(cvDisplayLinkData[screenId].mutex)); // Low-level timestamp debugging requested? if (PsychPrefStateGet_Verbosity() > 20) { // Compare CV timestamps against host time for correctness check. We wait 4 msecs, // then take tHost and hopefully tHost will be at least 4 msecs later than the // computed vblank timestamp tVBlank: PsychWaitIntervalSeconds(0.004); PsychGetAdjustedPrecisionTimerSeconds(&tHost); // Caution: Don't run from Matlab GUI! This printf will crash Matlab otherwise. printf("CVCallback: %i : tHost = %lf secs, tVBlank = %lf secs. tHost - tVBlank = %lf secs.\n", screenId, tHost, tVBlank, tHost - tVBlank); } return(kCVReturnSuccess); }
/* PsychOSGetVBLTimeAndCount() Returns absolute system time of last VBL and current total count of VBL interrupts since startup of gfx-system for the given screen. Returns a time of -1 and a count of 0 if this feature is unavailable on the given OS/Hardware configuration. */ double PsychOSGetVBLTimeAndCount(PsychWindowRecordType *windowRecord, psych_uint64* vblCount) { unsigned int screenid = windowRecord->screenNumber; double cvTime; // Should we use CoreVideo display link timestamping? if (cvDisplayLink[screenid]) { // Yes: Retrieve data from our shared data structure: PsychLockMutex(&(cvDisplayLinkData[screenid].mutex)); *vblCount = cvDisplayLinkData[screenid].vblCount; cvTime = cvDisplayLinkData[screenid].vblTimestamp; PsychUnlockMutex(&(cvDisplayLinkData[screenid].mutex)); return(cvTime); } else { // Unsupported: *vblCount = 0; return(-1); } }
void PsychHIDOSKbQueueFlush(int deviceIndex) { // Get true keyboardqueue index assigned to deviceIndex from original user provided deviceIndex: deviceIndex = PsychHIDOSGetKbQueueDevice(deviceIndex, NULL); // Does Keyboard queue for this deviceIndex already exist? if (NULL == psychHIDKbQueueFirstPress[deviceIndex]) { // No. Bad bad... printf("PsychHID-ERROR: Tried to flush non-existent keyboard queue for deviceIndex %i! Call KbQueueCreate first!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Invalid keyboard 'deviceIndex' specified. No queue for that device yet!"); } // Clear out current state for this queue: PsychLockMutex(&KbQueueMutex); memset(psychHIDKbQueueFirstPress[deviceIndex] , 0, (256 * sizeof(double))); memset(psychHIDKbQueueFirstRelease[deviceIndex] , 0, (256 * sizeof(double))); memset(psychHIDKbQueueLastPress[deviceIndex] , 0, (256 * sizeof(double))); memset(psychHIDKbQueueLastRelease[deviceIndex] , 0, (256 * sizeof(double))); modifierKeyState[deviceIndex] = 0; PsychUnlockMutex(&KbQueueMutex); return; }
/* Atomically release the 'mutex' lock and go to sleep, waiting for the 'condition' variable * being signalled, then waking up and trying to re-lock the 'mutex'. Will return with * mutex locked. */ int PsychWaitCondition(psych_condition* condition, psych_mutex* mutex) { int rc, rc2; // MS-Windows: Unlock mutex, wait for our event-object to go to signalled // state, then reacquire the mutex: if ((rc = PsychUnlockMutex(mutex))) { printf("PTB-CRITICAL: In call to PsychWaitCondition(%p, %p): PsychUnlockMutex(%p) FAILED [rc=%i]! Expect disaster!!!", condition, mutex, mutex, rc); return(rc); } if ((rc = WaitForSingleObject(*condition, INFINITE)) != WAIT_OBJECT_0) { rc = (int) GetLastError(); printf("PTB-CRITICAL: In call to PsychWaitCondition(%p, %p): WaitForSingleObject(%p) FAILED [GetLastError()=%i]! Expect disaster!!!", condition, mutex, condition, rc); } if ((rc2 = PsychLockMutex(mutex))) { printf("PTB-CRITICAL: In call to PsychWaitCondition(%p, %p): PsychLockMutex(%p) FAILED [rc=%i]! Expect disaster!!!", condition, mutex, mutex, rc2); return(rc2); } return(rc); }
void PsychHIDOSKbQueueStop(int deviceIndex) { psych_bool queueActive; int i; // Get true keyboardqueue index assigned to deviceIndex from original user provided deviceIndex: deviceIndex = PsychHIDOSGetKbQueueDevice(deviceIndex, NULL); // Keyboard queue for this deviceIndex already exists? if (NULL == psychHIDKbQueueFirstPress[deviceIndex]) { // No. Nothing to do then. return; } // Keyboard queue already stopped? if (!psychHIDKbQueueActive[deviceIndex]) return; // Queue is active. Stop it: PsychLockMutex(&KbQueueMutex); // Stop event collection in the queue: IOHIDQueueStop(queue[deviceIndex]); // Mark queue logically stopped: psychHIDKbQueueActive[deviceIndex] = FALSE; PsychUnlockMutex(&KbQueueMutex); // Was this the last active queue? queueActive = FALSE; for (i = 0; i < PSYCH_HID_MAX_DEVICES; i++) { queueActive |= psychHIDKbQueueActive[i]; } return; }
/* Atomically release the 'mutex' lock and go to sleep, waiting for the 'condition' variable * being signalled, then waking up and trying to re-lock the 'mutex'. Will return with * mutex locked. * * Like PsychWaitCondition, but function will timeout if it fails being signalled before * timeout interval 'maxwaittimesecs' expires. In any case, it will only return after * reacquiring the mutex. It will retun zero on successfull wait, non-zero (WAIT_TIMEOUT) if * timeout was triggered without the condition being signalled. */ int PsychTimedWaitCondition(psych_condition* condition, psych_mutex* mutex, double maxwaittimesecs) { int rc, rc2; int maxmillisecs; if (maxwaittimesecs < 0) { printf("PTB-CRITICAL: In call to PsychTimedWaitCondition(%p, %p, %f): NEGATIVE timeout value passed! Clamping to zero! Expect trouble!!", condition, mutex, maxwaittimesecs); maxmillisecs = 0; } else { // Convert seconds to milliseconds: maxmillisecs = (int) (maxwaittimesecs * 1000.0); } // MS-Windows: Unlock mutex, wait for our event-object to go to signalled // state, then reacquire the mutex: if ((rc = PsychUnlockMutex(mutex))) { printf("PTB-CRITICAL: In call to PsychTimedWaitCondition(%p, %p, %f): PsychUnlockMutex(%p) FAILED [rc=%i]! Expect disaster!!!", condition, mutex, maxwaittimesecs, mutex, rc); return(rc); } rc = (int) WaitForSingleObject(*condition, (DWORD) maxmillisecs); if ((rc != WAIT_OBJECT_0) && (rc != WAIT_TIMEOUT)) { rc = (int) GetLastError(); printf("PTB-CRITICAL: In call to PsychTimedWaitCondition(%p, %p, %f): WaitForSingleObject(%p, %i) FAILED [GetLastError()=%i]! Expect disaster!!!", condition, mutex, maxwaittimesecs, condition, maxmillisecs, rc); } if ((rc2 = PsychLockMutex(mutex))) { printf("PTB-CRITICAL: In call to PsychTimedWaitCondition(%p, %p, %f): PsychLockMutex(%p) FAILED [rc=%i]! Expect disaster!!!", condition, mutex, maxwaittimesecs, mutex, rc2); return(rc2); } // Success: Either in the sense of "signalled" or in the sense of "timeout". // rc will tell the caller what happened: 0 = Signalled, 0x00000102L == WAIT_TIMEOUT for timeout. return(rc); }
int PsychHIDReturnEventFromEventBuffer(int deviceIndex, int outArgIndex, double maxWaitTimeSecs) { unsigned int navail, j; PsychHIDEventRecord evt; PsychGenericScriptType *retevent; double* foo = NULL; PsychGenericScriptType *outMat; double *v; const char *FieldNames[] = { "Type", "Time", "Pressed", "Keycode", "CookedKey", "ButtonStates", "Motion", "X", "Y", "NormX", "NormY", "Valuators" }; if (deviceIndex < 0) deviceIndex = PsychHIDGetDefaultKbQueueDevice(); if (!hidEventBuffer[deviceIndex]) return(0); PsychLockMutex(&hidEventBufferMutex[deviceIndex]); navail = hidEventBufferWritePos[deviceIndex] - hidEventBufferReadPos[deviceIndex]; // If nothing available and we're asked to wait for something, then wait: if ((navail == 0) && (maxWaitTimeSecs > 0)) { // Wait for something: PsychTimedWaitCondition(&hidEventBufferCondition[deviceIndex], &hidEventBufferMutex[deviceIndex], maxWaitTimeSecs); // Recompute number of available events: navail = hidEventBufferWritePos[deviceIndex] - hidEventBufferReadPos[deviceIndex]; } // Check if anything available, copy it if so: if (navail) { memcpy(&evt, &(hidEventBuffer[deviceIndex][hidEventBufferReadPos[deviceIndex] % hidEventBufferCapacity[deviceIndex]]), sizeof(PsychHIDEventRecord)); hidEventBufferReadPos[deviceIndex]++; } PsychUnlockMutex(&hidEventBufferMutex[deviceIndex]); if (navail) { // Return event struct: switch (evt.type) { case 0: // Press/Release case 1: // Motion/Valuator change PsychAllocOutStructArray(outArgIndex, kPsychArgOptional, 1, 12, FieldNames, &retevent); break; case 2: // Touch begin case 3: // Touch update/move case 4: // Touch end case 5: // Touch sequence compromised marker. If this one shows up - with magic touch point // id 0xffffffff btw., then the user script knows the sequence was cut short / aborted // by some higher priority consumer, e.g., some global gesture recognizer. PsychAllocOutStructArray(outArgIndex, kPsychArgOptional, 1, 12, FieldNames, &retevent); break; default: PsychErrorExitMsg(PsychError_internal, "Unhandled keyboard queue event type!"); } PsychSetStructArrayDoubleElement("Type", 0, (double) evt.type, retevent); PsychSetStructArrayDoubleElement("Time", 0, evt.timestamp, retevent); PsychSetStructArrayDoubleElement("Pressed", 0, (double) (evt.status & (1 << 0)) ? 1 : 0, retevent); PsychSetStructArrayDoubleElement("Keycode", 0, (double) evt.rawEventCode, retevent); PsychSetStructArrayDoubleElement("CookedKey", 0, (double) evt.cookedEventCode, retevent); PsychSetStructArrayDoubleElement("ButtonStates", 0, (double) evt.buttonStates, retevent); PsychSetStructArrayDoubleElement("Motion", 0, (double) (evt.status & (1 << 1)) ? 1 : 0, retevent); PsychSetStructArrayDoubleElement("X", 0, (double) evt.X, retevent); PsychSetStructArrayDoubleElement("Y", 0, (double) evt.Y, retevent); PsychSetStructArrayDoubleElement("NormX", 0, (double) evt.normX, retevent); PsychSetStructArrayDoubleElement("NormY", 0, (double) evt.normY, retevent); // Copy out all valuators (including redundant (X,Y) again: PsychAllocateNativeDoubleMat(1, evt.numValuators, 1, &v, &outMat); for (j = 0; j < evt.numValuators; j++) *(v++) = (double) evt.valuators[j]; PsychSetStructArrayNativeElement("Valuators", 0, outMat, retevent); return(navail - 1); } else { // Return empty matrix: PsychCopyOutDoubleMatArg(outArgIndex, kPsychArgOptional, 0, 0, 0, foo); return(0); } }
/* * PsychGSGetTextureFromMovie() -- Create an OpenGL texture map from a specific videoframe from given movie object. * * win = Window pointer of onscreen window for which a OpenGL texture should be created. * moviehandle = Handle to the movie object. * checkForImage = true == Just check if new image available, false == really retrieve the image, blocking if necessary. * timeindex = When not in playback mode, this allows specification of a requested frame by presentation time. * If set to -1, or if in realtime playback mode, this parameter is ignored and the next video frame is returned. * out_texture = Pointer to the Psychtoolbox texture-record where the new texture should be stored. * presentation_timestamp = A ptr to a double variable, where the presentation timestamp of the returned frame should be stored. * * Returns true (1) on success, false (0) if no new image available, -1 if no new image available and there won't be any in future. */ int PsychGSGetTextureFromMovie(PsychWindowRecordType *win, int moviehandle, int checkForImage, double timeindex, PsychWindowRecordType *out_texture, double *presentation_timestamp) { GstElement *theMovie; unsigned int failcount=0; double rate; double targetdelta, realdelta, frames; // PsychRectType outRect; GstBuffer *videoBuffer = NULL; gint64 bufferIndex; double deltaT = 0; GstEvent *event; if (!PsychIsOnscreenWindow(win)) { PsychErrorExitMsg(PsychError_user, "Need onscreen window ptr!!!"); } if (moviehandle < 0 || moviehandle >= PSYCH_MAX_MOVIES) { PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided."); } if ((timeindex!=-1) && (timeindex < 0 || timeindex >= 10000.0)) { PsychErrorExitMsg(PsychError_user, "Invalid timeindex provided."); } if (NULL == out_texture && !checkForImage) { PsychErrorExitMsg(PsychError_internal, "NULL-Ptr instead of out_texture ptr passed!!!"); } // Fetch references to objects we need: theMovie = movieRecordBANK[moviehandle].theMovie; if (theMovie == NULL) { PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided. No movie associated with this handle."); } // Allow context task to do its internal bookkeeping and cleanup work: PsychGSProcessMovieContext(movieRecordBANK[moviehandle].MovieContext, FALSE); // If this is a pure audio "movie" with no video tracks, we always return failed, // as those certainly don't have movie frames associated. if (movieRecordBANK[moviehandle].nrVideoTracks == 0) return((checkForImage) ? -1 : FALSE); // Get current playback rate: rate = movieRecordBANK[moviehandle].rate; // Is movie actively playing (automatic async playback, possibly with synced sound)? // If so, then we ignore the 'timeindex' parameter, because the automatic playback // process determines which frames should be delivered to PTB when. This function will // simply wait or poll for arrival/presence of a new frame that hasn't been fetched // in previous calls. if (0 == rate) { // Movie playback inactive. We are in "manual" mode: No automatic async playback, // no synced audio output. The user just wants to manually fetch movie frames into // textures for manual playback in a standard Matlab-loop. // First pass - checking for new image? if (checkForImage) { // Image for specific point in time requested? if (timeindex >= 0) { // Yes. We try to retrieve the next possible image for requested timeindex. // Seek to target timeindex: PsychGSSetMovieTimeIndex(moviehandle, timeindex, FALSE); } else { // No. We just retrieve the next frame, given the current position. // Nothing to do so far... } // Check for frame availability happens down there in the shared check code... } } // Should we just check for new image? If so, just return availability status: if (checkForImage) { PsychLockMutex(&movieRecordBANK[moviehandle].mutex); if ((((0 != rate) && movieRecordBANK[moviehandle].frameAvail) || ((0 == rate) && movieRecordBANK[moviehandle].preRollAvail)) && !gst_app_sink_is_eos(GST_APP_SINK(movieRecordBANK[moviehandle].videosink))) { // New frame available. Unlock and report success: //printf("PTB-DEBUG: NEW FRAME %d\n", movieRecordBANK[moviehandle].frameAvail); PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex); return(true); } // Is this the special case of a movie without video, but only sound? In that case // we always return a 'false' because there ain't no image to return. We check this // indirectly - If the imageBuffer is NULL then the video callback hasn't been called. if (oldstyle && (NULL == movieRecordBANK[moviehandle].imageBuffer)) { PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex); return(false); } // None available. Any chance there will be one in the future? if (gst_app_sink_is_eos(GST_APP_SINK(movieRecordBANK[moviehandle].videosink)) && movieRecordBANK[moviehandle].loopflag == 0) { // No new frame available and there won't be any in the future, because this is a non-looping // movie that has reached its end. PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex); return(-1); } else { // No new frame available yet: PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex); //printf("PTB-DEBUG: NO NEW FRAME\n"); return(false); } } // If we reach this point, then an image fetch is requested. If no new data // is available we shall block: PsychLockMutex(&movieRecordBANK[moviehandle].mutex); // printf("PTB-DEBUG: Blocking fetch start %d\n", movieRecordBANK[moviehandle].frameAvail); if (((0 != rate) && !movieRecordBANK[moviehandle].frameAvail) || ((0 == rate) && !movieRecordBANK[moviehandle].preRollAvail)) { // No new frame available. Perform a blocking wait: PsychTimedWaitCondition(&movieRecordBANK[moviehandle].condition, &movieRecordBANK[moviehandle].mutex, 10.0); // Recheck: if (((0 != rate) && !movieRecordBANK[moviehandle].frameAvail) || ((0 == rate) && !movieRecordBANK[moviehandle].preRollAvail)) { // Game over! Wait timed out after 10 secs. PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex); printf("PTB-ERROR: No new video frame received after timeout of 10 seconds! Something's wrong. Aborting fetch.\n"); return(FALSE); } // At this point we should have at least one frame available. // printf("PTB-DEBUG: After blocking fetch start %d\n", movieRecordBANK[moviehandle].frameAvail); } // We're here with at least one frame available and the mutex lock held. // Preroll case is simple: movieRecordBANK[moviehandle].preRollAvail = 0; // Perform texture fetch & creation: if (oldstyle) { // Reset frame available flag: movieRecordBANK[moviehandle].frameAvail = 0; // This will retrieve an OpenGL compatible pointer to the pixel data and assign it to our texmemptr: out_texture->textureMemory = (GLuint*) movieRecordBANK[moviehandle].imageBuffer; } else { // Active playback mode? if (0 != rate) { // Active playback mode: One less frame available after our fetch: movieRecordBANK[moviehandle].frameAvail--; if (PsychPrefStateGet_Verbosity()>4) printf("PTB-DEBUG: Pulling from videosink, %d buffers avail...\n", movieRecordBANK[moviehandle].frameAvail); // Clamp frameAvail to queue lengths: if ((int) gst_app_sink_get_max_buffers(GST_APP_SINK(movieRecordBANK[moviehandle].videosink)) < movieRecordBANK[moviehandle].frameAvail) { movieRecordBANK[moviehandle].frameAvail = gst_app_sink_get_max_buffers(GST_APP_SINK(movieRecordBANK[moviehandle].videosink)); } // This will pull the oldest video buffer from the videosink. It would block if none were available, // but that won't happen as we wouldn't reach this statement if none were available. It would return // NULL if the stream would be EOS or the pipeline off, but that shouldn't ever happen: videoBuffer = gst_app_sink_pull_buffer(GST_APP_SINK(movieRecordBANK[moviehandle].videosink)); } else { // Passive fetch mode: Use prerolled buffers after seek: // These are available even after eos... videoBuffer = gst_app_sink_pull_preroll(GST_APP_SINK(movieRecordBANK[moviehandle].videosink)); } // We can unlock early, thanks to videosink's internal buffering: PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex); if (videoBuffer) { // Assign pointer to videoBuffer's data directly: Avoids one full data copy compared to oldstyle method. out_texture->textureMemory = (GLuint*) GST_BUFFER_DATA(videoBuffer); // Assign pts presentation timestamp in pipeline stream time and convert to seconds: movieRecordBANK[moviehandle].pts = (double) GST_BUFFER_TIMESTAMP(videoBuffer) / (double) 1e9; if (GST_CLOCK_TIME_IS_VALID(GST_BUFFER_DURATION(videoBuffer))) deltaT = (double) GST_BUFFER_DURATION(videoBuffer) / (double) 1e9; bufferIndex = GST_BUFFER_OFFSET(videoBuffer); } else { printf("PTB-ERROR: No new video frame received in gst_app_sink_pull_buffer! Something's wrong. Aborting fetch.\n"); return(FALSE); } if (PsychPrefStateGet_Verbosity()>4) printf("PTB-DEBUG: ...done.\n"); } // Assign presentation_timestamp: if (presentation_timestamp) *presentation_timestamp = movieRecordBANK[moviehandle].pts; // Activate OpenGL context of target window: PsychSetGLContext(win); #if PSYCH_SYSTEM == PSYCH_OSX // Explicitely disable Apple's Client storage extensions. For now they are not really useful to us. glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE); #endif // Build a standard PTB texture record: PsychMakeRect(out_texture->rect, 0, 0, movieRecordBANK[moviehandle].width, movieRecordBANK[moviehandle].height); // Set NULL - special texture object as part of the PTB texture record: out_texture->targetSpecific.QuickTimeGLTexture = NULL; // Set texture orientation as if it were an inverted Offscreen window: Upside-down. out_texture->textureOrientation = 3; // We use zero client storage memory bytes: out_texture->textureMemorySizeBytes = 0; // Textures are aligned on 4 Byte boundaries because texels are RGBA8: out_texture->textureByteAligned = 4; // Assign texturehandle of our cached texture, if any, so it gets recycled now: out_texture->textureNumber = movieRecordBANK[moviehandle].cached_texture; // Let PsychCreateTexture() do the rest of the job of creating, setting up and // filling an OpenGL texture with content: PsychCreateTexture(out_texture); // After PsychCreateTexture() the cached texture object from our cache is used // and no longer available for recycling. We mark the cache as empty: // It will be filled with a new textureid for recycling if a texture gets // deleted in PsychMovieDeleteTexture().... movieRecordBANK[moviehandle].cached_texture = 0; // Detection of dropped frames: This is a heuristic. We'll see how well it works out... // TODO: GstBuffer videoBuffer provides special flags that should allow to do a more // robust job, although nothing's wrong with the current approach per se... if (rate && presentation_timestamp) { // Try to check for dropped frames in playback mode: // Expected delta between successive presentation timestamps: targetdelta = 1.0f / (movieRecordBANK[moviehandle].fps * rate); // Compute real delta, given rate and playback direction: if (rate > 0) { realdelta = *presentation_timestamp - movieRecordBANK[moviehandle].last_pts; if (realdelta < 0) realdelta = 0; } else { realdelta = -1.0 * (*presentation_timestamp - movieRecordBANK[moviehandle].last_pts); if (realdelta < 0) realdelta = 0; } frames = realdelta / targetdelta; // Dropped frames? if (frames > 1 && movieRecordBANK[moviehandle].last_pts >= 0) { movieRecordBANK[moviehandle].nr_droppedframes += (int) (frames - 1 + 0.5); } movieRecordBANK[moviehandle].last_pts = *presentation_timestamp; } // Unlock. if (oldstyle) { PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex); } else { gst_buffer_unref(videoBuffer); videoBuffer = NULL; } // Manually advance movie time, if in fetch mode: if (0 == rate) { // We are in manual fetch mode: Need to manually advance movie to next // media sample: event = gst_event_new_step(GST_FORMAT_BUFFERS, 1, 1.0, TRUE, FALSE); gst_element_send_event(theMovie, event); // Block until seek completed, failed, or timeout of 30 seconds reached: gst_element_get_state(theMovie, NULL, NULL, (GstClockTime) (30 * 1e9)); } return(TRUE); }
void PsychHIDOSKbQueueCheck(int deviceIndex) { double *hasKeyBeenDownOutput, *firstPressTimeOutput, *firstReleaseTimeOutput, *lastPressTimeOutput, *lastReleaseTimeOutput; psych_bool isFirstPressSpecified, isFirstReleaseSpecified, isLastPressSpecified, isLastReleaseSpecified; int i; // Get true keyboardqueue index assigned to deviceIndex from original user provided deviceIndex: deviceIndex = PsychHIDOSGetKbQueueDevice(deviceIndex, NULL); // Does Keyboard queue for this deviceIndex already exist? if (NULL == psychHIDKbQueueFirstPress[deviceIndex]) { // No. Bad bad... printf("PsychHID-ERROR: Tried to check non-existent keyboard queue for deviceIndex %i! Call KbQueueCreate first!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Invalid keyboard 'deviceIndex' specified. No queue for that device yet!"); } // Allocate output PsychAllocOutDoubleArg(1, FALSE, &hasKeyBeenDownOutput); isFirstPressSpecified = PsychAllocOutDoubleMatArg(2, FALSE, 1, 256, 1, &firstPressTimeOutput); isFirstReleaseSpecified = PsychAllocOutDoubleMatArg(3, FALSE, 1, 256, 1, &firstReleaseTimeOutput); isLastPressSpecified = PsychAllocOutDoubleMatArg(4, FALSE, 1, 256, 1, &lastPressTimeOutput); isLastReleaseSpecified = PsychAllocOutDoubleMatArg(5, FALSE, 1, 256, 1, &lastReleaseTimeOutput); // Initialize output if(isFirstPressSpecified) memset((void*) firstPressTimeOutput, 0, sizeof(double) * 256); if(isFirstReleaseSpecified) memset((void*) firstReleaseTimeOutput, 0, sizeof(double) * 256); if(isLastPressSpecified) memset((void*) lastPressTimeOutput, 0, sizeof(double) * 256); if(isLastReleaseSpecified) memset((void*) lastReleaseTimeOutput, 0, sizeof(double) * 256); *hasKeyBeenDownOutput=0; // Compute and assign output: PsychLockMutex(&KbQueueMutex); for (i = 0; i < 256; i++) { double lastRelease = psychHIDKbQueueLastRelease[deviceIndex][i]; double lastPress = psychHIDKbQueueLastPress[deviceIndex][i]; double firstRelease = psychHIDKbQueueFirstRelease[deviceIndex][i]; double firstPress = psychHIDKbQueueFirstPress[deviceIndex][i]; if (firstPress) { *hasKeyBeenDownOutput=1; if(isFirstPressSpecified) firstPressTimeOutput[i] = firstPress; psychHIDKbQueueFirstPress[deviceIndex][i] = 0; } if (firstRelease) { if(isFirstReleaseSpecified) firstReleaseTimeOutput[i] = firstRelease; psychHIDKbQueueFirstRelease[deviceIndex][i] = 0; } if (lastPress) { if(isLastPressSpecified) lastPressTimeOutput[i] = lastPress; psychHIDKbQueueLastPress[deviceIndex][i] = 0; } if (lastRelease) { if(isLastReleaseSpecified) lastReleaseTimeOutput[i] = lastRelease; psychHIDKbQueueLastRelease[deviceIndex][i] = 0; } } PsychUnlockMutex(&KbQueueMutex); return; }
PsychError PsychHIDOSKbQueueCreate(int deviceIndex, int numScankeys, int* scanKeys) { pRecDevice deviceRecord; // Valid number of keys? if (scanKeys && (numScankeys != 256)) { PsychErrorExitMsg(PsychError_user, "Second argument to KbQueueCreate must be a vector with 256 elements."); } // Do we finally have a valid keyboard or other suitable input device? // PsychHIDOSGetKbQueueDevice() will error out if no suitable device // for deviceIndex can be found. Otherwise it will return the HID // device record and remapped deviceIndex for use with our KbQueues: deviceIndex = PsychHIDOSGetKbQueueDevice(deviceIndex, &deviceRecord); // Keyboard queue for this deviceIndex already created? if (psychHIDKbQueueFirstPress[deviceIndex]) { // Yep. Release it, so we can start from scratch: PsychHIDOSKbQueueRelease(deviceIndex); } // Allocate and zero-init memory for tracking key presses and key releases: psychHIDKbQueueFirstPress[deviceIndex] = calloc(256, sizeof(double)); psychHIDKbQueueFirstRelease[deviceIndex] = calloc(256, sizeof(double)); psychHIDKbQueueLastPress[deviceIndex] = calloc(256, sizeof(double)); psychHIDKbQueueLastRelease[deviceIndex] = calloc(256, sizeof(double)); psychHIDKbQueueScanKeys[deviceIndex] = calloc(256, sizeof(int)); // Assign scanKeys vector, if any: if (scanKeys) { // Copy it: memcpy(psychHIDKbQueueScanKeys[deviceIndex], scanKeys, 256 * sizeof(int)); } else { // None provided. Enable all keys by default: memset(psychHIDKbQueueScanKeys[deviceIndex], 1, 256 * sizeof(int)); } // Create HIDQueue for device: queue[deviceIndex] = IOHIDQueueCreate(kCFAllocatorDefault, deviceRecord, 30, 0); if (NULL == queue[deviceIndex]) PsychErrorExitMsg(PsychError_system, "Failed to create event queue for detecting key press."); // Mark as a non-keyboard device, to start with: queueIsAKeyboard[deviceIndex] = FALSE; // Parse HID device to add all detected and selected keys: { // Add deviceRecord's elements to our queue, filtering unwanted keys via 'scanList'. // This code is almost identical to the enumeration code in PsychHIDKbCheck, to make sure we get // matching performance and behaviour and hopefully that it works on the latest problematic Apple // hardware, e.g., late 2013 MacBookAir and OSX 10.9: { uint32_t usage, usagePage; pRecElement currentElement, lastElement = NULL; // Step through the elements of the device and add matching ones: for (currentElement = HIDGetFirstDeviceElement(deviceRecord, kHIDElementTypeInput | kHIDElementTypeCollection); (currentElement != NULL) && (currentElement != lastElement); currentElement = HIDGetNextDeviceElement(currentElement, kHIDElementTypeInput | kHIDElementTypeCollection)) { // Keep track of last queried element: lastElement = currentElement; usage = IOHIDElementGetUsage(currentElement); usagePage = IOHIDElementGetUsagePage(currentElement); if (getenv("PSYCHHID_TELLME")) { printf("PTB-DEBUG: [KbQueueCreate]: ce %p page %d usage: %d isArray: %d\n", currentElement, usagePage, usage, IOHIDElementIsArray(currentElement)); } if (IOHIDElementGetType(currentElement) == kIOHIDElementTypeCollection) { CFArrayRef children = IOHIDElementGetChildren(currentElement); if (!children) continue; CFIndex idx, cnt = CFArrayGetCount(children); for (idx = 0; idx < cnt; idx++) { IOHIDElementRef tIOHIDElementRef = (IOHIDElementRef) CFArrayGetValueAtIndex(children, idx); if (tIOHIDElementRef && ((IOHIDElementGetType(tIOHIDElementRef) == kIOHIDElementTypeInput_Button) || (IOHIDElementGetType(tIOHIDElementRef) == kIOHIDElementTypeInput_ScanCodes))) { usage = IOHIDElementGetUsage(tIOHIDElementRef); if ((usage <= 256) && (usage >= 1) && ( (scanKeys == NULL) || (scanKeys[usage - 1] > 0) )) { // Add it for use in keyboard queue: PsychHIDOSKbElementAdd(tIOHIDElementRef, queue[deviceIndex], deviceIndex); } } } // Done with this currentElement, which was a collection of buttons/keys. // Iterate to next currentElement: continue; } // Classic path for non-collection elements: if(((usagePage == kHIDPage_KeyboardOrKeypad) || (usagePage == kHIDPage_Button)) && (usage <= 256) && (usage >= 1) && ( (scanKeys == NULL) || (scanKeys[usage - 1] > 0) ) ) { // Add it for use in keyboard queue: PsychHIDOSKbElementAdd(currentElement, queue[deviceIndex], deviceIndex); } } } } // Register "queue empty -> non-empty transition" callback: TODO Replace queue by reference to our keyboard queue struct: IOHIDQueueRegisterValueAvailableCallback(queue[deviceIndex], (IOHIDCallback) PsychHIDKbQueueCallbackFunction, (void*) (long) deviceIndex); // Create event buffer: PsychHIDCreateEventBuffer(deviceIndex); // Start the processing thread for this queue: PsychLockMutex(&KbQueueMutex); if (PsychCreateThread(&KbQueueThread[deviceIndex], NULL, KbQueueWorkerThreadMain, (void*) (long) deviceIndex)) { // We are so screwed: // Cleanup the mess: psychHIDKbQueueActive[deviceIndex] = FALSE; PsychUnlockMutex(&KbQueueMutex); // Whine a little bit: printf("PsychHID-ERROR: Start of keyboard queue processing for deviceIndex %i failed!\n", deviceIndex); PsychErrorExitMsg(PsychError_system, "Creation of keyboard queue background processing thread failed!"); } PsychUnlockMutex(&KbQueueMutex); // Ready to use this keybord queue. return(PsychError_none); }
static void PsychHIDKbQueueCallbackFunction(void *target, IOReturn result, void *sender) { // This routine is executed each time the queue transitions from empty to non-empty // The CFRunLoop of the thread in KbQueueWorkerThreadMain() is the one that executes here: IOHIDQueueRef queue = (IOHIDQueueRef) sender; IOHIDValueRef valueRef = NULL; int deviceIndex = (int) target; double timestamp; int eventValue; long keysUsage = -1; PsychHIDEventRecord evt; result=kIOReturnError; if (!queue) return; // Nothing we can do because we can't access queue, (shouldn't happen) while (1) { // This function only gets called when queue transitions from empty to non-empty // Therefore, we must process all available events in this while loop before // it will be possible for this function to be notified again. if (valueRef) { CFRelease(valueRef); valueRef = NULL; } // Dequeue next event from queue in a polling non-blocking fashion: valueRef = IOHIDQueueCopyNextValueWithTimeout(queue, 0.0); // Done? Exit, if so: if (!valueRef) break; // Get event value, e.g., the key state of a key or button 1 = pressed, 0 = released: eventValue = IOHIDValueGetIntegerValue(valueRef); // Get usage value, ie., the identity of the key: IOHIDElementRef element = IOHIDValueGetElement(valueRef); keysUsage = IOHIDElementGetUsage(element); // Get double GetSecs timestamp, computed from returned uint64 nanoseconds timestamp: timestamp = convertTime(IOHIDValueGetTimeStamp(valueRef)); // Don't bother with keysUsage of 0 (meaningless) or 1 (ErrorRollOver) for keyboards: if ((queueIsAKeyboard[deviceIndex]) && (keysUsage <= 1)) continue; // Clear ringbuffer event: memset(&evt, 0 , sizeof(evt)); // Cooked key code defaults to "unhandled", and stays that way for anything but keyboards: evt.cookedEventCode = -1; // For real keyboards we can compute cooked key codes: Requires OSX 10.5 or later. if (queueIsAKeyboard[deviceIndex]) { // Keyboard(ish) device. We can handle this under some conditions. // Init to a default of handled, but unmappable/ignored keycode: evt.cookedEventCode = 0; // Keypress event code available in mapping table? if (keysUsage < kHID2VKCSize) { // Yes: We try to map this to a character code: // Step 1: Map HID usage value to virtual keycode via LUT: uint16_t vcKey = kHID2VKC[keysUsage]; // Keep track of SHIFT keys as modifier keys: Bits 0 == Command, 1 == Shift, 2 == CapsLock, 3 == Alt/Option, 4 == CTRL if ((vcKey == kVKC_Shift || vcKey == kVKC_rShift) && (eventValue != 0)) modifierKeyState[deviceIndex] |= (1 << 1); if ((vcKey == kVKC_Shift || vcKey == kVKC_rShift) && (eventValue == 0)) modifierKeyState[deviceIndex] &= ~(1 << 1); // Keep track of ALT keys as modifier keys: if ((vcKey == kVKC_Option || vcKey == kVKC_rOption) && (eventValue != 0)) modifierKeyState[deviceIndex] |= (1 << 3); if ((vcKey == kVKC_Option || vcKey == kVKC_rOption) && (eventValue == 0)) modifierKeyState[deviceIndex] &= ~(1 << 3); // Keep track of CTRL keys as modifier keys: if ((vcKey == kVKC_Control || vcKey == kVKC_rControl) && (eventValue != 0)) modifierKeyState[deviceIndex] |= (1 << 4); if ((vcKey == kVKC_Control || vcKey == kVKC_rControl) && (eventValue == 0)) modifierKeyState[deviceIndex] &= ~(1 << 4); // Was this a CTRL + C interrupt request? if ((eventValue != 0) && (vcKey == 0x08) && (modifierKeyState[deviceIndex] & (1 << 4))) { // Yes: Tell the console input helper about it, so it can send interrupt // signals to the runtime and reenable keyboard input if appropriate: // Note: Not sure if the mutex exclusion is needed here, but better safe than sorry. PsychLockMutex(&KbQueueMutex); ConsoleInputHelper(-1); PsychUnlockMutex(&KbQueueMutex); } // Key press? if (eventValue != 0) { // Step 2: Translate virtual key code into unicode char: // Ok, this is the usual horrifying complexity of Apple's system. We use code // snippets found on StackOverflow, modified to suit our needs, e.g., we track // modifier keys manually, at least left and right ALT and SHIFT keys. We don't // care about other modifiers. TISInputSourceRef currentKeyboard = TISCopyCurrentKeyboardInputSource(); CFDataRef uchr = (CFDataRef) ((currentKeyboard) ? TISGetInputSourceProperty(currentKeyboard, kTISPropertyUnicodeKeyLayoutData) : NULL); const UCKeyboardLayout *keyboardLayout = (const UCKeyboardLayout*) ((uchr) ? CFDataGetBytePtr(uchr) : NULL); if (keyboardLayout) { UInt32 deadKeyState = 0; UniCharCount maxStringLength = 255; UniCharCount actualStringLength = 0; UniChar unicodeString[maxStringLength]; OSStatus status = UCKeyTranslate(keyboardLayout, vcKey, kUCKeyActionDown, modifierKeyState[deviceIndex], LMGetKbdType(), 0, &deadKeyState, maxStringLength, &actualStringLength, unicodeString); if ((actualStringLength == 0) && deadKeyState) { status = UCKeyTranslate(keyboardLayout, kVK_Space, kUCKeyActionDown, 0, LMGetKbdType(), 0, &deadKeyState, maxStringLength, &actualStringLength, unicodeString); } if((actualStringLength > 0) && (status == noErr)) { // Assign final cooked / mapped keycode: evt.cookedEventCode = (int) unicodeString[0]; // Send same keystroke character to console input helper. // In kbqueue-based ListenChar(1) mode, the helper will // inject/forward the character into the runtime: // Note: ConsoleInputHelper() should be safe to call without // mutex protection for >= 0 event codes. ConsoleInputHelper(evt.cookedEventCode); } } } } } PsychLockMutex(&KbQueueMutex); // Update records of first and latest key presses and releases if (eventValue != 0) { if (psychHIDKbQueueFirstPress[deviceIndex]) { // First key press timestamp: if (psychHIDKbQueueFirstPress[deviceIndex][keysUsage-1] == 0) { psychHIDKbQueueFirstPress[deviceIndex][keysUsage-1] = timestamp; } } if (psychHIDKbQueueLastPress[deviceIndex]) { // Last key press timestamp: psychHIDKbQueueLastPress[deviceIndex][keysUsage-1] = timestamp; } evt.status |= (1 << 0); } else { if (psychHIDKbQueueFirstRelease[deviceIndex]) { // First key release timestamp: if (psychHIDKbQueueFirstRelease[deviceIndex][keysUsage-1] == 0) psychHIDKbQueueFirstRelease[deviceIndex][keysUsage-1] = timestamp; } if (psychHIDKbQueueLastRelease[deviceIndex]) { // Last key release timestamp: psychHIDKbQueueLastRelease[deviceIndex][keysUsage-1] = timestamp; } evt.status &= ~(1 << 0); } // Update event buffer: evt.timestamp = timestamp; evt.rawEventCode = keysUsage; PsychHIDAddEventToEventBuffer(deviceIndex, &evt); // Tell waiting userspace (under KbQueueMutxex protection for better scheduling) something interesting has changed: PsychSignalCondition(&KbQueueCondition); PsychUnlockMutex(&KbQueueMutex); // Next while loop iteration to dequeue potentially more events: } // Done for this queue transition. Return to runloop. }
void PsychHIDOSKbQueueCheck(int deviceIndex) { double *hasKeyBeenDownOutput, *firstPressTimeOutput, *firstReleaseTimeOutput, *lastPressTimeOutput, *lastReleaseTimeOutput; psych_bool isFirstPressSpecified, isFirstReleaseSpecified, isLastPressSpecified, isLastReleaseSpecified; int i; if (deviceIndex < 0) { deviceIndex = PsychHIDGetDefaultKbQueueDevice(); // Ok, deviceIndex now contains our default keyboard to use - The first suitable keyboard. } if ((deviceIndex < 0) || (deviceIndex >= ndevices)) { // Out of range index: PsychErrorExitMsg(PsychError_user, "Invalid 'deviceIndex' specified. No such device!"); } // Does Keyboard queue for this deviceIndex already exist? if (NULL == psychHIDKbQueueFirstPress[deviceIndex]) { // No. Bad bad... printf("PsychHID-ERROR: Tried to check non-existent keyboard queue for deviceIndex %i! Call KbQueueCreate first!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Invalid 'deviceIndex' specified. No queue for that device yet!"); } // Allocate output PsychAllocOutDoubleArg(1, kPsychArgOptional, &hasKeyBeenDownOutput); isFirstPressSpecified = PsychAllocOutDoubleMatArg(2, kPsychArgOptional, 1, 256, 1, &firstPressTimeOutput); isFirstReleaseSpecified = PsychAllocOutDoubleMatArg(3, kPsychArgOptional, 1, 256, 1, &firstReleaseTimeOutput); isLastPressSpecified = PsychAllocOutDoubleMatArg(4, kPsychArgOptional, 1, 256, 1, &lastPressTimeOutput); isLastReleaseSpecified = PsychAllocOutDoubleMatArg(5, kPsychArgOptional, 1, 256, 1, &lastReleaseTimeOutput); // Initialize output if(isFirstPressSpecified) memset((void*) firstPressTimeOutput, 0, sizeof(double) * 256); if(isFirstReleaseSpecified) memset((void*) firstReleaseTimeOutput, 0, sizeof(double) * 256); if(isLastPressSpecified) memset((void*) lastPressTimeOutput, 0, sizeof(double) * 256); if(isLastReleaseSpecified) memset((void*) lastReleaseTimeOutput, 0, sizeof(double) * 256); *hasKeyBeenDownOutput=0; // Compute and assign output: PsychLockMutex(&KbQueueMutex); for (i = 0; i < 256; i++) { double lastRelease = psychHIDKbQueueLastRelease[deviceIndex][i]; double lastPress = psychHIDKbQueueLastPress[deviceIndex][i]; double firstRelease = psychHIDKbQueueFirstRelease[deviceIndex][i]; double firstPress = psychHIDKbQueueFirstPress[deviceIndex][i]; if (firstPress) { *hasKeyBeenDownOutput=1; if(isFirstPressSpecified) firstPressTimeOutput[i] = firstPress; psychHIDKbQueueFirstPress[deviceIndex][i] = 0; } if (firstRelease) { if(isFirstReleaseSpecified) firstReleaseTimeOutput[i] = firstRelease; psychHIDKbQueueFirstRelease[deviceIndex][i] = 0; } if (lastPress) { if(isLastPressSpecified) lastPressTimeOutput[i] = lastPress; psychHIDKbQueueLastPress[deviceIndex][i] = 0; } if (lastRelease) { if(isLastReleaseSpecified) lastReleaseTimeOutput[i] = lastRelease; psychHIDKbQueueLastRelease[deviceIndex][i] = 0; } } PsychUnlockMutex(&KbQueueMutex); return; }
void PsychHIDOSKbQueueStart(int deviceIndex) { LPDIRECTINPUTDEVICE8 kb; DIPROPDWORD dipdw; psych_bool queueActive; int i; if (deviceIndex < 0) { deviceIndex = PsychHIDGetDefaultKbQueueDevice(); // Ok, deviceIndex now contains our default keyboard to use - The first suitable keyboard. } if ((deviceIndex < 0) || (deviceIndex >= ndevices)) { // Out of range index: PsychErrorExitMsg(PsychError_user, "Invalid 'deviceIndex' specified. No such device!"); } // Does Keyboard queue for this deviceIndex already exist? if (NULL == psychHIDKbQueueFirstPress[deviceIndex]) { // No. Bad bad... printf("PsychHID-ERROR: Tried to start processing on non-existent keyboard queue for deviceIndex %i! Call KbQueueCreate first!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Invalid keyboard 'deviceIndex' specified. No queue for that device yet!"); } // Keyboard queue already stopped? Then we ain't nothing to do: if (psychHIDKbQueueActive[deviceIndex]) return; // Queue is inactive. Start it: // Will this be the first active queue, ie., aren't there any queues running so far? queueActive = FALSE; for (i = 0; i < PSYCH_HID_MAX_DEVICES; i++) { queueActive |= psychHIDKbQueueActive[i]; } PsychLockMutex(&KbQueueMutex); // Clear out current state for this queue: memset(psychHIDKbQueueFirstPress[deviceIndex] , 0, (256 * sizeof(double))); memset(psychHIDKbQueueFirstRelease[deviceIndex] , 0, (256 * sizeof(double))); memset(psychHIDKbQueueLastPress[deviceIndex] , 0, (256 * sizeof(double))); memset(psychHIDKbQueueLastRelease[deviceIndex] , 0, (256 * sizeof(double))); // Setup event mask, so events from our associated xinput device // get enqueued in our event queue: kb = GetXDevice(deviceIndex); // Device specific data format setup: switch (info[deviceIndex].dwDevType & 0xff) { case DI8DEVTYPE_KEYBOARD: if (DI_OK != kb->SetDataFormat(&c_dfDIKeyboard)) { PsychUnlockMutex(&KbQueueMutex); printf("PsychHID-ERROR: Tried to start processing on keyboard queue for deviceIndex %i, but setting dataformat failed!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Starting keyboard queue failed!"); } break; case DI8DEVTYPE_MOUSE: case DI8DEVTYPE_SCREENPOINTER: if (DI_OK != kb->SetDataFormat(&c_dfDIMouse2)) { PsychUnlockMutex(&KbQueueMutex); printf("PsychHID-ERROR: Tried to start processing on keyboard queue for deviceIndex %i, but setting dataformat failed!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Starting keyboard queue failed!"); } break; case DI8DEVTYPE_JOYSTICK: if (DI_OK != kb->SetDataFormat(&c_dfDIJoystick2)) { PsychUnlockMutex(&KbQueueMutex); printf("PsychHID-ERROR: Tried to start processing on keyboard queue for deviceIndex %i, but setting dataformat failed!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Starting keyboard queue failed!"); } break; } // Set device event buffer size to 256 elements: dipdw.diph.dwSize = sizeof(DIPROPDWORD); dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER); dipdw.diph.dwObj = 0; dipdw.diph.dwHow = DIPH_DEVICE; dipdw.dwData = 256; if (DI_OK != kb->SetProperty(DIPROP_BUFFERSIZE, &dipdw.diph)) { PsychUnlockMutex(&KbQueueMutex); printf("PsychHID-ERROR: Tried to start processing on keyboard queue for deviceIndex %i, but setting buffersize on device failed!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Starting keyboard queue failed!"); } // Enable state-change event notifications: if (DI_OK != kb->SetEventNotification(hEvent)) { PsychUnlockMutex(&KbQueueMutex); printf("PsychHID-ERROR: Tried to start processing on keyboard queue for deviceIndex %i, but setting device state notifications failed!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Starting keyboard queue failed!"); } if (DI_OK != kb->Acquire()) { PsychUnlockMutex(&KbQueueMutex); printf("PsychHID-ERROR: Tried to start processing on keyboard queue for deviceIndex %i, but acquiring device failed!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Starting keyboard queue failed!"); } // Mark this queue as logically started: psychHIDKbQueueActive[deviceIndex] = TRUE; // Queue started. PsychUnlockMutex(&KbQueueMutex); // If other queues are already active then we're done: if (queueActive) return; // No other active queues. We are the first one. // Start the common processing thread for all queues: PsychLockMutex(&KbQueueMutex); KbQueueThreadTerminate = FALSE; if (PsychCreateThread(&KbQueueThread, NULL, KbQueueWorkerThreadMain, NULL)) { // We are soo screwed: // Cleanup the mess: psychHIDKbQueueActive[deviceIndex] = FALSE; PsychUnlockMutex(&KbQueueMutex); // Whine a little bit: printf("PsychHID-ERROR: Start of keyboard queue processing failed!\n"); PsychErrorExitMsg(PsychError_system, "Creation of keyboard queue background processing thread failed!"); } // Up and running, we're done! PsychUnlockMutex(&KbQueueMutex); return; }
void PsychHIDOSKbQueueStop(int deviceIndex) { LPDIRECTINPUTDEVICE8 kb; psych_bool queueActive; int i; if (deviceIndex < 0) { deviceIndex = PsychHIDGetDefaultKbQueueDevice(); // Ok, deviceIndex now contains our default keyboard to use - The first suitable keyboard. } if ((deviceIndex < 0) || (deviceIndex >= ndevices)) { // Out of range index: PsychErrorExitMsg(PsychError_user, "Invalid 'deviceIndex' specified. No such device!"); } // Keyboard queue for this deviceIndex already exists? if (NULL == psychHIDKbQueueFirstPress[deviceIndex]) { // No. Nothing to do then. return; } // Keyboard queue already stopped? if (!psychHIDKbQueueActive[deviceIndex]) return; // Get device: kb = GetXDevice(deviceIndex); // Queue is active. Stop it: PsychLockMutex(&KbQueueMutex); // Release the device: if (DI_OK != kb->Unacquire()) { PsychUnlockMutex(&KbQueueMutex); printf("PsychHID-ERROR: Tried to stop processing on keyboard queue for deviceIndex %i, but releasing device failed!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Stopping keyboard queue failed!"); } // Disable state-change event notifications: if (DI_OK != kb->SetEventNotification(NULL)) { PsychUnlockMutex(&KbQueueMutex); printf("PsychHID-ERROR: Tried to stop processing on keyboard queue for deviceIndex %i, but disabling device state notifications failed!\n", deviceIndex); PsychErrorExitMsg(PsychError_user, "Stopping keyboard queue failed!"); } // Mark queue logically stopped: psychHIDKbQueueActive[deviceIndex] = FALSE; PsychUnlockMutex(&KbQueueMutex); // Was this the last active queue? queueActive = FALSE; for (i = 0; i < PSYCH_HID_MAX_DEVICES; i++) { queueActive |= psychHIDKbQueueActive[i]; } // If more queues are active then we're done: if (queueActive) return; // No more active queues. Shutdown the common processing thread: PsychLockMutex(&KbQueueMutex); KbQueueThreadTerminate = TRUE; // Done. PsychUnlockMutex(&KbQueueMutex); // Shutdown the thread, wait for its termination: PsychDeleteThread(&KbQueueThread); KbQueueThreadTerminate = FALSE; // printf("DEBUG: THREAD JOINED.\n"); fflush(NULL); return; }
void PsychHIDOSKbTriggerWait(int deviceIndex, int numScankeys, int* scanKeys) { int keyMask[256]; int i; double t, tc; if (deviceIndex < 0) { deviceIndex = PsychHIDGetDefaultKbQueueDevice(); // Ok, deviceIndex now contains our default keyboard to use - The first suitable keyboard. } if ((deviceIndex < 0) || (deviceIndex >= ndevices)) { // Out of range index: PsychErrorExitMsg(PsychError_user, "Invalid 'deviceIndex' specified. No such device!"); } if(psychHIDKbQueueFirstPress[deviceIndex]) PsychErrorExitMsg(PsychError_user, "A queue for this device is already running, you must call KbQueueRelease() before invoking KbTriggerWait."); // Create a keyboard queue for this deviceIndex: memset(&keyMask[0], 0, sizeof(keyMask)); for (i = 0; i < numScankeys; i++) { if (scanKeys[i] < 1 || scanKeys[i] > 256) PsychErrorExitMsg(PsychError_user, "Invalid entry for triggerKey specified. Not in valid range 1 - 256!"); keyMask[scanKeys[i] - 1] = 1; } // Create keyboard queue with proper mask: PsychHIDOSKbQueueCreate(deviceIndex, 256, &keyMask[0]); PsychHIDOSKbQueueStart(deviceIndex); PsychLockMutex(&KbQueueMutex); // Scan for trigger key: while (1) { // Wait until something changes in a keyboard queue: PsychWaitCondition(&KbQueueCondition, &KbQueueMutex); // Check if our queue had one of the dedicated trigger keys pressed: for (i = 0; i < numScankeys; i++) { // Break out of scan loop if key pressed: if (psychHIDKbQueueFirstPress[deviceIndex][scanKeys[i] - 1] != 0) break; } // Triggerkey pressed? if ((i < numScankeys) && (psychHIDKbQueueFirstPress[deviceIndex][scanKeys[i] - 1] != 0)) break; // No change for our trigger keys. Repeat scan loop. } // If we reach this point, we know some triggerkey has been pressed. As we aborted // the scan on detection of the first pressed key, we can't be certain we caught the // key with the earliest key press, maybe one of the untested keys was pressed even // earlier. Therefore do another pass over all keys to find the pressed one with the // earliest (minimum) pressed time: t = DBL_MAX; for (i = 0; i < numScankeys; i++) { tc = psychHIDKbQueueFirstPress[deviceIndex][scanKeys[i] - 1]; if ((tc != 0) && (tc <= t)) t = tc; } // Done. Release the lock: PsychUnlockMutex(&KbQueueMutex); // Stop and release the queue: PsychHIDOSKbQueueStop(deviceIndex); PsychHIDOSKbQueueRelease(deviceIndex); // Return timestamp: PsychCopyOutDoubleArg(1, kPsychArgOptional, t); return; }
// This is the event dequeue & process function which updates // Keyboard queue state. It can be called with 'blockingSinglepass' // set to TRUE to process exactly one event, if called from the // background keyboard queue processing thread. Alternatively it // can be called synchronously from KbQueueCheck with a setting of FALSE // to iterate over all available events and process them instantaneously: void KbQueueProcessEvents(psych_bool blockingSinglepass) { LPDIRECTINPUTDEVICE8 kb; DIDEVICEOBJECTDATA event; HRESULT rc; DWORD dwItems; double tnow; unsigned int i, keycode, keystate; PsychHIDEventRecord evt; WORD asciiValue[2]; UCHAR keyboardState[256]; while (1) { // Single pass or multi-pass? if (blockingSinglepass) { // Wait until at least one event available and dequeue it: // We use a timeout of 100 msecs. WaitForSingleObject(hEvent, 100); } else { // Check if event available, dequeue it, if so. Abort // processing if no new event available, aka queue empty: // TODO if (!XCheckTypedEvent(thread_dpy, GenericEvent, &KbQueue_xevent)) break; } // Take timestamp: PsychGetAdjustedPrecisionTimerSeconds(&tnow); // Need the lock from here on: PsychLockMutex(&KbQueueMutex); // Do a sweep over all keyboard devices whose queues are active: for (i = 0; i < (unsigned int) ndevices; i++) { // Skip this one if inactive: if (!psychHIDKbQueueActive[i]) continue; // Check this device: kb = GetXDevice(i); // Fetch one item from the buffer: // event.dwTimeStamp = Timestamp in msecs of timeGetTime() timebase. // event.dwSequence = Sequence number. // Fetch from this device, item-by-item, until nothing more to fetch: while (TRUE) { // Try one fetch from this device: dwItems = 1; rc = kb->GetDeviceData(sizeof(DIDEVICEOBJECTDATA), &event, &dwItems, 0); // If failed or nothing more to fetch, break out of fetch loop: if (!SUCCEEDED(rc) || (0 == dwItems)) break; // Clear ringbuffer event: memset(&evt, 0 , sizeof(evt)); // Init character code to "unmapped": It will stay like that for anything but real keyboards: evt.cookedEventCode = -1; // Map to key code and key state: keycode = event.dwOfs & 0xff; keystate = event.dwData & 0x80; // Remap keycode into target slot in our arrays, depending on input device: switch (info[i].dwDevType & 0xff) { case DI8DEVTYPE_KEYBOARD: // Try to map scancode to ascii character: memset(keyboardState, 0, sizeof(keyboardState)); if (GetAsyncKeyState(VK_SHIFT)) keyboardState[VK_SHIFT] = 0xff; if ((1 == ToAsciiEx(MapVirtualKeyEx(keycode, 1, GetKeyboardLayout(0)), keycode, keyboardState, (LPWORD) &(asciiValue[0]), 0, GetKeyboardLayout(0)))) { // Mapped to single char: Return it as cooked keycode: evt.cookedEventCode = (int) (asciiValue[0] & 0xff); } else { // Could not map key to valid ascii character: Mark as "not mapped" aka zero: evt.cookedEventCode = 0; } // Map scancode 'keycode' to virtual key code 'keycode': keycode = PsychHIDOSMapKey(keycode); break; case DI8DEVTYPE_MOUSE: case DI8DEVTYPE_SCREENPOINTER: // Button event? Otherwise skip it. if (keycode < 3 * sizeof(LONG)) continue; // Correct for buttons offset in data structure DIMOUSESTATE2: keycode -= 3 * sizeof(LONG); break; case DI8DEVTYPE_JOYSTICK: // Button event? Otherwise skip it. if (keycode < (8 * sizeof(LONG) + 4 * sizeof(DWORD))) continue; // Correct for buttons offset in data structure DIJOYSTATE2: keycode -= (8 * sizeof(LONG) + 4 * sizeof(DWORD)); // Also skip if beyond button array: if (keycode >= 128) continue; break; default: // Unkown device -- Skip it. continue; } // This keyboard queue interested in this keycode? if (psychHIDKbQueueScanKeys[i][keycode] != 0) { // Yes: The queue wants to receive info about this key event. // Press or release? if (keystate) { // Enqueue key press. Always in the "last press" array, because any // press at this time is the best candidate for the last press. // Only enqeue in "first press" if there wasn't any registered before, // ie., the slot is so far empty: if (psychHIDKbQueueFirstPress[i][keycode] == 0) psychHIDKbQueueFirstPress[i][keycode] = tnow; psychHIDKbQueueLastPress[i][keycode] = tnow; evt.status |= (1 << 0); } else { // Enqueue key release. See logic above: if (psychHIDKbQueueFirstRelease[i][keycode] == 0) psychHIDKbQueueFirstRelease[i][keycode] = tnow; psychHIDKbQueueLastRelease[i][keycode] = tnow; evt.status &= ~(1 << 0); // Clear cooked keycode - We don't record key releases this way: if (evt.cookedEventCode > 0) evt.cookedEventCode = 0; } // Update event buffer: evt.timestamp = tnow; evt.rawEventCode = keycode + 1; PsychHIDAddEventToEventBuffer(i, &evt); // Tell waiting userspace (under KbQueueMutex protection for better scheduling) something interesting has changed: PsychSignalCondition(&KbQueueCondition); } // Next fetch iteration for this device... } // Check next device... } // Done with shared data access: PsychUnlockMutex(&KbQueueMutex); // Done if we were only supposed to handle one sweep, which we did: if (blockingSinglepass) break; } return; }