// 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);
}
/*
* PsychAsyncCreateMovie() -- Open a movie file in the background.
*
* This function is called by SCREENOpenMovie as main-function of
* a new Posix-Thread for background movie loading. It simply calls
* PsychCreateMovie(), waiting for it to return a new moviehandle.
* Then it returns those info and terminates.
* -> By calling PsychCreateMovie from the run-function of a dedicated
* Posix-Thread which runs independent of the main Matlab/PTB Thread with
* non-realtime priority, we can do the work of opening a Quicktime movie
* in the background, hopefully not affecting the timing of the main PTB
* thread too much.
*/
void* PsychAsyncCreateMovie(void* inmovieinfo)
{
int rc;
PsychAsyncMovieInfo* movieinfo = (PsychAsyncMovieInfo*) inmovieinfo;
// The special value -1000 tells PsychCreateMovie to not output any error-
// messages as this could easily crash Matlab/Octave.
int mymoviehandle=-1000;
// Reduce our scheduling priority to the minimum value of zero, so
// we do not interfere too much with the PTB main thread:
if ((rc=PsychSetThreadPriority(NULL, 0, 0))!=0) {
printf("PTB-WARNING: In PsychAsyncCreateMovie(): Failed to lower my priority to non-realtime [System errorcode %i]. Expect timing problems for movie playback!", rc);
}
// Execute our normal OpenMovie function: This does the hard work:
PsychCreateMovie(&(movieinfo->windowRecord), movieinfo->moviename, movieinfo->preloadSecs, &mymoviehandle, movieinfo->asyncFlag, movieinfo->specialFlags1);
// Ok, either we have a moviehandle to a valid movie, or we failed, which would
// be signalled to the calling function via some negative moviehandle:
movieinfo->moviehandle = mymoviehandle; // Return moviehandle.
movieinfo->asyncstate = 2; // Set state to "Completed"
// Exit from the routine. This will automatically terminate our Thread.
return(NULL);
}
// Async processing thread for keyboard events:
static void *KbQueueWorkerThreadMain(void *inarg) {
int deviceIndex = (int) inarg;
int rc;
// Switch ourselves (NULL) to RT scheduling: We promise to use / require at most (0+1) == 1 msec every
// 10 msecs and allow for wakeup delay/jitter of up to 2 msecs -- perfectly reasonable, given that we
// only do minimal << 1 msec processing, only at the timescale of human reaction times, and driven by
// input devices with at least 4+/-4 msecs jitter at 8 msec USB polling frequency.
if ((rc = PsychSetThreadPriority(NULL, 2, 0)) > 0) {
printf("PsychHID: KbQueueCreate: Failed to switch to realtime priority [%s].\n", strerror(rc));
}
// Keep a global reference to the runloop, as we need it in KbQueueRelease to get this thread to exit:
psychHIDKbQueueCFRunLoopRef[deviceIndex] = (CFRunLoopRef) CFRunLoopGetCurrent();
CFRetain(psychHIDKbQueueCFRunLoopRef[deviceIndex]);
// Add HID queue to current runloop:
IOHIDQueueScheduleWithRunLoop(queue[deviceIndex], psychHIDKbQueueCFRunLoopRef[deviceIndex], kCFRunLoopDefaultMode);
// Start the run loop, code execution will block here until run loop is stopped again by PsychHIDKbQueueRelease
// Meanwhile, the run loop of this thread will be responsible for executing code below in PsychHIDKbQueueCalbackFunction
while (CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false) == kCFRunLoopRunTimedOut) {};
// Remove HID queue from current runloop:
IOHIDQueueUnscheduleFromRunLoop(queue[deviceIndex], psychHIDKbQueueCFRunLoopRef[deviceIndex], kCFRunLoopDefaultMode);
// Done. Die peacefully:
return(NULL);
}
PsychError SCREENOpenMovie(void)
{
PsychWindowRecordType *windowRecord;
char *moviefile;
char *movieOptions;
char dummmyOptions[1];
int moviehandle = -1;
int framecount;
double durationsecs;
double framerate;
double aspectRatio;
int width;
int height;
int asyncFlag = 0;
int specialFlags1 = 0;
static psych_bool firstTime = TRUE;
double preloadSecs = 1;
int rc;
int pixelFormat = 4;
int maxNumberThreads = -1;
if (firstTime) {
// Setup asyncopeninfo on first invocation:
firstTime = FALSE;
asyncmovieinfo.asyncstate = 0; // State = No async open in progress.
}
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()) {PsychGiveHelp(); return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(8)); // Max. 8 input args.
PsychErrorExit(PsychRequireNumInputArgs(1)); // Min. 1 input args required.
PsychErrorExit(PsychCapNumOutputArgs(7)); // Max. 7 output args.
// Get the window record from the window record argument and get info from the window record
windowRecord = NULL;
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, FALSE, &windowRecord);
// Only onscreen windows allowed:
if(windowRecord && !PsychIsOnscreenWindow(windowRecord)) {
PsychErrorExitMsg(PsychError_user, "OpenMovie called on something else than an onscreen window.");
}
// Get the movie name string:
moviefile = NULL;
PsychAllocInCharArg(2, kPsychArgRequired, &moviefile);
// Get the (optional) asyncFlag:
PsychCopyInIntegerArg(3, FALSE, &asyncFlag);
PsychCopyInDoubleArg(4, FALSE, &preloadSecs);
if (preloadSecs < 0 && preloadSecs!= -1 && preloadSecs!= -2) PsychErrorExitMsg(PsychError_user, "OpenMovie called with invalid (negative, but not equal -1) 'preloadSecs' argument!");
// Get the (optional) specialFlags1:
PsychCopyInIntegerArg(5, FALSE, &specialFlags1);
if (specialFlags1 < 0) PsychErrorExitMsg(PsychError_user, "OpenMovie called with invalid 'specialFlags1' setting! Only positive values allowed.");
// Get the (optional) pixelFormat:
PsychCopyInIntegerArg(6, FALSE, &pixelFormat);
if (pixelFormat < 1 || pixelFormat > 10) PsychErrorExitMsg(PsychError_user, "OpenMovie called with invalid 'pixelFormat' setting! Only values 1 to 10 are allowed.");
// Get the (optional) maxNumberThreads:
PsychCopyInIntegerArg(7, FALSE, &maxNumberThreads);
if (maxNumberThreads < -1) PsychErrorExitMsg(PsychError_user, "OpenMovie called with invalid 'maxNumberThreads' setting! Only values of -1 or greater are allowed.");
// Get the (optional) movie options string: As PsychAllocInCharArg() no-ops if
// the optional string isn't provided, we need to point movieOptions to an empty
// 0-terminated string by default, so we don't have a dangling pointer:
dummmyOptions[0] = 0;
movieOptions = &dummmyOptions[0];
PsychAllocInCharArg(8, FALSE, &movieOptions);
// Queueing of a new movie for seamless playback requested?
if (asyncFlag & 2) {
// Yes. Do a special call, just passing the moviename of the next
// movie to play. Pass the relevant moviehandle as retrieved from
// preloadSecs:
moviehandle = (int) preloadSecs;
preloadSecs = 0;
PsychCreateMovie(windowRecord, moviefile, preloadSecs, &moviehandle, asyncFlag, specialFlags1, pixelFormat, maxNumberThreads, movieOptions);
if (moviehandle == -1) PsychErrorExitMsg(PsychError_user, "Could not queue new moviefile for gapless playback.");
return(PsychError_none);
}
// Asynchronous Open operation in progress or requested?
if ((asyncmovieinfo.asyncstate == 0) && !(asyncFlag & 1)) {
// No. We should just synchronously open the movie:
// Try to open the named 'moviefile' and create & initialize a corresponding movie object.
// A handle to the movie object is returned upon successfull operation.
PsychCreateMovie(windowRecord, moviefile, preloadSecs, &moviehandle, asyncFlag, specialFlags1, pixelFormat, maxNumberThreads, movieOptions);
}
else {
// Asynchronous open operation requested or running:
switch(asyncmovieinfo.asyncstate) {
case 0: // No async open running, but async open requested
// Fill all information needed for opening the movie into the info struct:
asyncmovieinfo.asyncstate = 1; // Mark state as "Operation in progress"
asyncmovieinfo.moviename = strdup(moviefile);
asyncmovieinfo.preloadSecs = preloadSecs;
asyncmovieinfo.asyncFlag = asyncFlag;
asyncmovieinfo.specialFlags1 = specialFlags1;
asyncmovieinfo.pixelFormat = pixelFormat;
asyncmovieinfo.maxNumberThreads = maxNumberThreads;
asyncmovieinfo.movieOptions = strdup(movieOptions);
if (windowRecord) {
memcpy(&asyncmovieinfo.windowRecord, windowRecord, sizeof(PsychWindowRecordType));
} else {
memset(&asyncmovieinfo.windowRecord, 0, sizeof(PsychWindowRecordType));
}
asyncmovieinfo.moviehandle = -1;
// Increase our scheduling priority to basic RT priority: This way we should get
// more cpu time for our PTB main thread than the async. background prefetch-thread:
// On Windows we must not go higher than basePriority 1 (HIGH PRIORITY) or bad interference can happen.
// On OS/X we use basePriority 2 for robust realtime, using up to (4+1) == 5 msecs of time in every 10 msecs slice, allowing for up to 1 msec jitter/latency for ops.
// On Linux we just use standard basePriority 2 RT-FIFO scheduling and trust the os to do the right thing.
if ((rc=PsychSetThreadPriority(NULL, ((PSYCH_SYSTEM == PSYCH_WINDOWS) ? 1 : 2), ((PSYCH_SYSTEM == PSYCH_OSX) ? 4 : 0)))!=0) {
printf("PTB-WARNING: In OpenMovie(): Failed to raise priority of main thread [System error %i]. Expect movie timing problems.\n", rc);
}
// Start our own movie loader Posix-Thread:
PsychCreateThread(&asyncmovieinfo.pid, NULL, PsychAsyncCreateMovie, &asyncmovieinfo);
// Async movie open initiated. We return control to host environment:
return(PsychError_none);
break;
case 1: // Async open operation in progress, but not yet finished.
// Should we wait for completion or just return?
if (asyncFlag & 1) {
// Async poll requested. We just return -1 to signal that open isn't finished yet:
PsychCopyOutDoubleArg(1, TRUE, -1);
return(PsychError_none);
}
// We fall through to case 2 - Wait for "Load operation successfully finished."
// Fall through.
case 2: // Async open operation finished. Parse asyncinfo struct and return it to host environment:
// We need to join our terminated worker thread to release its ressources. If the worker-thread
// isn't done yet (fallthrough from case 1 for sync. wait), this join will block us until worker
// completes:
PsychDeleteThread(&asyncmovieinfo.pid);
asyncmovieinfo.asyncstate = 0; // Reset state to idle:
moviehandle = asyncmovieinfo.moviehandle;
// Release options string:
free(asyncmovieinfo.movieOptions);
// Movie successfully opened?
if (moviehandle < 0) {
// Movie loading failed for some reason.
printf("PTB-ERROR: When trying to asynchronously load movie '%s', the operation failed! Reasons given above.\n", asyncmovieinfo.moviename);
free(asyncmovieinfo.moviename);
PsychErrorExitMsg(PsychError_user, "Asynchronous loading of the movie failed.");
}
free(asyncmovieinfo.moviename);
// We can fall out of the switch statement and continue with the standard synchronous load code as if
// the movie had been loaded synchronously.
break;
default:
PsychErrorExitMsg(PsychError_internal, "Unhandled async movie state condition encountered! BUG!!");
}
}
// Upon sucessfull completion, we'll have a valid handle in 'moviehandle'.
PsychCopyOutDoubleArg(1, TRUE, (double) moviehandle);
// Retrieve infos about new movie:
// Is the "count" output argument (total number of frames) requested by user?
if (PsychGetNumOutputArgs() > 5) {
// Yes. Query the framecount (expensive!) and return it:
PsychGetMovieInfos(moviehandle, &width, &height, &framecount, &durationsecs, &framerate, NULL, &aspectRatio);
PsychCopyOutDoubleArg(6, TRUE, (double) framecount);
}
else {
// No. Don't compute and return it.
PsychGetMovieInfos(moviehandle, &width, &height, NULL, &durationsecs, &framerate, NULL, &aspectRatio);
}
PsychCopyOutDoubleArg(2, FALSE, (double) durationsecs);
PsychCopyOutDoubleArg(3, FALSE, (double) framerate);
PsychCopyOutDoubleArg(4, FALSE, (double) width);
PsychCopyOutDoubleArg(5, FALSE, (double) height);
PsychCopyOutDoubleArg(7, FALSE, (double) aspectRatio);
// Ready!
return(PsychError_none);
}
PsychError SCREENGetMouseHelper(void)
{
const char *valuatorInfo[]={"label", "min", "max", "resolution", "mode", "sourceID"};
int numValuatorStructFieldNames = 6;
int numIValuators = 0;
PsychGenericScriptType *valuatorStruct = NULL;
#if PSYCH_SYSTEM == PSYCH_OSX
Point mouseXY;
UInt32 buttonState;
double *buttonArray;
int numButtons, i;
psych_bool doButtonArray;
PsychWindowRecordType *windowRecord;
//all subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//cap the numbers of inputs and outputs
PsychErrorExit(PsychCapNumInputArgs(3)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(6)); //The maximum number of outputs
//Buttons.
// The only way I know to detect the number number of mouse buttons is directly via HID. The device reports
//that information but OS X seems to ignore it above the level of the HID driver, that is, no OS X API above the HID driver
//exposes it. So GetMouse.m function calls PsychHID detect the number of buttons and then passes that value to GetMouseHelper
//which returns that number of button values in a vector.
PsychCopyInIntegerArg(1, kPsychArgRequired, &numButtons);
if(numButtons > 32)
PsychErrorExitMsg(PsychErorr_argumentValueOutOfRange, "numButtons must not exceed 32");
// Special codes -10 to -15? --> Console keyboard queries:
if(numButtons <= -10 && numButtons >= -15) {
ConsoleInputHelper((int) numButtons);
return(PsychError_none);
}
if(numButtons < 1)
PsychErrorExitMsg(PsychErorr_argumentValueOutOfRange, "numButtons must exceed 1");
doButtonArray=PsychAllocOutDoubleMatArg(3, kPsychArgOptional, (int)1, (int)numButtons, (int)1, &buttonArray);
if(doButtonArray){
buttonState=GetCurrentButtonState();
for(i=0;i<numButtons;i++)
buttonArray[i]=(double)(buttonState & (1<<i));
}
// Get cursor position:
#ifndef __LP64__
// 32-Bit Carbon version:
GetGlobalMouse(&mouseXY);
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double)mouseXY.h);
PsychCopyOutDoubleArg(2, kPsychArgOptional, (double)mouseXY.v);
#else
// 64-Bit HIToolbox version (OSX 10.5 and later):
HIPoint outPoint;
HIGetMousePosition(kHICoordSpaceScreenPixel, NULL, &outPoint);
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double) outPoint.x);
PsychCopyOutDoubleArg(2, kPsychArgOptional, (double) outPoint.y);
#endif
// Return optional keyboard input focus status:
if (numButtons > 0) {
// Window provided?
// We only have the function GetUserFocusWindow on 32-Bit Carbon.
// We have a drop-in replacement in OSX/PsychCocoaGlue.c for 64-Bit Cocoa.
if (PsychIsWindowIndexArg(2)) {
// Yes: Check if it has focus.
PsychAllocInWindowRecordArg(2, TRUE, &windowRecord);
if (!PsychIsOnscreenWindow(windowRecord)) {
PsychErrorExitMsg(PsychError_user, "Provided window handle isn't an onscreen window, as required.");
}
PsychCopyOutDoubleArg(4, kPsychArgOptional, (double) (GetUserFocusWindow() == windowRecord->targetSpecific.windowHandle) ? 1 : 0);
} else
{
// No. Just always return "has focus":
PsychCopyOutDoubleArg(4, kPsychArgOptional, (double) 1);
}
}
// Return optional valuator values: Unimplemented on OS/X. Just return an empty matrix.
// The buttonArray is just a dummy assignment without any meaning.
PsychCopyOutDoubleMatArg(5, kPsychArgOptional, (int) 1, (int) 0, (int) 1, buttonArray);
PsychCopyOutDoubleMatArg(6, kPsychArgOptional, (int) 1, (int) 0, (int) 1, buttonArray);
#endif
#if PSYCH_SYSTEM == PSYCH_WINDOWS
static unsigned char disabledKeys[256];
static unsigned char firsttime = 1;
int keysdown, i, priorityLevel;
unsigned char keyState[256];
double* buttonArray;
double numButtons, timestamp;
PsychNativeBooleanType* buttonStates;
POINT point;
HANDLE currentProcess;
DWORD oldPriority = NORMAL_PRIORITY_CLASS;
const DWORD realtime_class = REALTIME_PRIORITY_CLASS;
PsychWindowRecordType *windowRecord;
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
// Retrieve optional number of mouse buttons:
numButtons = 0;
PsychCopyInDoubleArg(1, FALSE, &numButtons);
// Are we operating in 'GetMouseHelper' mode? numButtons>=0 indicates this.
if (numButtons>=0) {
// GetMouse-Mode: Return mouse button states and mouse cursor position:
PsychAllocOutDoubleMatArg(3, kPsychArgOptional, (int)1, (int)3, (int)1, &buttonArray);
// Query and return mouse button state:
PsychGetMouseButtonState(buttonArray);
// Query and return cursor position in global coordinates:
GetCursorPos(&point);
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double) point.x);
PsychCopyOutDoubleArg(2, kPsychArgOptional, (double) point.y);
// Window provided?
if (PsychIsWindowIndexArg(2)) {
// Yes: Check if it has focus.
PsychAllocInWindowRecordArg(2, TRUE, &windowRecord);
if (!PsychIsOnscreenWindow(windowRecord)) {
PsychErrorExitMsg(PsychError_user, "Provided window handle isn't an onscreen window, as required.");
}
PsychCopyOutDoubleArg(4, kPsychArgOptional, (double) (GetForegroundWindow() == windowRecord->targetSpecific.windowHandle) ? 1 : 0);
} else {
// No. Just always return "has focus":
PsychCopyOutDoubleArg(4, kPsychArgOptional, (double) 1);
}
// Return optional valuator values: Unimplemented on Windows. Just return an empty matrix.
// The ×tamp is just a dummy assignment without any meaning.
PsychCopyOutDoubleMatArg(5, kPsychArgOptional, (int) 1, (int) 0, (int) 1, ×tamp);
PsychCopyOutDoubleMatArg(6, kPsychArgOptional, (int) 1, (int) 0, (int) 1, buttonArray);
}
else {
// 'KeyboardHelper' mode: We implement either KbCheck() or KbWait() via X11.
// This is a hack to provide keyboard queries until a PsychHID() implementation
// for Microsoft Windows is available...
// Special codes -10 to -15? --> Console keyboard queries:
if(numButtons <= -10 && numButtons >= -15) {
ConsoleInputHelper((int) numButtons);
return(PsychError_none);
}
if (firsttime) {
// First time init:
firsttime = 0;
memset(keyState, 0, sizeof(keyState));
memset(disabledKeys, 0, sizeof(disabledKeys));
// These keycodes are always disabled: 0, 255:
disabledKeys[0]=1;
disabledKeys[255]=1;
// Mouse buttone (left, right, middle) are also disabled by default:
disabledKeys[1]=1;
disabledKeys[2]=1;
disabledKeys[4]=1;
}
if (numButtons==-1 || numButtons==-2) {
// KbCheck()/KbWait() mode
do {
// Reset overall key state to "none pressed":
keysdown=0;
// Request current time of query:
PsychGetAdjustedPrecisionTimerSeconds(×tamp);
// Query state of all keys:
for(i=1;i<255;i++){
keyState[i] = (GetAsyncKeyState(i) & -32768) ? 1 : 0;
}
// Disable all keys that are registered in disabledKeys. Check if
// any non-disabled key is down.
for (i=0; i<256; i++) {
if (disabledKeys[i]>0) keyState[i] = 0;
keysdown+=(unsigned int) keyState[i];
}
// We repeat until any key pressed if in KbWait() mode, otherwise we
// exit the loop after first iteration in KbCheck mode.
if ((numButtons==-1) || ((numButtons==-2) && (keysdown>0))) break;
// Sleep for a millisecond before next KbWait loop iteration:
PsychWaitIntervalSeconds(0.001);
} while(1);
if (numButtons==-2) {
// KbWait mode: Copy out time value.
PsychCopyOutDoubleArg(1, kPsychArgOptional, timestamp);
}
else {
// KbCheck mode:
// Copy out overall keystate:
PsychCopyOutDoubleArg(1, kPsychArgOptional, (keysdown>0) ? 1 : 0);
// Copy out timestamp:
PsychCopyOutDoubleArg(2, kPsychArgOptional, timestamp);
// Copy out keyboard state:
PsychAllocOutBooleanMatArg(3, kPsychArgOptional, 1, 256, 1, &buttonStates);
// Build 256 elements return vector:
for(i=0; i<255; i++) {
buttonStates[i] = (PsychNativeBooleanType)((keyState[i+1]) ? 1 : 0);
}
// Special case: Null out last element:
buttonStates[255] = (PsychNativeBooleanType) 0;
}
}
if (numButtons==-3) {
// Priority() - helper mode: The 2nd argument is the priority level:
// Determine our processID:
currentProcess = GetCurrentProcess();
// Get current scheduling policy:
oldPriority = GetPriorityClass(currentProcess);
// Map to PTB's scheme:
switch(oldPriority) {
case NORMAL_PRIORITY_CLASS:
priorityLevel = 0;
break;
case HIGH_PRIORITY_CLASS:
priorityLevel = 1;
break;
case REALTIME_PRIORITY_CLASS:
priorityLevel = 2;
break;
default:
priorityLevel = 0;
}
// Copy it out as optional return argument:
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double) priorityLevel);
// Query if a new level should be set:
priorityLevel = -1;
PsychCopyInIntegerArg(2, kPsychArgOptional, &priorityLevel);
// Priority level provided?
if (priorityLevel > -1) {
// Map to new scheduling class:
if (priorityLevel > 2) PsychErrorExitMsg(PsychErorr_argumentValueOutOfRange, "Invalid Priority level: Requested Priority() level must not exceed 2.");
switch(priorityLevel) {
case 0: // Standard scheduling:
SetPriorityClass(currentProcess, NORMAL_PRIORITY_CLASS);
// Disable any MMCSS scheduling for us:
PsychSetThreadPriority((psych_thread*) 0x1, 0, 0);
break;
case 1: // High priority scheduling:
SetPriorityClass(currentProcess, HIGH_PRIORITY_CLASS);
// Additionally try to schedule us MMCSS: This will lift us roughly into the
// same scheduling range as REALTIME_PRIORITY_CLASS, even if we are non-admin users
// on Vista and Windows-7 and later, however with a scheduler safety net applied.
PsychSetThreadPriority((psych_thread*) 0x1, 10, 0);
break;
case 2: // Realtime scheduling:
// This can fail if Matlab is not running under a user account with proper permissions:
if ((0 == SetPriorityClass(currentProcess, REALTIME_PRIORITY_CLASS)) || (REALTIME_PRIORITY_CLASS != GetPriorityClass(currentProcess))) {
// Failed to get RT-Scheduling. Let's try at least high priority scheduling:
SetPriorityClass(currentProcess, HIGH_PRIORITY_CLASS);
// Additionally try to schedule us MMCSS: This will lift us roughly into the
// same scheduling range as REALTIME_PRIORITY_CLASS, even if we are non-admin users
// on Vista and Windows-7 and later, however with a scheduler safety net applied.
PsychSetThreadPriority((psych_thread*) 0x1, 10, 0);
}
break;
}
}
// End of Priority() helper for Win32.
}
}
#endif
#if PSYCH_SYSTEM == PSYCH_LINUX
double myvaluators[100];
int numvaluators;
unsigned char keys_return[32];
char* keystring;
PsychGenericScriptType *kbNames;
CGDirectDisplayID dpy;
Window rootwin, childwin, mywin;
int i, j, mx, my, dx, dy;
double mxd, myd, dxd, dyd;
unsigned int mask_return;
double timestamp;
int numButtons;
double* buttonArray;
PsychNativeBooleanType* buttonStates;
int keysdown;
XEvent event_return;
XKeyPressedEvent keypressevent;
int screenNumber;
int priorityLevel;
struct sched_param schedulingparam;
PsychWindowRecordType *windowRecord;
int mouseIndex;
XIButtonState buttons_return;
XIModifierState modifiers_return;
XIGroupState group_return;
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychCopyInIntegerArg(1, kPsychArgRequired, &numButtons);
// Retrieve optional screenNumber argument:
if (numButtons!=-5) {
screenNumber = 0;
if (PsychIsScreenNumberArg(2)) {
PsychCopyInScreenNumberArg(2, FALSE, &screenNumber);
}
// Map screenNumber to X11 display handle and screenid:
PsychGetCGDisplayIDFromScreenNumber(&dpy, screenNumber);
if (PsychIsWindowIndexArg(2)) {
PsychAllocInWindowRecordArg(2, TRUE, &windowRecord);
if (!PsychIsOnscreenWindow(windowRecord)) {
PsychErrorExitMsg(PsychError_user, "Provided window handle isn't an onscreen window, as required.");
}
screenNumber = windowRecord->screenNumber;
mywin = windowRecord->targetSpecific.xwindowHandle;
// Map screenNumber to X11 display handle and screenid:
PsychGetCGDisplayIDFromScreenNumber(&dpy, screenNumber);
} else {
mywin = RootWindow(dpy, PsychGetXScreenIdForScreen(screenNumber));
}
}
// Default to "old school" mouse query - System default mouse via X core protocol:
mouseIndex = -1;
PsychCopyInIntegerArg(3, FALSE, &mouseIndex);
// Are we operating in 'GetMouseHelper' mode? numButtons>=0 indicates this.
if (numButtons>=0) {
// Mouse pointer query mode:
numvaluators = 0;
if (mouseIndex >= 0) {
// XInput-2 query for handling of multiple mouse pointers:
// Query input device list for screen:
int nDevices;
XIDeviceInfo* indevs = PsychGetInputDevicesForScreen(screenNumber, &nDevices);
// Sanity check:
if (NULL == indevs) PsychErrorExitMsg(PsychError_user, "Sorry, your system does not support individual mouse pointer queries.");
if (mouseIndex >= nDevices) PsychErrorExitMsg(PsychError_user, "Invalid 'mouseIndex' provided. No such device.");
if ((indevs[mouseIndex].use != XIMasterPointer) && (indevs[mouseIndex].use != XISlavePointer) && (indevs[mouseIndex].use != XIFloatingSlave)) {
PsychErrorExitMsg(PsychError_user, "Invalid 'mouseIndex' provided. Not a pointer device.");
}
// We requery the device info struct to retrieve updated live device state:
// Crucial for slave pointers to get any state at all, but also needed on
// master pointers to get the state of additional valuators, e.g., pen pressure,
// touch area, tilt etc. for digitizer tablets, touch pads etc. For master pointers,
// the primary 2 axis for 2D (x,y) position and the button/modifier state will be
// queried via a dedicated XIQueryPointer() call, so that info gets overriden.
indevs = XIQueryDevice(dpy, indevs[mouseIndex].deviceid, &numButtons);
modifiers_return.effective = 0;
// Query real number of mouse buttons and the raw button and axis state
// stored inside the device itself. This is done mostly because slave pointer
// devices don't support XIQueryPointer() so we get their relevant info from the
// XIDeviceInfo struct itself:
numButtons = 0;
numvaluators = 0;
memset(myvaluators, 0, sizeof(myvaluators));
if (PsychIsArgPresent(PsychArgOut, 6)) {
// Usercode wants valuator info structs:
for (i = 0; i < indevs->num_classes; i++) if (indevs->classes[i]->type == XIValuatorClass) numIValuators++;
PsychAllocOutStructArray(6, TRUE, numIValuators, numValuatorStructFieldNames, valuatorInfo, &valuatorStruct);
}
for (i = 0; i < indevs->num_classes; i++) {
// printf("Class %i: Type %i\n", i, (int) indevs->classes[i]->type);
if (indevs->classes[i]->type == XIButtonClass) {
// Number of buttons: For all pointers.
numButtons = ((XIButtonClassInfo*) indevs->classes[i])->num_buttons;
// Button state for slave pointers. Will get overriden for master pointers:
buttons_return.mask = ((XIButtonClassInfo*) indevs->classes[i])->state.mask;
buttons_return.mask_len = ((XIButtonClassInfo*) indevs->classes[i])->state.mask_len;
}
// Axis state for slave pointers. First two axis (x,y) will get overriden for master pointers:
if (indevs->classes[i]->type == XIValuatorClass) {
XIValuatorClassInfo* axis = (XIValuatorClassInfo*) indevs->classes[i];
if (axis->number == 0) mxd = axis->value; // x-Axis.
if (axis->number == 1) myd = axis->value; // y-Axis.
// Additional axis, e.g., digitizer tablet, touchpads etc.:
if (axis->number >= 0 && axis->number < 100) {
myvaluators[axis->number] = axis->value;
numvaluators = (numvaluators >= axis->number + 1) ? numvaluators : axis->number + 1;
}
// Assign valuator info struct, if requested:
if (valuatorStruct) {
if (axis->label != None) {
char* atomlabel = XGetAtomName(dpy, axis->label);
PsychSetStructArrayStringElement("label", axis->number, atomlabel, valuatorStruct);
XFree(atomlabel);
} else {
PsychSetStructArrayStringElement("label", axis->number, "None", valuatorStruct);
}
PsychSetStructArrayDoubleElement("min", axis->number, (double) axis->min, valuatorStruct);
PsychSetStructArrayDoubleElement("max", axis->number, (double) axis->max, valuatorStruct);
PsychSetStructArrayDoubleElement("resolution", axis->number, (double) axis->resolution, valuatorStruct);
PsychSetStructArrayDoubleElement("mode", axis->number, (double) axis->mode, valuatorStruct);
PsychSetStructArrayDoubleElement("sourceID", axis->number, (double) axis->sourceid, valuatorStruct);
}
// printf("AXIS %i, LABEL = %s, MIN = %f, MAX = %f, VAL = %f\n", axis->number, (char*) "NONE", (float) axis->min, (float) axis->max, (float) axis->value);
}
}
// Add 32 buttons for modifier key state vector:
numButtons += 32;
// A real master pointer: Use official query for mouse devices.
if (indevs->use == XIMasterPointer) {
// Query pointer location and state:
XIQueryPointer(dpy, indevs->deviceid, RootWindow(dpy, PsychGetXScreenIdForScreen(screenNumber)), &rootwin, &childwin, &mxd, &myd, &dxd, &dyd,
&buttons_return, &modifiers_return, &group_return);
}
// Copy out mouse x and y position:
PsychCopyOutDoubleArg(1, kPsychArgOptional, mxd);
PsychCopyOutDoubleArg(2, kPsychArgOptional, myd);
// Copy out mouse button state:
PsychAllocOutDoubleMatArg(3, kPsychArgOptional, (int)1, (int) numButtons, (int)1, &buttonArray);
memset(buttonArray, 0, sizeof(double) * numButtons);
if (numButtons > 0) {
// Mouse buttons:
const int buttonOffset = 1; // Buttons start at bit 1, not 0 for some strange reason? At least so on Ubuntu 10.10 and 11.10 with 2 mice and 1 joystick?
for (i = buttonOffset; (i < numButtons - 32) && ((i / 8 ) < buttons_return.mask_len); i++) {
buttonArray[i - buttonOffset] = (double) ((buttons_return.mask[i / 8] & (1 << (i % 8))) ? 1 : 0);
}
// Free mask if retrieved via XIQueryPointer():
if (indevs->use == XIMasterPointer) free(buttons_return.mask);
// Append modifier key state from associated master keyboard. Last 32 entries:
for (i = 0; i < 32; i++) {
buttonArray[numButtons - 32 + i] = (double) ((modifiers_return.effective & (1 << i)) ? 1 : 0);
}
}
// Release live state info structure:
XIFreeDeviceInfo(indevs);
}
else {
// Old school core protocol query of virtual core pointer:
XQueryPointer(dpy, RootWindow(dpy, PsychGetXScreenIdForScreen(screenNumber)), &rootwin, &childwin, &mx, &my, &dx, &dy, &mask_return);
// Copy out mouse x and y position:
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double) mx);
PsychCopyOutDoubleArg(2, kPsychArgOptional, (double) my);
// Copy out mouse button state:
PsychAllocOutDoubleMatArg(3, kPsychArgOptional, (int)1, (int)numButtons, (int)1, &buttonArray);
// Bits 8, 9 and 10 of mask_return seem to correspond to mouse buttons
// 1, 2 and 3 of a mouse for some weird reason. Bits 0-7 describe keyboard modifier keys
// like Alt, Ctrl, Shift, ScrollLock, NumLock, CapsLock...
// We remap here, so the first three returned entries correspond to the mouse buttons and
// the rest is attached behind, if requested...
// Mouse buttons: Left, Middle, Right == 0, 1, 2, aka 1,2,3 in Matlab space...
for (i=0; i<numButtons && i<3; i++) {
buttonArray[i] = (mask_return & (1<<(i+8))) ? 1 : 0;
}
// Modifier keys 0 to 7 appended:
for (i=3; i<numButtons && i<3+8; i++) {
buttonArray[i] = (mask_return & (1<<(i-3))) ? 1 : 0;
}
// Everything else appended:
for (i=11; i<numButtons; i++) {
buttonArray[i] = (mask_return & (1<<i)) ? 1 : 0;
}
}
// Return optional 4th argument: Focus state. Returns 1 if our window has
// keyboard input focus, zero otherwise:
XGetInputFocus(dpy, &rootwin, &i);
PsychCopyOutDoubleArg(4, kPsychArgOptional, (double) (rootwin == mywin) ? 1 : 0);
// Return optional valuator values:
PsychCopyOutDoubleMatArg(5, kPsychArgOptional, (int) 1, (int) numvaluators, (int) 1, &myvaluators[0]);
}
else {
// 'KeyboardHelper' mode: We implement either KbCheck() or KbWait() via X11.
// This is a hack to provide keyboard queries until a PsychHID() implementation
// for Linux is available...
// Special codes -10 to -15? --> Console keyboard queries:
if(numButtons <= -10 && numButtons >= -15) {
ConsoleInputHelper((int) numButtons);
return(PsychError_none);
}
if (numButtons==-1 || numButtons==-2) {
// KbCheck()/KbWait() mode:
// Switch X-Server into synchronous mode: We need this to get
// a higher timing precision.
XSynchronize(dpy, TRUE);
do {
// Reset overall key state to "none pressed":
keysdown=0;
// Request current keyboard state from X-Server:
XQueryKeymap(dpy, keys_return);
// Request current time of query:
PsychGetAdjustedPrecisionTimerSeconds(×tamp);
// Any key down?
for (i=0; i<32; i++) keysdown+=(unsigned int) keys_return[i];
// We repeat until any key pressed if in KbWait() mode, otherwise we
// exit the loop after first iteration in KbCheck mode.
if ((numButtons==-1) || ((numButtons==-2) && (keysdown>0))) break;
// Sleep for a few milliseconds before next KbWait loop iteration:
PsychWaitIntervalSeconds(0.01);
} while(1);
if (numButtons==-2) {
// Copy out time:
PsychCopyOutDoubleArg(1, kPsychArgOptional, timestamp);
}
else {
// KbCheck mode:
// Copy out overall keystate:
PsychCopyOutDoubleArg(1, kPsychArgOptional, (keysdown>0) ? 1 : 0);
// copy out timestamp:
PsychCopyOutDoubleArg(2, kPsychArgOptional, timestamp);
// Copy keyboard state:
PsychAllocOutBooleanMatArg(3, kPsychArgOptional, 1, 256, 1, &buttonStates);
// Map 32 times 8 bitvector to 256 element return vector:
for(i=0; i<32; i++) {
for(j=0; j<8; j++) {
buttonStates[i*8 + j] = (PsychNativeBooleanType)(keys_return[i] & (1<<j)) ? 1 : 0;
}
}
}
}
else if (numButtons == -3) {
// numButtons == -3 --> KbName mapping mode:
// Return the full keyboard keycode to ASCII character code mapping table...
PsychAllocOutCellVector(1, kPsychArgOptional, 256, &kbNames);
for(i=0; i<256; i++) {
// Map keyboard scan code to KeySym:
keystring = XKeysymToString(XKeycodeToKeysym(dpy, i, 0));
if (keystring) {
// Character found: Return its ASCII name string:
PsychSetCellVectorStringElement(i, keystring, kbNames);
}
else {
// No character for this keycode:
PsychSetCellVectorStringElement(i, "", kbNames);
}
}
}
else if (numButtons == -4) {
// GetChar() emulation.
/* do { */
/* // Fetch next keypress event from queue, block if none is available... */
/* keystring = NULL; */
/* XNextEvent(dpy, &event_return); */
/* // Check for valid keypress event and extract character: */
/* if (event_return.type == KeyPress) { */
/* keypressevent = (XKeyPressedEvent) event_return; */
/* keystring = NULL; */
/* keystring = XKeysymToString(XKeycodeToKeysym(dpy, keypressevent.keycode, 0)); */
/* } */
/* // Repeat until a valid char is returned. */
/* } while (keystring == NULL); */
/* // Copy out character: */
/* PsychCopyOutCharArg(1, kPsychArgOptional, (char) keystring); */
/* // Copy out time: */
/* PsychCopyOutDoubleArg(2, kPsychArgOptional, (double) keypressevent.time); */
}
else if (numButtons==-5) {
// Priority() - helper mode: The 2nd argument is the priority level:
// Query scheduling policy and priority:
pthread_getschedparam(pthread_self(), &priorityLevel, &schedulingparam);
// If scheduling mode is a realtime mode (RoundRobin realtime RR, or FIFO realtime),
// then assign RT priority level (range 1-99) as current priorityLevel, otherwise
// assign non realtime priority level zero:
priorityLevel = (priorityLevel == SCHED_RR || priorityLevel == SCHED_FIFO) ? schedulingparam.sched_priority : 0;
// Copy it out as optional return argument:
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double) priorityLevel);
// Query if a new level should be set:
priorityLevel = -1;
PsychCopyInIntegerArg(2, kPsychArgOptional, &priorityLevel);
errno=0;
// Priority level provided?
if (priorityLevel > -1) {
// Map to new scheduling class:
if (priorityLevel > 99 || priorityLevel < 0) PsychErrorExitMsg(PsychErorr_argumentValueOutOfRange, "Invalid Priority level: Requested Priority() level must be between zero and 99!");
if (priorityLevel > 0) {
// Realtime FIFO scheduling and all pages of Matlab/Octave locked into memory:
schedulingparam.sched_priority = priorityLevel;
priorityLevel = pthread_setschedparam(pthread_self(), SCHED_FIFO, &schedulingparam);
if (priorityLevel == -1) {
// Failed!
if(!PsychPrefStateGet_SuppressAllWarnings()) {
printf("PTB-ERROR: Failed to enable realtime-scheduling with Priority(%i) [%s]!\n", schedulingparam.sched_priority, strerror(errno));
if (errno==EPERM) {
printf("PTB-ERROR: You need to run Matlab/Octave with root-privileges, or run the script PsychLinuxConfiguration once for this to work.\n");
}
}
errno=0;
}
else {
// RT-Scheduling active. Lock all current and future memory:
priorityLevel = mlockall(MCL_CURRENT | MCL_FUTURE);
if (priorityLevel!=0) {
// Failed! Report problem as warning, but don't worry further.
if(!PsychPrefStateGet_SuppressAllWarnings()) printf("PTB-WARNING: Failed to enable system memory locking with Priority(%i) [%s]!\n", schedulingparam.sched_priority, strerror(errno));
// Undo any possibly partial mlocks....
munlockall();
errno=0;
}
}
}
else {
// Standard scheduling and no memory locking:
schedulingparam.sched_priority = 0;
priorityLevel = pthread_setschedparam(pthread_self(), SCHED_OTHER, &schedulingparam);
if (priorityLevel == -1) {
// Failed!
if(!PsychPrefStateGet_SuppressAllWarnings()) {
printf("PTB-ERROR: Failed to disable realtime-scheduling with Priority(%i) [%s]!\n", schedulingparam.sched_priority, strerror(errno));
if (errno==EPERM) {
printf("PTB-ERROR: You need to run Matlab/Octave with root-privileges, or run the script PsychLinuxConfiguration once for this to work.\n");
}
}
errno=0;
}
munlockall();
errno=0;
}
// End of setup of new Priority...
}
// End of Priority() helper for Linux.
}
} // End of special functions handling for Linux...
#endif
return(PsychError_none);
}
PsychError SCREENOpenMovie(void)
{
PsychWindowRecordType *windowRecord;
char *moviefile;
int moviehandle = -1;
int framecount;
double durationsecs;
double framerate;
int width;
int height;
int asyncFlag = 0;
static psych_bool firstTime = TRUE;
double preloadSecs = 1;
int rc;
if (firstTime) {
// Setup asyncopeninfo on first invocation:
firstTime = FALSE;
asyncmovieinfo.asyncstate = 0; // State = No async open in progress.
}
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()) {PsychGiveHelp(); return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(4)); // Max. 4 input args.
PsychErrorExit(PsychRequireNumInputArgs(1)); // Min. 1 input args required.
PsychErrorExit(PsychCapNumOutputArgs(6)); // Max. 6 output args.
// Get the window record from the window record argument and get info from the window record
windowRecord = NULL;
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, FALSE, &windowRecord);
// Only onscreen windows allowed:
if(windowRecord && !PsychIsOnscreenWindow(windowRecord)) {
PsychErrorExitMsg(PsychError_user, "OpenMovie called on something else than an onscreen window.");
}
// Get the movie name string:
moviefile = NULL;
PsychAllocInCharArg(2, kPsychArgRequired, &moviefile);
// Get the (optional) asyncFlag:
PsychCopyInIntegerArg(3, FALSE, &asyncFlag);
PsychCopyInDoubleArg(4, FALSE, &preloadSecs);
if (preloadSecs < 0 && preloadSecs!= -1) PsychErrorExitMsg(PsychError_user, "OpenMovie called with invalid (negative, but not equal -1) 'preloadSecs' argument!");
// Asynchronous Open operation in progress or requested?
if ((asyncmovieinfo.asyncstate == 0) && (asyncFlag == 0)) {
// No. We should just synchronously open the movie:
// Try to open the named 'moviefile' and create & initialize a corresponding movie object.
// A MATLAB handle to the movie object is returned upon successfull operation.
PsychCreateMovie(windowRecord, moviefile, preloadSecs, &moviehandle);
}
else {
// Asynchronous open operation requested or running:
switch(asyncmovieinfo.asyncstate) {
case 0: // No async open running, but async open requested
// Fill all information needed for opening the movie into the info struct:
asyncmovieinfo.asyncstate = 1; // Mark state as "Operation in progress"
asyncmovieinfo.moviename = strdup(moviefile);
asyncmovieinfo.preloadSecs = preloadSecs;
if (windowRecord) {
memcpy(&asyncmovieinfo.windowRecord, windowRecord, sizeof(PsychWindowRecordType));
} else {
memcpy(&asyncmovieinfo.windowRecord, 0, sizeof(PsychWindowRecordType));
}
asyncmovieinfo.moviehandle = -1;
// Increase our scheduling priority to maximum FIFO priority: This way we should get
// more cpu time for our PTB main thread than the async. background prefetch-thread:
if ((rc=PsychSetThreadPriority(NULL, 1, 0))!=0) {
printf("PTB-WARNING: In OpenMovie(): Failed to raise priority of main thread [System error %i]. Expect movie timing problems.\n", rc);
}
// Start our own movie loader Posix-Thread:
PsychCreateThread(&asyncmovieinfo.pid, NULL, PsychAsyncCreateMovie, &asyncmovieinfo);
// Async movie open initiated. We return control to host environment:
return(PsychError_none);
break;
case 1: // Async open operation in progress, but not yet finished.
// Should we wait for completion or just return?
if (asyncFlag) {
// Async poll requested. We just return -1 to signal that open isn't finished yet:
PsychCopyOutDoubleArg(1, TRUE, -1);
return(PsychError_none);
}
// We fall through to case 2 - Wait for "Load operation successfully finished."
case 2: // Async open operation successfully finished. Parse asyncinfo struct and return it to host environment:
// We need to join our terminated worker thread to release its ressources. If the worker-thread
// isn't done yet (fallthrough from case 1 for sync. wait), this join will block us until worker
// completes:
PsychDeleteThread(&asyncmovieinfo.pid);
// Reset our priority to "normal" after async prefetch completion:
if ((rc=PsychSetThreadPriority(NULL, 0, 0))!=0) {
printf("PTB-WARNING: In OpenMovie(): Failed to lower priority of main thread [System error %i]. Expect movie timing problems.\n", rc);
}
asyncmovieinfo.asyncstate = 0; // Reset state to idle:
moviehandle = asyncmovieinfo.moviehandle;
// Movie successfully opened?
if (moviehandle < 0) {
// Movie loading failed for some reason.
printf("PTB-ERROR: When trying to asynchronously load movie %s, the operation failed: ", asyncmovieinfo.moviename);
switch(moviehandle) {
case -2000:
case -50:
case -43:
printf("File not found.");
break;
case -2048:
printf("This is not a file that Quicktime understands.");
break;
case -2003:
printf("Can't find media handler (codec) for this movie.");
break;
case -2:
printf("Maximum allowed number of simultaneously open movie files exceeded!");
break;
case -1:
printf("Internal error: Failure in PTB's movie playback engine!");
break;
default:
printf("Unknown error (Quicktime error %i): Check http://developer.apple.com/documentation/QuickTime/APIREF/ErrorCodes.htm#//apple_ref/doc/constant_group/Error_Codes", moviehandle);
}
printf("\n\n");
PsychErrorExitMsg(PsychError_user, "Asynchronous loading of the Quicktime movie failed.");
}
// We can fall out of the switch statement and continue with the standard synchronous load code as if
// the movie had been loaded synchronously.
break;
default:
PsychErrorExitMsg(PsychError_internal, "Unhandled async movie state condition encountered! BUG!!");
}
}
// Upon sucessfull completion, we'll have a valid handle in 'moviehandle'.
// Return it to Matlab-world:
PsychCopyOutDoubleArg(1, TRUE, (double) moviehandle);
// Retrieve infos about new movie:
// Is the "count" output argument (total number of frames) requested by user?
if (PsychGetNumOutputArgs() > 5) {
// Yes. Query the framecount (expensive!) and return it:
PsychGetMovieInfos(moviehandle, &width, &height, &framecount, &durationsecs, &framerate, NULL);
PsychCopyOutDoubleArg(6, TRUE, (double) framecount);
}
else {
// No. Don't compute and return it.
PsychGetMovieInfos(moviehandle, &width, &height, NULL, &durationsecs, &framerate, NULL);
}
PsychCopyOutDoubleArg(2, FALSE, (double) durationsecs);
PsychCopyOutDoubleArg(3, FALSE, (double) framerate);
PsychCopyOutDoubleArg(4, FALSE, (double) width);
PsychCopyOutDoubleArg(5, FALSE, (double) height);
// Ready!
return(PsychError_none);
}
/** PsychRealtimePriority: Temporarily boost priority to THREAD_TIME_CONSTRAINT_POLICY.
PsychRealtimePriority(true) enables realtime-scheduling (like Priority(9) would do in Matlab).
PsychRealtimePriority(false) restores scheduling to the state before last invocation of PsychRealtimePriority(true),
it undos whatever the previous switch did.
We switch to RT scheduling during PsychGetMonitorRefreshInterval() and a few other timing tests in
PsychOpenWindow() to reduce measurement jitter caused by possible interference of other tasks.
*/
psych_bool PsychRealtimePriority(psych_bool enable_realtime)
{
psych_bool isError;
thread_policy_flavor_t flavorConstant;
int kernError;
task_t threadID;
thread_policy_t threadPolicy;
static thread_policy_t old_threadPolicy;
mach_msg_type_number_t policyCount, policyCountFilled;
static mach_msg_type_number_t old_policyCountFilled;
boolean_t isDefault;
static psych_bool old_enable_realtime = FALSE;
static psych_bool oldModeWasStandard = FALSE;
if (old_enable_realtime == enable_realtime) {
// No transition with respect to previous state -> Nothing to do.
return(TRUE);
}
// Transition requested:
old_enable_realtime = enable_realtime;
// Determine our threadID:
threadID = mach_thread_self();
if (enable_realtime) {
// Transition to realtime requested:
// Get current scheduling policy and its settings and back it up for later restore:
old_threadPolicy = (thread_policy_t) malloc(sizeof(thread_time_constraint_policy_data_t));
policyCount = THREAD_TIME_CONSTRAINT_POLICY_COUNT;
old_policyCountFilled = policyCount;
isDefault = FALSE;
// We check if STANDARD_POLICY is active and query its settings, if so...
kernError = thread_policy_get(threadID, THREAD_STANDARD_POLICY, old_threadPolicy, &old_policyCountFilled, &isDefault);
if (kernError) {
// Failed!
old_enable_realtime = FALSE;
free(old_threadPolicy);
printf("PsychRealtimePriority: ERROR! COULDN'T QUERY CURRENT SCHEDULING SETTINGS!!!\n");
return(FALSE);
}
// oldModeWasStandard == TRUE --> We need to revert to STANDARD POLICY later...
oldModeWasStandard = !isDefault;
// printf("PRE-RT: CURRENTLY IN %s mode\n", oldModeWasStandard ? "STANDARD" : "REALTIME");
if (!oldModeWasStandard) {
// We are already RT scheduled. Backup settings for later switch-back:
policyCount = THREAD_TIME_CONSTRAINT_POLICY_COUNT;
old_policyCountFilled = policyCount;
isDefault = FALSE;
// We check if STANDARD_POLICY is active and query its settings, if so...
kernError = thread_policy_get(threadID, THREAD_TIME_CONSTRAINT_POLICY, old_threadPolicy, &old_policyCountFilled, &isDefault);
if (kernError) {
// Failed!
old_enable_realtime = FALSE;
free(old_threadPolicy);
printf("PsychRealtimePriority: ERROR! COULDN'T QUERY CURRENT RT SCHEDULING SETTINGS!!!\n");
return(FALSE);
}
}
// Switch to our ultra-high priority realtime mode: Guaranteed up to 3 msecs of uninterrupted
// runtime as soon as we want to run: Perfect for swap completion timestamping in refresh rate
// calibration - our only use-case:
PsychSetThreadPriority(NULL, 10, 2);
}
else {
// Transition from RT to Non-RT scheduling requested: We just reestablish the backed-up old
// policy:
kernError = thread_policy_set(threadID, (oldModeWasStandard) ? THREAD_STANDARD_POLICY : THREAD_TIME_CONSTRAINT_POLICY, old_threadPolicy, old_policyCountFilled);
if (kernError) {
// Failed!
old_enable_realtime = TRUE;
free((void*) old_threadPolicy);
printf("PsychRealtimePriority: ERROR! COULDN'T SWITCH BACK TO NON-RT SCHEDULING!!!\n");
fflush(NULL);
return(FALSE);
}
// Successfully switchted to RT-Scheduling:
free((void*) old_threadPolicy);
}
// Success.
return(TRUE);
}
