PsychError SCREENAddAudioBufferToMovie(void)
{
static char useString[] = "Screen('AddAudioBufferToMovie', moviePtr, audioBuffer);";
static char synopsisString[] =
"Add a buffer filled with audio data samples to movie 'moviePtr'.\n"
"The movie must have been created in 'CreateMovie' with an options string that "
"enables writing of an audio track into the movie, otherwise this function will fail.\n"
"You enable writing of audio tracks by adding the keyword 'AddAudioTrack' to the options string.\n"
"Alternatively, if your options string is a gst-launch style pipeline description, it must contain "
"one pipeline element with a name option of 'name=ptbaudioappsrc'.\n"
"'audioBuffer' must be 'numChannels' rows by 'numSamples' columns double matrix of audio data. "
"Each row encodes one audio channel, each column element in a row encodes a sample. "
"E.g., a 2-by-48000 matrix would encode 48000 samples for a two channel stereo sound track.\n"
"Sample values must lie in the range between -1.0 and +1.0.\n"
"The audio buffer is converted into a movie specific sound format and then appended to "
"the audio samples already stored in the audio track.\n"
"\n";
static char seeAlsoString[] = "FinalizeMovie AddFrameToMovie CloseMovie PlayMovie GetMovieImage GetMovieTimeIndex SetMovieTimeIndex";
int moviehandle = -1;
int m, n, p;
double* buffer;
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()) {PsychGiveHelp(); return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(2)); // Max. 2 input args.
PsychErrorExit(PsychRequireNumInputArgs(2)); // Min. 2 input args required.
PsychErrorExit(PsychCapNumOutputArgs(0)); // Max. 0 output args.
// Get movie handle:
PsychCopyInIntegerArg(1, kPsychArgRequired, &moviehandle);
// And audio date buffer:
PsychAllocInDoubleMatArg(2, kPsychArgRequired, &m, &n, &p, &buffer);
if (p!=1 || m < 1 || n < 1) PsychErrorExitMsg(PsychError_user, "Invalid audioBuffer provided. Must be a 2D matrix with at least one row and at least one column!");
// Pass audio data to movie writing engine:
PsychAddAudioBufferToMovie(moviehandle, m, n, buffer);
return(PsychError_none);
}
PsychError SCREENPlayMovie(void)
{
int moviehandle = -1;
double rate = 0;
int loop = 0;
double sndvolume = 1;
double dropped = 0;
// 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(2)); // Min. 2 input args required.
PsychErrorExit(PsychCapNumOutputArgs(1)); // Max. 1 output args.
// Get the movie handle:
PsychCopyInIntegerArg(1, TRUE, &moviehandle);
if (moviehandle==-1) {
PsychErrorExitMsg(PsychError_user, "PlayMovie called without valid handle to a movie object.");
}
// Get the requested playback rate.
PsychCopyInDoubleArg(2, TRUE, &rate);
// Get the 'loop' flag: If zero, we don't loop, otherwise we loop.
PsychCopyInIntegerArg(3, FALSE, &loop);
// Get the requested sound volume. Defaults to 1 == Full blast!
PsychCopyInDoubleArg(4, FALSE, &sndvolume);
if (sndvolume<0) sndvolume = 0;
if (sndvolume>1) sndvolume = 1;
// Start playback via low-level routines:
dropped = (double) PsychPlaybackRate(moviehandle, rate, loop, sndvolume);
// Return optional count of dropped frames:
PsychCopyOutDoubleArg(1, FALSE, dropped);
// Ready!
return(PsychError_none);
}
/*
PsychHIDGetIndexFromRecord()
The inverse of PsychHIDGetDeviceRecordPtrFromIndex.
This O(n) where n is the number of device elements. We could make it O(1) if we modified
the element structure in the HID Utilities library to include a field specifying the index of the element or
collection.
Note that if PsychHIDGetIndexFromRecord() is O(n) then its caller, PsychHIDGetCollections, is O(n^2) for each
device, whereas if PsychHIDGetIndexFromRecord() is O(1) then psychHIDGetCollections becomes O(n) for each
device.
*/
int PsychHIDGetIndexFromRecord(pRecDevice deviceRecord, pRecElement elementRecord, HIDElementTypeMask typeMask)
{
int elementIndex;
pRecElement currentElement;
if (elementRecord == NULL)
return(0);
elementIndex = 1;
for (currentElement = HIDGetFirstDeviceElement(deviceRecord, typeMask);
currentElement != elementRecord && currentElement != NULL;
currentElement = HIDGetNextDeviceElement(currentElement, typeMask))
++elementIndex;
if (currentElement == elementRecord)
return elementIndex;
else {
PsychErrorExitMsg(PsychError_internal, "Element record not found within device record");
return 0; //make the compiler happy
}
}
psych_bool PsychCopyInWindowIndexArg(int position, psych_bool required, PsychWindowIndexType *windowIndex)
{
double *arg;
psych_bool isThere;
if(position==kPsychUseDefaultArgPosition)
position = kPsychDefaultNumdexArgPosition;
isThere=PsychAllocInDoubleArg(position,required,&arg);
if(!isThere)
return(FALSE);
*windowIndex = (PsychWindowIndexType)*arg;
if(IsWindowIndex(*windowIndex))
return(TRUE);
else{
PsychErrorExitMsg(PsychError_invalidWindex,NULL);
return(FALSE); //only to satisfy the compiler with a return statement.
}
}
pRecElement PsychHIDGetCollectionRecordFromDeviceRecordAndCollectionIndex(pRecDevice deviceRecord, int elementIndex)
{
int i;
pRecElement currentElement;
PsychHIDVerifyInit();
i=1;
for(currentElement=HIDGetFirstDeviceElement(deviceRecord, kHIDElementTypeCollection);
currentElement != NULL;
currentElement=HIDGetNextDeviceElement (currentElement, kHIDElementTypeCollection))
{
if(i==elementIndex)
return(currentElement);
++i;
}
PsychErrorExitMsg(PsychError_internal, "Invalid collection index specified. Has a device has been unplugged? Try rebuilding the device list");
return(NULL); //make the compiler happy.
}
/* PsychSetOutputDithering() - Control bit depth control and dithering on digital display output encoder:
*
* This function enables or disables bit depths truncation or dithering of digital display output ports of supported
* graphics hardware. Currently the ATI Radeon X1000/HD2000/HD3000/HD4000/HD5000 and later cards should allow this.
*
* This needs support from the Psychtoolbox kernel level support driver for low-level register reads
* and writes to the GPU registers.
*
*
* 'windowRecord' Is used to find the Id of the screen for which mode should be changed. If set to NULL then...
* 'screenId' ... is used to determine the screenId for the screen. Otherwise 'screenId' is ignored.
* 'ditherEnable' Zero = Disable any dithering. Non-Zero Reenable dithering after it has been disabled by us,
* or if it wasn't disabled beforehand, enable it with a control mode as specified by the numeric
* value of 'ditherEnable'. The value is GPU specific.
*
*/
psych_bool PsychSetOutputDithering(PsychWindowRecordType* windowRecord, int screenId, unsigned int ditherEnable)
{
#if PSYCH_SYSTEM == PSYCH_OSX || PSYCH_SYSTEM == PSYCH_LINUX
// Child protection:
if (windowRecord && !PsychIsOnscreenWindow(windowRecord)) PsychErrorExitMsg(PsychError_internal, "Invalid non-onscreen windowRecord provided!!!");
// Either screenid from windowRecord or as passed in:
if (windowRecord) screenId = windowRecord->screenNumber;
// Do the call:
PsychOSKDSetDitherMode(screenId, ditherEnable);
return(TRUE);
#else
// This cool stuff not supported on the uncool Windows OS:
if(PsychPrefStateGet_Verbosity() > 1) printf("PTB-WARNING: GPU dithering control requested, but this is not supported on MS-Windows.\n");
return(FALSE);
#endif
}
void PsychSetATSUStyleAttributesFromPsychWindowRecord(ATSUStyle atsuStyle, PsychWindowRecordType *winRec)
{
PsychFontStructType *psychFontRecord;
int psychColorSize;
//for ATSU attributes
ATSUFontID atsuFontID;
Fixed atsuFontSize;
ATSURGBAlphaColor atsuFontColor;
ATSStyleRenderingOptions atsuRenderOptions;
GLdouble colorVector[4];
OSStatus callError;
ATSUAttributeTag aaTags[] = {kATSUFontTag, kATSUSizeTag, kATSURGBAlphaColorTag, kATSUStyleRenderingOptionsTag };
ByteCount aaSizes[] = {sizeof(ATSUFontID), sizeof(Fixed), sizeof(ATSURGBAlphaColor), sizeof(ATSStyleRenderingOptions) };
ATSUAttributeValuePtr aaValue[] = {&atsuFontID, &atsuFontSize, &atsuFontColor, &atsuRenderOptions};
//set the font index
PsychGetFontRecordFromFontNumber(winRec->textAttributes.textFontNumber, &psychFontRecord);
if(psychFontRecord==NULL)
PsychErrorExitMsg(PsychError_internal, "Failed to lookup the font from the font number");
atsuFontID=psychFontRecord->fontFMRef;
//set the font size
atsuFontSize=Long2Fix((long)(winRec->textAttributes.textSize));
//set the color
PsychCoerceColorMode(&(winRec->textAttributes.textColor));
PsychConvertColorToDoubleVector(&(winRec->textAttributes.textColor), winRec, colorVector);
atsuFontColor.red=(float)colorVector[0];
atsuFontColor.green=(float)colorVector[1];
atsuFontColor.blue=(float)colorVector[2];
atsuFontColor.alpha=(float)colorVector[3];
// Set anti-aliasing mode (on/off): Default is to leave it up to the system to decide when
// to anti-alias and when not. But this flag allows to always force anti-aliasin on or off:
atsuRenderOptions = kATSStyleNoOptions;
if(PsychPrefStateGet_TextAntiAliasing()==0) atsuRenderOptions = kATSStyleNoAntiAliasing;
if(PsychPrefStateGet_TextAntiAliasing()> 0) atsuRenderOptions = kATSStyleApplyAntiAliasing;
//assign attributes to the style object
callError=ATSUSetAttributes(atsuStyle, 4, aaTags, aaSizes, aaValue);
}
/*
FindCollectionElements()
Non-recursively return of a list of a collection's memember elements.
HID element records hold three pointers to other element records: pPrevious, pChild and pSibling. FindCollectionElements()
operates on the theory that the members of a collection are its child and all of that child's siblings.
*/
int PsychHIDFindCollectionElements(pRecElement collectionRecord, HIDElementTypeMask elementTypeMask, pRecElement *collectionMembers, int maxListElements)
{
pRecElement currentElement;
int numElements = 0;
CFIndex i, nmax;
HIDElementTypeMask currentElementMaskValue;
CFArrayRef children = IOHIDElementGetChildren(collectionRecord);
nmax = CFArrayGetCount(children);
for (i = 0; i < nmax; i++) {
currentElement = (pRecElement)CFArrayGetValueAtIndex(children, i);
currentElementMaskValue = HIDConvertElementTypeToMask(IOHIDElementGetType(currentElement));
if (currentElementMaskValue & elementTypeMask) {
if (numElements == maxListElements) PsychErrorExitMsg(PsychError_internal, "Number of collection elements exceeds allocated storage space.");
collectionMembers[numElements] = currentElement;
++numElements;
}
}
return numElements;
}
void PsychHIDOSKbQueueFlush(int deviceIndex)
{
if(!hidDataRef || !psychHIDKbQueueFirstPress || !psychHIDKbQueueFirstRelease || !psychHIDKbQueueLastPress || !psychHIDKbQueueLastRelease){
PsychErrorExitMsg(PsychError_user, "Queue has not been created.");
}
// Drain the queue of any unprocessed events
{
IOHIDEventStruct event;
AbsoluteTime zeroTime= {0,0};
while( (*hidDataRef->hidQueueInterface)->getNextEvent(hidDataRef->hidQueueInterface, &event, zeroTime, 0) == kIOReturnSuccess){
if ((event.longValueSize != 0) && (event.longValue != NULL)) free(event.longValue);
}
}
pthread_mutex_lock(&psychHIDKbQueueMutex);
// Zero out the scored values
{
int i;
for(i=0; i<256; i++){
psychHIDKbQueueFirstPress[i].hi=0;
psychHIDKbQueueFirstPress[i].lo=0;
psychHIDKbQueueFirstRelease[i].hi=0;
psychHIDKbQueueFirstRelease[i].lo=0;
psychHIDKbQueueLastPress[i].hi=0;
psychHIDKbQueueLastPress[i].lo=0;
psychHIDKbQueueLastRelease[i].hi=0;
psychHIDKbQueueLastRelease[i].lo=0;
}
modifierKeyState = 0;
}
pthread_mutex_unlock(&psychHIDKbQueueMutex);
}
void PsychHIDOSKbQueueRelease(int deviceIndex)
{
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;
}
// Ok, we have a keyboard queue. Stop any operation on it first:
PsychHIDOSKbQueueStop(deviceIndex);
// 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;
}
void PsychGetScreenDepths(int screenNumber, PsychDepthType *depths)
{
int* x11_depths;
int i, count;
if(screenNumber>=numDisplays) PsychErrorExitMsg(PsychError_internal, "screenNumber is out of range"); //also checked within SCREENPixelSizes
x11_depths = XListDepths(displayCGIDs[screenNumber], PsychGetXScreenIdForScreen(screenNumber), &count);
if (depths && count>0) {
// Query successful: Add all values to depth struct:
for(i=0; i<count; i++) PsychAddValueToDepthStruct(x11_depths[i], depths);
XFree(x11_depths);
}
else {
// Query failed: Assume at least 32 bits is available.
printf("PTB-WARNING: Couldn't query available display depths values! Returning a made up list...\n");
fflush(NULL);
PsychAddValueToDepthStruct(32, depths);
PsychAddValueToDepthStruct(24, depths);
PsychAddValueToDepthStruct(16, depths);
}
}
static void ReportSysctlError(int errorValue)
{
psych_bool foundError;
int sysctlErrors[]={EFAULT, EINVAL, ENOMEM, ENOTDIR, EISDIR, EOPNOTSUPP, EPERM};
int i, errorIndex, numSysctlErrors=7;
char *sysctlErrorStrings[]={"EFAULT", "EINVAL", "ENOMEM", "ENOTDIR", "EISDIR", "EOPNOTSUPP", "EPERM", "UNRECOGNIZED"};
if(errorValue == 0) return;
foundError=0;
errorIndex=7;
for(i=0; i<numSysctlErrors; i++){
if(errno==sysctlErrors[i]){
foundError=1;
errorIndex=i;
break;
}
}
PsychErrorExitMsg(PsychError_internal, sysctlErrorStrings[errorIndex]);
}
/* PsychSetupVertexColorArrays()
Helper routine, called from the different batch drawing functions of Screen():
*/
void PsychSetupVertexColorArrays(PsychWindowRecordType *windowRecord, psych_bool enable, int mc, double* colors, unsigned char *bytecolors)
{
if (enable) {
// Enable and setup whatever's used:
if (windowRecord->defaultDrawShader) {
// Shader based unclamped path:
if (colors) glTexCoordPointer(mc, GL_DOUBLE, 0, colors);
// Can't support uint8 datatype for this vertex attribute :-(
if (bytecolors) PsychErrorExitMsg(PsychError_user, "Sorry, this function can't accept matrices of uint8 type for colors\nif color clamping is disabled or high precision mode active.\n Use the double() operator to convert to double matrix.");
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glColorPointer(4, GL_DOUBLE, 0, NULL);
}
else {
// Standard path:
if (colors) glColorPointer(mc, GL_DOUBLE, 0, colors);
if (bytecolors) glColorPointer(mc, GL_UNSIGNED_BYTE, 0, bytecolors);
glEnableClientState(GL_COLOR_ARRAY);
glTexCoordPointer(4, GL_DOUBLE, 0, NULL);
}
}
else {
// Disable whatever's used:
if (windowRecord->defaultDrawShader) {
// Shader based unclamped path:
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
else {
// Standard path:
glDisableClientState(GL_COLOR_ARRAY);
}
glColorPointer(4, GL_DOUBLE, 0, NULL);
glTexCoordPointer(4, GL_DOUBLE, 0, NULL);
}
}
PsychError SCREENTextMode(void)
{
PsychTextDrawingModeType newCopyMode;
Str255 oldCopyModeName;
char *newCopyModeName;
psych_bool doSetMode;
PsychWindowRecordType *windowRecord;
psych_bool nameError;
//all subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for valid number of arguments
PsychErrorExit(PsychRequireNumInputArgs(1));
PsychErrorExit(PsychCapNumInputArgs(2));
PsychErrorExit(PsychCapNumOutputArgs(1));
//Get the window record
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
//Get the old copy mode & its name
PsychGetTextDrawingModeNameFromTextDrawingModeConstant(oldCopyModeName, 255, windowRecord->textAttributes.textMode);
PsychCopyOutCharArg(1, FALSE, oldCopyModeName);
//Get the copy new mode string
doSetMode= PsychAllocInCharArg(2, FALSE, &newCopyModeName);
if(doSetMode){
nameError=PsychGetTextDrawingModeConstantFromTextDrawingModeName(&newCopyMode, newCopyModeName);
if(nameError)
PsychErrorExitMsg(PsychError_user, "Invalid text copy mode. See Screen('TextModes') for a list of allowable modes");
windowRecord->textAttributes.needsRebuild|=(windowRecord->textAttributes.textMode != newCopyMode) ? TRUE : FALSE;
windowRecord->textAttributes.textMode=newCopyMode;
}
return(PsychError_none);
}
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;
}
PsychError SCREENCloseVideoCapture(void)
{
int capturehandle = -1;
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()) {PsychGiveHelp(); return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(1)); // Max. 1 input args.
PsychErrorExit(PsychRequireNumInputArgs(1)); // Min. 1 input args required.
PsychErrorExit(PsychCapNumOutputArgs(0)); // No output args.
// Get the handle:
PsychCopyInIntegerArg(1, TRUE, &capturehandle);
if (capturehandle==-1) {
PsychErrorExitMsg(PsychError_user, "CloseVideoCapture called without valid handle to a capture object.");
}
// Try to delete the object, releasing all associated ressources:
PsychCloseVideoCaptureDevice(capturehandle);
// Ready!
return(PsychError_none);
}
void APIENTRY PsychtcbCombine(GLdouble c[3], void *d[4], GLfloat w[4], void **out)
{
GLdouble *nv;
(void) d, (void) w;
// Free slots available?
if (combinerCacheSlot >= combinerCacheSize) {
// Nope. Need to alloc another cache for up to another 1000 elements:
combinerCacheSize = 1000;
combinerCacheSlot = 0;
combinerCache = (GLdouble *) PsychMallocTemp(sizeof(GLdouble) * 3 * combinerCacheSize);
if (NULL == combinerCache) PsychErrorExitMsg(PsychError_outofMemory, "Out of memory condition in Screen('FillPoly')! Not enough space.");
}
nv = (GLdouble *) &(combinerCache[combinerCacheSlot * 3]);
nv[0] = c[0];
nv[1] = c[1];
nv[2] = c[2];
*out = nv;
combinerCacheSlot++;
}
PsychError SCREENGetMovieTimeIndex(void)
{
int moviehandle = -1;
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()) {PsychGiveHelp(); return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(1)); // Max. 1 input args.
PsychErrorExit(PsychRequireNumInputArgs(1)); // Min. 1 input args required.
PsychErrorExit(PsychCapNumOutputArgs(1)); // One output arg.
// Get the movie handle:
PsychCopyInIntegerArg(1, TRUE, &moviehandle);
if (moviehandle==-1) {
PsychErrorExitMsg(PsychError_user, "GetMovieTimeIndex called without valid handle to a movie object.");
}
// Retrieve and return current movie time index:
PsychCopyOutDoubleArg(1, TRUE, PsychGetMovieTimeIndex(moviehandle));
return(PsychError_none);
}
psych_bool PsychHIDCreateEventBuffer(int deviceIndex)
{
unsigned int bufferSize;
if (deviceIndex < 0) deviceIndex = PsychHIDGetDefaultKbQueueDevice();
bufferSize = hidEventBufferCapacity[deviceIndex];
// Already created? If so, nothing to do:
if (hidEventBuffer[deviceIndex] || (bufferSize < 1)) return(FALSE);
hidEventBuffer[deviceIndex] = (PsychHIDEventRecord*) calloc(sizeof(PsychHIDEventRecord), bufferSize);
if (NULL == hidEventBuffer[deviceIndex]) PsychErrorExitMsg(PsychError_outofMemory, "Insufficient memory to create KbQueue event buffer!");
// Prepare mutex for buffer:
PsychInitMutex(&hidEventBufferMutex[deviceIndex]);
PsychInitCondition(&hidEventBufferCondition[deviceIndex], NULL);
// Flush it:
PsychHIDFlushEventBuffer(deviceIndex);
return(TRUE);
}
PsychError SCREENGlobalRect(void)
{
int screenNumber;
PsychWindowRecordType *windowRecord;
PsychRectType rect;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(1));
PsychErrorExit(PsychRequireNumInputArgs(1));
PsychErrorExit(PsychCapNumOutputArgs(1));
if(PsychIsScreenNumberArg(1)) {
// Real screen id: Get screens global rect and return it:
PsychCopyInScreenNumberArg(1, TRUE, &screenNumber);
PsychGetGlobalScreenRect(screenNumber, rect);
PsychCopyOutRectArg(1, FALSE, rect);
}
else if(PsychIsWindowIndexArg(1)) {
// Window:
PsychAllocInWindowRecordArg(1, TRUE, &windowRecord);
// Onscreen?
if (PsychIsOnscreenWindow(windowRecord)) {
PsychCopyOutRectArg(1, FALSE, windowRecord->globalrect);
}
else {
PsychCopyOutRectArg(1, FALSE, windowRecord->rect);
}
}
else PsychErrorExitMsg(PsychError_user, "Argument was recognized as neither a window index nor a screen pointer");
return(PsychError_none);
}
/*
PsychExtractQuadVertexFromRect()
Return one of the four vertices define by a Psych rect in a 2-element array of GLdoubles.
Vertices are numbered from the top left corner (0) clockwise to the bottom left corner (3).
*/
GLdouble *PsychExtractQuadVertexFromRect(double *rect, int vertexNumber, GLdouble *vertex)
{
switch(vertexNumber){
case 0:
vertex[0]=(GLdouble)rect[0];
vertex[1]=(GLdouble)rect[1];
break;
case 1:
vertex[0]=(GLdouble)rect[2];
vertex[1]=(GLdouble)rect[1];
break;
case 2:
vertex[0]=(GLdouble)rect[2];
vertex[1]=(GLdouble)rect[3];
break;
case 3:
vertex[0]=(GLdouble)rect[0];
vertex[1]=(GLdouble)rect[3];
break;
default:
PsychErrorExitMsg(PsychError_internal, "Illegal vertex value");
}
return(vertex);
}
void PsychLoadNormalizedGammaTable(int screenNumber, int numEntries, float *redTable, float *greenTable, float *blueTable)
{
CGDirectDisplayID cgDisplayID;
int i;
psych_uint16 RTable[256];
psych_uint16 GTable[256];
psych_uint16 BTable[256];
// Table must have 256 slots!
if (numEntries!=256) PsychErrorExitMsg(PsychError_user, "Loadable hardware gamma tables must have 256 slots!");
// The X-Windows hardware LUT has 3 tables for R,G,B, 256 slots each.
// Each entry is a 16-bit word with the n most significant bits used for an n-bit DAC.
// Convert input table to X11 specific gammaTable:
for (i=0; i<256; i++) RTable[i] = (int)(redTable[i] * 65535.0f + 0.5f);
for (i=0; i<256; i++) GTable[i] = (int)(greenTable[i] * 65535.0f + 0.5f);
for (i=0; i<256; i++) BTable[i] = (int)(blueTable[i] * 65535.0f + 0.5f);
// Set new gammaTable:
PsychGetCGDisplayIDFromScreenNumber(&cgDisplayID, screenNumber);
XF86VidModeSetGammaRamp(cgDisplayID, PsychGetXScreenIdForScreen(screenNumber), 256, (unsigned short*) RTable, (unsigned short*) GTable, (unsigned short*) BTable);
return;
}
void PsychEnumerateVideoSources(int engineId, int outPos)
{
psych_bool dispatched = FALSE;
#ifdef PTBVIDEOCAPTURE_LIBDC
if (engineId == 1) {
PsychDCEnumerateVideoSources(outPos);
dispatched = TRUE;
}
#endif
#ifdef PTB_USE_GSTREAMER
if (engineId == 3) {
// GStreamer device enumeration:
PsychGSEnumerateVideoSources(outPos, -1, NULL);
dispatched = TRUE;
}
#endif
// Unsupported engine requested?
if (!dispatched) PsychErrorExitMsg(PsychError_user, "The requested video capture engine is not supported on your system, either not at all, or has been disabled at compile time.");
return;
}
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 SCREENCreateMovie(void)
{
static char useString[] = "moviePtr = Screen('CreateMovie', windowPtr, movieFile [, width][, height][, frameRate=30][, movieOptions][, numChannels=4][, bitdepth=8]);";
static char synopsisString[] =
"Create a new movie file with filename 'movieFile' and according to given 'movieOptions'.\n"
"The function returns a handle 'moviePtr' to the file.\n"
"Currently only single-track video encoding is supported.\n"
"See 'Screen AddAudioBufferToMovie?' on how to add audio tracks to movies.\n"
"\n"
"Movie creation is a 3 step procedure:\n"
"1. Create a movie and define encoding options via 'CreateMovie'.\n"
"2. Add video and audio data to the movie via calls to 'AddFrameToMovie' et al.\n"
"3. Finalize and close the movie via a call to 'FinalizeMovie'.\n\n"
"All following parameters are optional and have reasonable defaults:\n\n"
"'width' Width of movie video frames in pixels. Defaults to width of window 'windowPtr'.\n"
"'height' Height of movie video frames in pixels. Defaults to height of window 'windowPtr'.\n"
"'frameRate' Playback framerate of movie. Defaults to 30 fps. Technically this is not the "
"playback framerate but the granularity in 1/frameRate seconds with which the duration of "
"a single movie frame can be specified. When you call 'AddFrameToMovie', there's an optional "
"parameter 'frameDuration' which defaults to one. The parameter defines the display duration "
"of that frame as the fraction 'frameDuration' / 'frameRate' seconds, so 'frameRate' defines "
"the denominator of that term. However, for a default 'frameDuration' of one, this is equivalent "
"to the 'frameRate' of the movie, at least if you leave everything at defaults.\n\n"
"'movieoptions' a textstring which allows to define additional parameters via keyword=parm pairs. "
"For GStreamer movie writing, you can provide the same options as for GStreamer video recording. "
"See 'help VideoRecording' for supported options and tips.\n"
"Keywords unknown to a certain implementation or codec will be silently ignored:\n"
"EncodingQuality=x Set encoding quality to value x, in the range 0.0 for lowest movie quality to "
"1.0 for highest quality. Default is 0.5 = normal quality. 1.0 often provides near-lossless encoding.\n"
"'numChannels' Optional number of image channels to encode: Can be 1, 3 or 4 on OpenGL graphics hardware, "
"and 3 or 4 on OpenGL-ES hardware. 1 = Red/Grayscale channel only, 3 = RGB, 4 = RGBA. Please note that not "
"all video codecs can encode pure 1 channel data or RGBA data, ie. an alpha channel. If an unsuitable codec "
"is selected, movie writing may fail, or unsupported channels (e.g., the alpha channel) may get silently "
"discarded. It could also happen that a codec which doesn't support 1 channel storage will replicate "
"the Red/Grayscale data into all three RGB channels, leading to no data loss but increased movie file size. "
"Default is to request RGBA 4 channel data from the system, encoding to RGBA or RGB, depending on codec.\n"
"'bitdepth' Optional color/intensity resolution of each channel: Default is 8 bpc, for 8 bit per component "
"storage. OpenGL graphics hardware, but not OpenGL-ES, also supports 16 bpc image readback. However, not all "
"codecs can encode with > 8 bpc color/luminance precision, so encoding with 16 bpc may fail or silently reduce "
"precision to less bits, possibly 8 bpc or less. If you specify the special keyword UsePTB16BPC in 'movieoptions', "
"then PTB will use its own proprietary 16 bpc format for 1 or 3 channel mode. This format can only be read by "
"PTB's own movie playback functions, not by other software.\n"
"In general, embedded OpenGL-ES graphics hardware is more restricted in the type of image data it can return. "
"Most video codecs are lossy codecs. They will intentionally throw away color or spatial precision of encoded "
"video to reduce video file size or network bandwidth, often in a way that is not easily perceptible to the "
"naked eye. If you require high fidelity, make sure to double-check your results for a given codec + parameter "
"setup, e.g., via encoding + decoding the movie and checking the original data against decoded data.\n"
"\n";
static char seeAlsoString[] = "FinalizeMovie AddFrameToMovie CloseMovie PlayMovie GetMovieImage GetMovieTimeIndex SetMovieTimeIndex";
PsychWindowRecordType *windowRecord;
char *moviefile;
char *movieOptions;
int moviehandle = -1;
double framerate = 30.0;
int width;
int height;
int numChannels, bitdepth;
char defaultOptions[2] = "";
// 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(2)); // Min. 2 input args required.
PsychErrorExit(PsychCapNumOutputArgs(1)); // Max. 1 output args.
// Get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
// Only onscreen windows allowed:
if(!PsychIsOnscreenWindow(windowRecord)) {
PsychErrorExitMsg(PsychError_user, "CreateMovie called on something else than an onscreen window.");
}
// Get the movie name string:
moviefile = NULL;
PsychAllocInCharArg(2, kPsychArgRequired, &moviefile);
// Get the optional size:
// Default Width and Height of movie frames is derived from size of window:
width = (int) PsychGetWidthFromRect(windowRecord->clientrect);
height = (int) PsychGetHeightFromRect(windowRecord->clientrect);
PsychCopyInIntegerArg(3, kPsychArgOptional, &width);
PsychCopyInIntegerArg(4, kPsychArgOptional, &height);
// Get the optional framerate:
PsychCopyInDoubleArg(5, kPsychArgOptional, &framerate);
// Get the optional options string:
movieOptions = defaultOptions;
PsychAllocInCharArg(6, kPsychArgOptional, &movieOptions);
// Get optional number of channels of movie:
numChannels = 4;
PsychCopyInIntegerArg(7, kPsychArgOptional, &numChannels);
if (numChannels != 1 && numChannels != 3 && numChannels != 4) PsychErrorExitMsg(PsychError_user, "Invalid number of channels 'numChannels' provided. Only 1, 3 or 4 channels allowed!");
// Get optional bitdepth of movie:
bitdepth = 8;
PsychCopyInIntegerArg(8, kPsychArgOptional, &bitdepth);
if (bitdepth != 8 && bitdepth != 16) PsychErrorExitMsg(PsychError_user, "Invalid 'bitdepth' provided. Only 8 bpc or 16 bpc allowed!");
// Create movie of given size and framerate with given options:
moviehandle = PsychCreateNewMovieFile(moviefile, width, height, framerate, numChannels, bitdepth, movieOptions, NULL);
if (0 > moviehandle) {
PsychErrorExitMsg(PsychError_user, "CreateMovie failed for reason mentioned above.");
}
// Return handle to it:
PsychCopyOutDoubleArg(1, FALSE, (double) moviehandle);
return(PsychError_none);
}
PsychError SCREENSetOpenGLTextureFromMemPointer(void)
{
PsychWindowRecordType *windowRecord, *textureRecord;
int w, h, d, testarg, upsidedown, glinternalformat, glexternaltype, glexternalformat;
double doubleMemPtr;
GLenum target = 0;
w=h=d=-1;
doubleMemPtr = 0;
upsidedown = 0;
//all subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(11)); // The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(5)); // The required number of inputs
PsychErrorExit(PsychCapNumOutputArgs(2)); // The maximum number of outputs
// Get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
// Get the texture record from the texture record argument.
// Check if either none ( [] or '' ) or the special value zero was
// provided as Psychtoolbox textureHandle. In that case, we create a new
// empty texture record instead of reusing an existing one.
testarg=0;
PsychCopyInIntegerArg(2, FALSE, &testarg);
if (testarg==0) {
// No valid textureHandle provided. Create a new empty textureRecord.
PsychCreateWindowRecord(&textureRecord);
textureRecord->windowType=kPsychTexture;
textureRecord->screenNumber = windowRecord->screenNumber;
textureRecord->targetSpecific.contextObject = windowRecord->targetSpecific.contextObject;
textureRecord->targetSpecific.deviceContext = windowRecord->targetSpecific.deviceContext;
textureRecord->targetSpecific.glusercontextObject = windowRecord->targetSpecific.glusercontextObject;
textureRecord->colorRange = windowRecord->colorRange;
// Copy imaging mode flags from parent:
textureRecord->imagingMode = windowRecord->imagingMode;
// Mark it valid and return handle to userspace:
PsychSetWindowRecordValid(textureRecord);
}
else {
// None of the special values provided. We assume its a handle to a valid
// and existing PTB texture and try to retrieve the textureRecord:
PsychAllocInWindowRecordArg(2, TRUE, &textureRecord);
}
// Is it a textureRecord?
if (!PsychIsTexture(textureRecord)) {
PsychErrorExitMsg(PsychError_user, "You tried to set texture information on something else than a texture!");
}
// Query double-encoded memory pointer:
PsychCopyInDoubleArg(3, TRUE, &doubleMemPtr);
// Query width:
PsychCopyInIntegerArg(4, TRUE, &w);
// Query height:
PsychCopyInIntegerArg(5, TRUE, &h);
// Query depth:
PsychCopyInIntegerArg(6, TRUE, &d);
// Query (optional) upsidedown - flag:
PsychCopyInIntegerArg(7, FALSE, &upsidedown);
// Query (optional) OpenGL texture target:
PsychCopyInIntegerArg(8, FALSE, (int*) &target);
// Query (optional) full format spec:
glinternalformat = 0;
PsychCopyInIntegerArg(9, FALSE, &glinternalformat);
if (glinternalformat>0) {
// Ok copy the (now non-optional) remaining format spec:
PsychCopyInIntegerArg(10, TRUE, &glexternalformat);
PsychCopyInIntegerArg(11, TRUE, &glexternaltype);
}
// Safety checks:
if (doubleMemPtr == 0) {
PsychErrorExitMsg(PsychError_user, "You tried to set invalid (NULL) imagePtr.");
}
if (w<=0) {
PsychErrorExitMsg(PsychError_user, "You tried to set invalid (negative) texture width.");
}
if (h<=0) {
PsychErrorExitMsg(PsychError_user, "You tried to set invalid (negative) texture height.");
}
if (d<=0) {
PsychErrorExitMsg(PsychError_user, "You tried to set invalid (negative) texture depth.");
}
if (d>4) {
PsychErrorExitMsg(PsychError_user, "You tried to set invalid (greater than four) texture depth.");
}
if (target!=0 && target!=GL_TEXTURE_RECTANGLE_EXT && target!=GL_TEXTURE_2D) {
PsychErrorExitMsg(PsychError_user, "You tried to set invalid texture target.");
}
// Activate OpenGL rendering context of windowRecord and make it the active drawing target:
PsychSetGLContext(windowRecord);
PsychSetDrawingTarget(windowRecord);
PsychTestForGLErrors();
// Ok, setup texture record for texture:
PsychInitWindowRecordTextureFields(textureRecord);
textureRecord->depth = d * 8;
textureRecord->nrchannels = d;
PsychMakeRect(textureRecord->rect, 0, 0, w, h);
// Override texture target, if one was provided:
if (target!=0) textureRecord->texturetarget = target;
// Orientation is normally set to 2 - like an upright Offscreen window texture.
// If upsidedown flag is set, then we do 3 - an upside down Offscreen window texture.
textureRecord->textureOrientation = (upsidedown>0) ? 3 : 2;
if (glinternalformat!=0) {
textureRecord->textureinternalformat = glinternalformat;
textureRecord->textureexternalformat = glexternalformat;
textureRecord->textureexternaltype = glexternaltype;
}
// Setting memsize to zero prevents unwanted free() operation in PsychDeleteTexture...
textureRecord->textureMemorySizeBytes = 0;
// This will retrieve an OpenGL compatible pointer to the raw pixel data and assign it to our texmemptr:
textureRecord->textureMemory = (GLuint*) PsychDoubleToPtr(doubleMemPtr);
// printf("InTexPtr %p , %.20e", PsychDoubleToPtr(doubleMemPtr), doubleMemPtr);
// Let PsychCreateTexture() do the rest of the job of creating, setting up and
// filling an OpenGL texture with memory buffers image content:
PsychCreateTexture(textureRecord);
// Return new (or old) PTB textureHandle for this texture:
PsychCopyOutDoubleArg(1, FALSE, textureRecord->windowIndex);
PsychCopyOutRectArg(2, FALSE, textureRecord->rect);
// Done.
return(PsychError_none);
}
PsychError SCREENPreloadTextures(void)
{
PsychWindowRecordType *windowRecord, *texwin;
psych_bool isArgThere;
int *texhandles;
PsychWindowRecordType **windowRecordArray;
int i, n, numWindows, myhandle;
double *success;
psych_bool* residency;
GLuint* texids;
GLboolean* texresident;
psych_bool failed = false;
GLclampf maxprio = 1.0f;
GLenum target;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(2)); //The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(1)); //The minimum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(2)); //The maximum number of outputs
//get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(1, kPsychArgRequired, &windowRecord);
// Get optional texids vector:
isArgThere = PsychIsArgPresent(PsychArgIn, 2);
PsychAllocInIntegerListArg(2, FALSE, &n, &texhandles);
if (n < 1) isArgThere=FALSE;
// Enable this windowRecords framebuffer as current drawingtarget:
PsychSetDrawingTarget(windowRecord);
// Disable shader:
PsychSetShader(windowRecord, 0);
glDisable(GL_TEXTURE_2D);
// Fetch global texturing mode:
target=PsychGetTextureTarget(windowRecord);
glEnable(target);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor4f(0, 0, 0, 0);
// Setup identity modelview matrix:
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
PsychCreateVolatileWindowRecordPointerList(&numWindows, &windowRecordArray);
// Process vector of all texids for all requested textures:
if (!isArgThere) {
// No handles provided: In this case, we preload all textures:
n=0;
for(i=0; i<numWindows; i++) {
if (windowRecordArray[i]->windowType==kPsychTexture) {
n++;
// Prioritize this texture:
glPrioritizeTextures(1, (GLuint*) &(windowRecordArray[i]->textureNumber), &maxprio);
// Bind this texture:
glBindTexture(target, windowRecordArray[i]->textureNumber);
// Render a single textured point, thereby enforcing a texture upload:
glBegin(GL_QUADS);
glTexCoord2f(0,0); glVertex2i(10,10);
glTexCoord2f(0,1); glVertex2i(10,11);
glTexCoord2f(1,1); glVertex2i(11,11);
glTexCoord2f(1,0); glVertex2i(11,10);
glEnd();
}
}
texids = (GLuint*) PsychMallocTemp(sizeof(GLuint) * n);
texresident = (GLboolean*) PsychMallocTemp(sizeof(GLboolean) * n);
n=0;
for(i=0; i<numWindows; i++) {
if (windowRecordArray[i]->windowType==kPsychTexture) {
texids[n] = (GLuint) windowRecordArray[i]->textureNumber;
n++;
}
}
}
else {
// Vector with texture handles provided: Just preload them.
texids = (GLuint*) PsychMallocTemp(sizeof(GLuint) * n);
texresident = (GLboolean*) PsychMallocTemp(sizeof(GLboolean) * n);
myhandle=0;
for (i=0; i<n; i++) {
myhandle = texhandles[i];
texwin = NULL;
if (IsWindowIndex(myhandle)) FindWindowRecord(myhandle, &texwin);
if (texwin && texwin->windowType==kPsychTexture) {
// Prioritize this texture:
glPrioritizeTextures(1, (GLuint*) &(texwin->textureNumber), &maxprio);
// Bind this texture:
glBindTexture(target, texwin->textureNumber);
// Render a single textured point, thereby enforcing a texture upload:
glBegin(GL_QUADS);
glTexCoord2f(0,0); glVertex2i(10,10);
glTexCoord2f(0,1); glVertex2i(10,11);
glTexCoord2f(1,1); glVertex2i(11,11);
glTexCoord2f(1,0); glVertex2i(11,10);
glEnd();
texids[i] = (GLuint) texwin->textureNumber;
}
else {
// This handle is invalid or at least no texture handle:
printf("PTB-ERROR! Screen('PreloadTextures'): Entry %i of texture handle vector (handle %i) is not a texture handle!\n",
i, myhandle);
failed = true;
}
}
}
// Restore old matrix from backup copy, undoing the global translation:
glPopMatrix();
// Disable texture engine:
glDisable(GL_TEXTURE_2D);
glDisable(target);
// Wait for prefetch completion:
glFinish();
// We don't need these anymore:
PsychDestroyVolatileWindowRecordPointerList(windowRecordArray);
if (failed) {
PsychErrorExitMsg(PsychError_user, "At least one texture handle in texids-vector was invalid! Aborted.");
}
// Query residency state of all preloaded textures:
success = NULL;
PsychAllocOutDoubleArg(1, FALSE, &success);
*success = (double) glAreTexturesResident(n, texids, texresident);
// Sync pipe again, just to be safe...
glFinish();
// Count them and copy them into output vector:
PsychAllocOutBooleanMatArg(2, FALSE, n, 1, 1, &residency);
for (i=0; i<n; i++) {
residency[i] = (psych_bool) ((*success) ? TRUE : texresident[i]);
}
PsychTestForGLErrors();
// Done. Our PsychMallocTemp'ed arrays will be auto-released...
return(PsychError_none);
}
PsychError SCREENDrawLines(void)
{
PsychWindowRecordType *windowRecord;
int m,n,p, smooth;
int nrsize, nrcolors, nrvertices, mc, nc, pc, i;
boolean isArgThere, usecolorvector, isdoublecolors, isuint8colors;
double *xy, *size, *center, *dot_type, *colors;
unsigned char *bytecolors;
float linesizerange[2];
double convfactor;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(6)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(0)); //The maximum number of outputs
//get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(1, kPsychArgRequired, &windowRecord);
// Query, allocate and copy in all vectors...
nrvertices = 2;
nrsize = 1;
colors = NULL;
bytecolors = NULL;
PsychPrepareRenderBatch(windowRecord, 2, &nrvertices, &xy, 4, &nc, &mc, &colors, &bytecolors, 3, &nrsize, &size);
isdoublecolors = (colors) ? TRUE:FALSE;
isuint8colors = (bytecolors) ? TRUE:FALSE;
usecolorvector = (nc>1) ? TRUE:FALSE;
// Get center argument
isArgThere = PsychIsArgPresent(PsychArgIn, 5);
if(!isArgThere){
center = (double *) PsychMallocTemp(2 * sizeof(double));
center[0] = 0;
center[1] = 0;
} else {
PsychAllocInDoubleMatArg(5, TRUE, &m, &n, &p, ¢er);
if(p!=1 || n!=2 || m!=1) PsychErrorExitMsg(PsychError_user, "center must be a 1-by-2 vector");
}
// Get smooth argument
isArgThere = PsychIsArgPresent(PsychArgIn, 6);
if(!isArgThere){
smooth = 0;
} else {
PsychAllocInDoubleMatArg(6, TRUE, &m, &n, &p, &dot_type);
smooth = (int) dot_type[0];
if(p!=1 || n!=1 || m!=1 || (smooth!=0 && smooth!=1)) PsychErrorExitMsg(PsychError_user, "smooth must be 0 or 1");
}
// Child-protection: Alpha blending needs to be enabled for smoothing to work:
if (smooth>0 && windowRecord->actualEnableBlending!=TRUE) {
PsychErrorExitMsg(PsychError_user, "Line smoothing doesn't work with alpha-blending disabled! See Screen('BlendFunction') on how to enable it.");
}
// turn on antialiasing to draw anti-aliased lines:
if(smooth) glEnable(GL_LINE_SMOOTH);
// Set global width of lines:
glLineWidth(size[0]);
// Setup modelview matrix to perform translation by 'center':
glMatrixMode(GL_MODELVIEW);
// Make a backup copy of the matrix:
glPushMatrix();
// Apply a global translation of (center(x,y)) pixels to all following lines:
glTranslated(center[0], center[1],0);
// Render the array of 2D-Lines - Efficient version:
// This command sequence allows fast processing of whole arrays
// of vertices (or lines, in this case). It saves the call overhead
// associated with the original implementation below and is potentially
// optimized in specific OpenGL implementations.
// Pass a pointer to the start of the arrays:
glVertexPointer(2, GL_DOUBLE, 0, &xy[0]);
if (usecolorvector) {
if (isdoublecolors) glColorPointer(mc, GL_DOUBLE, 0, colors);
if (isuint8colors) glColorPointer(mc, GL_UNSIGNED_BYTE, 0, bytecolors);
glEnableClientState(GL_COLOR_ARRAY);
}
// Enable fast rendering of arrays:
glEnableClientState(GL_VERTEX_ARRAY);
if (nrsize==1) {
// Common line-width for all lines: Render all lines, starting at line 0:
glDrawArrays(GL_LINES, 0, nrvertices);
}
else {
// Different line-width per line: Need to manually loop through this mess:
for (i=0; i < nrvertices/2; i++) {
glLineWidth(size[i]);
// Render line:
glDrawArrays(GL_LINES, i * 2, 2);
}
}
// Disable fast rendering of arrays:
glDisableClientState(GL_VERTEX_ARRAY);
if (usecolorvector) glDisableClientState(GL_COLOR_ARRAY);
// Restore old matrix from backup copy, undoing the global translation:
glPopMatrix();
// Turn off anti-aliasing:
if(smooth) glDisable(GL_LINE_SMOOTH);
// Reset line width to 1.0:
glLineWidth(1);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
//All psychfunctions require this.
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);
}
// Special console handler: Performs functions of ListenChar, FlushEvents,
// CharAvail and GetChar when run in terminal mode without GUI and JavaVM:
void ConsoleInputHelper(int ccode)
{
int ret;
switch(ccode) {
case -10: // ListenChar(0);
// Disable char listening:
listenchar_enabled = 0;
_kbhit();
break;
case -11: // ListenChar(1);
// Enable char listening:
listenchar_enabled = 1;
_kbhit();
break;
case -12: // ListenChar(2);
// Enable char listening and suppress output to console:
listenchar_enabled = 1 + 2;
_kbhit();
break;
case -13: // FlushEvents:
// Enable char listening:
listenchar_enabled |= 1;
// Drain queue from all pending characters:
while (_kbhit()) getchar();
break;
case -14: // CharAvail():
// Enable char listening:
listenchar_enabled |= 1;
// Return number of pending chars in queue:
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double) _kbhit());
break;
case -15: // GetChar():
// Enable char listening:
listenchar_enabled |= 1;
// Retrieve one character: Return if none available.
// We call _kbhit() once to turn the terminal into non-blocking mode,
// so it doesn't wait for newlines:
if (0 == _kbhit()) {
// Nothing available: Return zero result code:
ret = 0;
}
else {
// At least one available: Fetch one...
ret = getchar();
// Valid?
if (ret == EOF) {
// Failed - End of stream or error! Clear error condition:
clearerr(stdin);
errno = 0;
// Return error code -1:
ret = -1;
}
}
// Return whatever we've got:
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double) ret);
break;
default:
PsychErrorExitMsg(PsychError_internal, "Invalid command code encountered in ConsoleInputHelper()! This is an implementation BUG!");
}
return;
}