/*
PsychIsLastWindow()
Is this the last open onscreen window for this screen ?
SCREENClose needs to know this so that it can release the screen
*/
boolean PsychIsLastOnscreenWindow(PsychWindowRecordType *windowRecord)
{
int i;
if(!PsychIsOnscreenWindow(windowRecord))
return(FALSE);
for(i=PSYCH_FIRST_WINDOW;i<=PSYCH_LAST_WINDOW;i++){
if(windowRecordArrayWINBANK[i]){
if(windowRecordArrayWINBANK[i]->screenNumber == windowRecord->screenNumber &&
windowRecordArrayWINBANK[i]->windowIndex != windowRecord->windowIndex &&
(windowRecordArrayWINBANK[i]->windowType == kPsychSingleBufferOnscreen ||
windowRecordArrayWINBANK[i]->windowType == kPsychDoubleBufferOnscreen))
return(FALSE);
}
}
return(TRUE);
}
// Perform OS specific processing of Window events:
void PsychOSProcessEvents(PsychWindowRecordType *windowRecord, int flags)
{
Rect globalBounds;
// Trigger event queue dispatch processing for GUI windows:
if (windowRecord == NULL) {
// No op, so far...
return;
}
// GUI windows need to behave GUIyee:
if ((windowRecord->specialflags & kPsychGUIWindow) && PsychIsOnscreenWindow(windowRecord)) {
// Update windows rect and globalrect, based on current size and location:
PsychCocoaGetWindowBounds(windowRecord->targetSpecific.windowHandle, windowRecord->globalrect, windowRecord->rect);
PsychSetupClientRect(windowRecord);
PsychSetupView(windowRecord, FALSE);
}
}
/* 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 PsychFindScreenWindowFromScreenNumber(int screenNumber, PsychWindowRecordType **winRec)
{
int i, numWindows;
PsychWindowRecordType **windowArray;
*winRec=NULL;
if(screenNumber==kPsychUnaffiliatedWindow)
return;
PsychCreateVolatileWindowRecordPointerList(&numWindows, &windowArray);
for(i=0;i<numWindows;i++){
if(PsychIsOnscreenWindow(windowArray[i])){
if(windowArray[i]->screenNumber==screenNumber){
*winRec=windowArray[i];
break;
}
}
}
PsychDestroyVolatileWindowRecordPointerList(windowArray);
}
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);
}
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 SCREENGetWindowInfo(void)
{
const char *FieldNames[]={ "Beamposition", "LastVBLTimeOfFlip", "LastVBLTime", "VBLCount", "TimeAtSwapRequest", "TimePostSwapRequest", "RawSwapTimeOfFlip",
"VBLTimePostFlip", "OSSwapTimestamp", "GPULastFrameRenderTime", "StereoMode", "ImagingMode", "MultiSampling", "MissedDeadlines", "FlipCount", "StereoDrawBuffer",
"GuesstimatedMemoryUsageMB", "VBLStartline", "VBLEndline", "VideoRefreshFromBeamposition", "GLVendor", "GLRenderer", "GLVersion", "GPUCoreId",
"GLSupportsFBOUpToBpc", "GLSupportsBlendingUpToBpc", "GLSupportsTexturesUpToBpc", "GLSupportsFilteringUpToBpc", "GLSupportsPrecisionColors",
"GLSupportsFP32Shading", "BitsPerColorComponent", "IsFullscreen", "SpecialFlags", "SwapGroup", "SwapBarrier" };
const int fieldCount = 35;
PsychGenericScriptType *s;
PsychWindowRecordType *windowRecord;
double beamposition, lastvbl;
int infoType = 0, retIntArg;
double auxArg1, auxArg2, auxArg3;
CGDirectDisplayID displayId;
psych_uint64 postflip_vblcount;
double vbl_startline;
long scw, sch;
psych_bool onscreen;
//all subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(5)); //The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(1)); //The required number of inputs
PsychErrorExit(PsychCapNumOutputArgs(1)); //The maximum number of outputs
// Query infoType flag: Defaults to zero.
PsychCopyInIntegerArg(2, FALSE, &infoType);
if (infoType < 0 || infoType > 5) PsychErrorExitMsg(PsychError_user, "Invalid 'infoType' argument specified! Valid are 0, 1, 2, 3, 4 and 5.");
// Windowserver info requested?
if (infoType == 2 || infoType == 3) {
// Return info about WindowServer:
#if PSYCH_SYSTEM == PSYCH_OSX
const char *CoreGraphicsFieldNames[]={ "CGSFps", "CGSValue1", "CGSValue2", "CGSValue3", "CGSDebugOptions" };
const int CoreGraphicsFieldCount = 5;
float cgsFPS, val1, val2, val3;
// This (undocumented) Apple call retrieves information about performance statistics of
// the Core graphics server, also known as WindowServer or Quartz compositor:
CGSGetPerformanceData(_CGSDefaultConnection(), &cgsFPS, &val1, &val2, &val3);
if (CGSGetDebugOptions(&retIntArg)) {
if (PsychPrefStateGet_Verbosity() > 1) printf("PTB-WARNING: GetWindowInfo: Call to CGSGetDebugOptions() failed!\n");
}
PsychAllocOutStructArray(1, FALSE, 1, CoreGraphicsFieldCount, CoreGraphicsFieldNames, &s);
PsychSetStructArrayDoubleElement("CGSFps", 0 , cgsFPS, s);
PsychSetStructArrayDoubleElement("CGSValue1", 0, val1, s);
PsychSetStructArrayDoubleElement("CGSValue2", 0, val2, s);
PsychSetStructArrayDoubleElement("CGSValue3", 0, val3, s);
PsychSetStructArrayDoubleElement("CGSDebugOptions", 0, (double) retIntArg, s);
if ( (infoType == 3) && PsychCopyInDoubleArg(3, FALSE, &auxArg1) ) {
// Type 3 setup request with auxArg1 provided. Apple auxArg1 as debugFlag setting
// for the CoreGraphics server: DANGEROUS!
if (CGSSetDebugOptions((unsigned int) auxArg1)) {
if (PsychPrefStateGet_Verbosity() > 1) printf("PTB-WARNING: GetWindowInfo: Call to CGSSetDebugOptions() failed!\n");
}
}
#endif
#if PSYCH_SYSTEM == PSYCH_WINDOWS
psych_uint64 onsetVBLCount, frameId;
double onsetVBLTime, compositionRate;
psych_uint64 targetVBL;
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
// Query all DWM presentation timing info, return full info as struct in optional return argument '1':
if (PsychOSGetPresentationTimingInfo(windowRecord, TRUE, 0, &onsetVBLCount, &onsetVBLTime, &frameId, &compositionRate, 1)) {
// Query success: Info struct has been created and returned by PsychOSGetPresentationTimingInfo()...
auxArg1 = auxArg2 = 0;
auxArg3 = 2;
// Want us to change settings?
if ( (infoType == 3) && PsychCopyInDoubleArg(3, FALSE, &auxArg1) && PsychCopyInDoubleArg(4, FALSE, &auxArg2) && PsychCopyInDoubleArg(5, FALSE, &auxArg3)) {
if (auxArg1 < 0) auxArg1 = 0;
targetVBL = auxArg1;
if (PsychOSSetPresentParameters(windowRecord, targetVBL, (int) auxArg3, auxArg2)) {
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: GetWindowInfo: Call to PsychOSSetPresentParameters(%i, %i, %f) SUCCESS!\n", (int) auxArg1, (int) auxArg3, auxArg2);
}
else {
if (PsychPrefStateGet_Verbosity() > 1) printf("PTB-WARNING: GetWindowInfo: Call to PsychOSSetPresentParameters() failed!\n");
}
}
}
else {
// Unsupported / Failed:
PsychCopyOutDoubleArg(1, FALSE, -1);
}
#endif
#if PSYCH_SYSTEM == PSYCH_LINUX
if (infoType == 2) {
// MMIO register Read for screenid "auxArg1", register offset "auxArg2":
PsychCopyInDoubleArg(3, TRUE, &auxArg1);
PsychCopyInDoubleArg(4, TRUE, &auxArg2);
PsychCopyOutDoubleArg(1, FALSE, (double) PsychOSKDReadRegister((int) auxArg1, (unsigned int) auxArg2, NULL));
}
if (infoType == 3) {
// MMIO register Write for screenid "auxArg1", register offset "auxArg2", to value "auxArg3":
PsychCopyInDoubleArg(3, TRUE, &auxArg1);
PsychCopyInDoubleArg(4, TRUE, &auxArg2);
PsychCopyInDoubleArg(5, TRUE, &auxArg3);
PsychOSKDWriteRegister((int) auxArg1, (unsigned int) auxArg2, (unsigned int) auxArg3, NULL);
}
#endif
// Done.
return(PsychError_none);
}
// Get the window record:
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
onscreen = PsychIsOnscreenWindow(windowRecord);
if (onscreen) {
// Query rasterbeam position: Will return -1 if unsupported.
PsychGetCGDisplayIDFromScreenNumber(&displayId, windowRecord->screenNumber);
beamposition = (double) PsychGetDisplayBeamPosition(displayId, windowRecord->screenNumber);
}
else {
beamposition = -1;
}
if (infoType == 1) {
// Return the measured beamposition:
PsychCopyOutDoubleArg(1, FALSE, beamposition);
}
else if (infoType == 4) {
// Return async flip state: 1 = Active, 0 = Inactive.
PsychCopyOutDoubleArg(1, FALSE, (((NULL != windowRecord->flipInfo) && (0 != windowRecord->flipInfo->asyncstate)) ? 1 : 0));
}
else if (infoType == 5) {
// Create a GL_EXT_timer_query object for this window:
if (glewIsSupported("GL_EXT_timer_query")) {
// Pending queries finished?
if (windowRecord->gpuRenderTimeQuery > 0) {
PsychErrorExitMsg(PsychError_user, "Tried to create a new GPU rendertime query, but last query not yet finished! Call Screen('Flip') first!");
}
// Enable our rendering context by selecting this window as drawing target:
PsychSetDrawingTarget(windowRecord);
// Generate Query object:
glGenQueries(1, &windowRecord->gpuRenderTimeQuery);
// Emit Query: GPU will measure elapsed processing time in Nanoseconds, starting
// with the first GL command executed after this command:
glBeginQuery(GL_TIME_ELAPSED_EXT, windowRecord->gpuRenderTimeQuery);
// Reset last measurement:
windowRecord->gpuRenderTime = 0;
}
else {
if (PsychPrefStateGet_Verbosity() > 4) printf("PTB-INFO: GetWindowInfo for infoType 5: GPU timer query objects are unsupported on this platform and GPU. Call ignored!\n");
}
}
else {
// Return all information:
PsychAllocOutStructArray(1, FALSE, 1, fieldCount, FieldNames, &s);
// Rasterbeam position:
PsychSetStructArrayDoubleElement("Beamposition", 0, beamposition, s);
// Time of last vertical blank when a double-buffer swap occured:
if ((windowRecord->flipCount > 0) && (windowRecord->time_at_last_vbl == 0) && (PsychPrefStateGet_VBLTimestampingMode() == 4)) {
// If time_at_last_vbl for an already finished or at least pending flip isn't available and
// we have support for OS-Builtin timestamping enabled, we try to employ OS-Builtin timestamping
// to get a timestamp for the most recent pending or finished flip. If this fails or is unsupported,
// it will have no effect:
PsychOSGetSwapCompletionTimestamp(windowRecord, 0, &(windowRecord->time_at_last_vbl));
}
// Return it - or the value zero if it is (still) undefined/unavailable:
PsychSetStructArrayDoubleElement("LastVBLTimeOfFlip", 0, windowRecord->time_at_last_vbl, s);
// Uncorrected timestamp of flip swap completion:
PsychSetStructArrayDoubleElement("RawSwapTimeOfFlip", 0, windowRecord->rawtime_at_swapcompletion, s);
// Timestamp immediately prior to call to PsychOSFlipWindowBuffers(), i.e., time at swap request submission:
PsychSetStructArrayDoubleElement("TimeAtSwapRequest", 0, windowRecord->time_at_swaprequest, s);
// Timestamp immediately after call to PsychOSFlipWindowBuffers() returns, i.e., time at swap request submission completion:
PsychSetStructArrayDoubleElement("TimePostSwapRequest", 0, windowRecord->time_post_swaprequest, s);
// Timestamp immediately after call to PsychOSFlipWindowBuffers() returns, i.e., time at swap request submission completion:
PsychSetStructArrayDoubleElement("VBLTimePostFlip", 0, windowRecord->postflip_vbltimestamp, s);
// Swap completion timestamp for most recently completed swap, according to OS-builtin PsychOSGetSwapCompletionTimestamp() method:
PsychSetStructArrayDoubleElement("OSSwapTimestamp", 0, windowRecord->osbuiltin_swaptime, s);
// Result from last GPU rendertime query as triggered by infoType 5: Zero if undefined.
PsychSetStructArrayDoubleElement("GPULastFrameRenderTime", 0, windowRecord->gpuRenderTime, s);
// Try to determine system time of last VBL on display, independent of any
// flips / bufferswaps.
lastvbl = -1;
postflip_vblcount = 0;
// On supported systems, we can query the OS for the system time of last VBL, so we can
// use the most recent VBL timestamp as baseline for timing calculations,
// instead of one far in the past.
if (onscreen) { lastvbl = PsychOSGetVBLTimeAndCount(windowRecord, &postflip_vblcount); }
// If we couldn't determine this information we just set lastvbl to the last known
// vbl timestamp of last flip -- better than nothing...
if (lastvbl < 0) lastvbl = windowRecord->time_at_last_vbl;
PsychSetStructArrayDoubleElement("LastVBLTime", 0, lastvbl, s);
PsychSetStructArrayDoubleElement("VBLCount", 0, (double) (psych_int64) postflip_vblcount, s);
// Misc. window parameters:
PsychSetStructArrayDoubleElement("StereoMode", 0, windowRecord->stereomode, s);
PsychSetStructArrayDoubleElement("ImagingMode", 0, windowRecord->imagingMode, s);
PsychSetStructArrayDoubleElement("SpecialFlags", 0, windowRecord->specialflags, s);
PsychSetStructArrayDoubleElement("IsFullscreen", 0, (windowRecord->specialflags & kPsychIsFullscreenWindow) ? 1 : 0, s);
PsychSetStructArrayDoubleElement("MultiSampling", 0, windowRecord->multiSample, s);
PsychSetStructArrayDoubleElement("MissedDeadlines", 0, windowRecord->nr_missed_deadlines, s);
PsychSetStructArrayDoubleElement("FlipCount", 0, windowRecord->flipCount, s);
PsychSetStructArrayDoubleElement("StereoDrawBuffer", 0, windowRecord->stereodrawbuffer, s);
PsychSetStructArrayDoubleElement("GuesstimatedMemoryUsageMB", 0, (double) windowRecord->surfaceSizeBytes / 1024 / 1024, s);
PsychSetStructArrayDoubleElement("BitsPerColorComponent", 0, (double) windowRecord->bpc, s);
// Query real size of the underlying display in order to define the vbl_startline:
PsychGetScreenSize(windowRecord->screenNumber, &scw, &sch);
vbl_startline = (double) sch;
PsychSetStructArrayDoubleElement("VBLStartline", 0, vbl_startline, s);
// And VBL endline:
PsychSetStructArrayDoubleElement("VBLEndline", 0, windowRecord->VBL_Endline, s);
// Video refresh interval duration from beamposition method:
PsychSetStructArrayDoubleElement("VideoRefreshFromBeamposition", 0, windowRecord->ifi_beamestimate, s);
// Swap group assignment and swap barrier assignment, if any:
PsychSetStructArrayDoubleElement("SwapGroup", 0, windowRecord->swapGroup, s);
PsychSetStructArrayDoubleElement("SwapBarrier", 0, windowRecord->swapBarrier, s);
// Which basic GPU architecture is this?
PsychSetStructArrayStringElement("GPUCoreId", 0, windowRecord->gpuCoreId, s);
// FBO's supported, and how deep?
if (windowRecord->gfxcaps & kPsychGfxCapFBO) {
if (windowRecord->gfxcaps & kPsychGfxCapFPFBO32) {
PsychSetStructArrayDoubleElement("GLSupportsFBOUpToBpc", 0, 32, s);
} else
if (windowRecord->gfxcaps & kPsychGfxCapFPFBO16) {
PsychSetStructArrayDoubleElement("GLSupportsFBOUpToBpc", 0, 16, s);
} else PsychSetStructArrayDoubleElement("GLSupportsFBOUpToBpc", 0, 8, s);
}
else {
PsychSetStructArrayDoubleElement("GLSupportsFBOUpToBpc", 0, 0, s);
}
// How deep is alpha blending supported?
if (windowRecord->gfxcaps & kPsychGfxCapFPBlend32) {
PsychSetStructArrayDoubleElement("GLSupportsBlendingUpToBpc", 0, 32, s);
} else if (windowRecord->gfxcaps & kPsychGfxCapFPBlend16) {
PsychSetStructArrayDoubleElement("GLSupportsBlendingUpToBpc", 0, 16, s);
} else PsychSetStructArrayDoubleElement("GLSupportsBlendingUpToBpc", 0, 8, s);
// How deep is texture mapping supported?
if (windowRecord->gfxcaps & kPsychGfxCapFPTex32) {
PsychSetStructArrayDoubleElement("GLSupportsTexturesUpToBpc", 0, 32, s);
} else if (windowRecord->gfxcaps & kPsychGfxCapFPTex16) {
PsychSetStructArrayDoubleElement("GLSupportsTexturesUpToBpc", 0, 16, s);
} else PsychSetStructArrayDoubleElement("GLSupportsTexturesUpToBpc", 0, 8, s);
// How deep is texture filtering supported?
if (windowRecord->gfxcaps & kPsychGfxCapFPFilter32) {
PsychSetStructArrayDoubleElement("GLSupportsFilteringUpToBpc", 0, 32, s);
} else if (windowRecord->gfxcaps & kPsychGfxCapFPFilter16) {
PsychSetStructArrayDoubleElement("GLSupportsFilteringUpToBpc", 0, 16, s);
} else PsychSetStructArrayDoubleElement("GLSupportsFilteringUpToBpc", 0, 8, s);
if (windowRecord->gfxcaps & kPsychGfxCapVCGood) {
PsychSetStructArrayDoubleElement("GLSupportsPrecisionColors", 0, 1, s);
} else PsychSetStructArrayDoubleElement("GLSupportsPrecisionColors", 0, 0, s);
if (windowRecord->gfxcaps & kPsychGfxCapFP32Shading) {
PsychSetStructArrayDoubleElement("GLSupportsFP32Shading", 0, 1, s);
} else PsychSetStructArrayDoubleElement("GLSupportsFP32Shading", 0, 0, s);
// Renderer information: This comes last, and would fail if async flips
// are active, because it needs PsychSetDrawingTarget, which in turn needs async
// flips to be inactive:
PsychSetDrawingTarget(windowRecord);
PsychSetStructArrayStringElement("GLVendor", 0, (char*) glGetString(GL_VENDOR), s);
PsychSetStructArrayStringElement("GLRenderer", 0, (char*) glGetString(GL_RENDERER), s);
PsychSetStructArrayStringElement("GLVersion", 0, (char*) glGetString(GL_VERSION), s);
}
// Done.
return(PsychError_none);
}
PsychError SCREENGetImage(void)
{
PsychRectType windowRect,sampleRect;
int nrchannels, ix, iy, sampleRectWidth, sampleRectHeight, invertedY, redReturnIndex, greenReturnIndex, blueReturnIndex, alphaReturnIndex, planeSize;
int viewid;
ubyte *returnArrayBase, *redPlane, *greenPlane, *bluePlane, *alphaPlane;
float *dredPlane, *dgreenPlane, *dbluePlane, *dalphaPlane;
double *returnArrayBaseDouble;
PsychWindowRecordType *windowRecord;
GLboolean isDoubleBuffer, isStereo;
char* buffername = NULL;
boolean floatprecision = FALSE;
GLenum whichBuffer = 0;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//cap the numbers of inputs and outputs
PsychErrorExit(PsychCapNumInputArgs(5)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(1)); //The maximum number of outputs
// Get windowRecord for this window:
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
// Set window as drawingtarget: Even important if this binding is changed later on!
// We need to make sure all needed transitions are done - esp. in non-imaging mode,
// so backbuffer is in a useable state:
PsychSetDrawingTarget(windowRecord);
// Disable shaders:
PsychSetShader(windowRecord, 0);
// Soft-Reset drawingtarget. This is important to make sure no FBO's are bound,
// otherwise the following glGets for GL_DOUBLEBUFFER and GL_STEREO will retrieve
// wrong results, leading to totally wrong read buffer assignments down the road!!
PsychSetDrawingTarget(0x1);
glGetBooleanv(GL_DOUBLEBUFFER, &isDoubleBuffer);
glGetBooleanv(GL_STEREO, &isStereo);
// Retrieve optional read rectangle:
PsychGetRectFromWindowRecord(windowRect, windowRecord);
if(!PsychCopyInRectArg(2, FALSE, sampleRect)) memcpy(sampleRect, windowRect, sizeof(PsychRectType));
if (IsPsychRectEmpty(sampleRect)) return(PsychError_none);
// Assign read buffer:
if(PsychIsOnscreenWindow(windowRecord)) {
// Onscreen window: We read from the front- or front-left buffer by default.
// This works on single-buffered and double buffered contexts in a consistent fashion:
// Copy in optional override buffer name:
PsychAllocInCharArg(3, FALSE, &buffername);
// Override buffer name provided?
if (buffername) {
// Which one is it?
// "frontBuffer" is always a valid choice:
if (PsychMatch(buffername, "frontBuffer")) whichBuffer = GL_FRONT;
// Allow selection of left- or right front stereo buffer in stereo mode:
if (PsychMatch(buffername, "frontLeftBuffer") && isStereo) whichBuffer = GL_FRONT_LEFT;
if (PsychMatch(buffername, "frontRightBuffer") && isStereo) whichBuffer = GL_FRONT_RIGHT;
// Allow selection of backbuffer in double-buffered mode:
if (PsychMatch(buffername, "backBuffer") && isDoubleBuffer) whichBuffer = GL_BACK;
// Allow selection of left- or right back stereo buffer in stereo mode:
if (PsychMatch(buffername, "backLeftBuffer") && isStereo && isDoubleBuffer) whichBuffer = GL_BACK_LEFT;
if (PsychMatch(buffername, "backRightBuffer") && isStereo && isDoubleBuffer) whichBuffer = GL_BACK_RIGHT;
// Allow AUX buffer access for debug purposes:
if (PsychMatch(buffername, "aux0Buffer")) whichBuffer = GL_AUX0;
if (PsychMatch(buffername, "aux1Buffer")) whichBuffer = GL_AUX1;
if (PsychMatch(buffername, "aux2Buffer")) whichBuffer = GL_AUX2;
if (PsychMatch(buffername, "aux3Buffer")) whichBuffer = GL_AUX3;
}
else {
// Default is frontbuffer:
whichBuffer=GL_FRONT;
}
}
else {
// Offscreen window or texture: They only have one buffer, which is the
// backbuffer in double-buffered mode and the frontbuffer in single buffered mode:
whichBuffer=(isDoubleBuffer) ? GL_BACK : GL_FRONT;
}
// Enable this windowRecords framebuffer as current drawingtarget. This should
// also allow us to "GetImage" from Offscreen windows:
if ((windowRecord->imagingMode & kPsychNeedFastBackingStore) || (windowRecord->imagingMode & kPsychNeedFastOffscreenWindows)) {
// Special case: Imaging pipeline active - We need to activate system framebuffer
// so we really read the content of the framebuffer and not of some FBO:
if (PsychIsOnscreenWindow(windowRecord)) {
// It's an onscreen window:
if (buffername && (PsychMatch(buffername, "drawBuffer")) && (windowRecord->imagingMode & kPsychNeedFastBackingStore)) {
// Activate drawBufferFBO:
PsychSetDrawingTarget(windowRecord);
whichBuffer = GL_COLOR_ATTACHMENT0_EXT;
// Is the drawBufferFBO multisampled?
viewid = (((windowRecord->stereomode > 0) && (windowRecord->stereodrawbuffer == 1)) ? 1 : 0);
if (windowRecord->fboTable[windowRecord->drawBufferFBO[viewid]]->multisample > 0) {
// It is! We can't read from a multisampled FBO. Need to perform a multisample resolve operation and read
// from the resolved unisample buffer instead. This is only safe if the unisample buffer is either a dedicated
// FBO, or - in case its the final system backbuffer etc. - if preflip operations haven't been performed yet.
// If non dedicated buffer (aka finalizedFBO) and preflip ops have already happened, then the backbuffer contains
// final content for an upcoming Screen('Flip') and we can't use (and therefore taint) that buffer.
if ((windowRecord->inputBufferFBO[viewid] == windowRecord->finalizedFBO[viewid]) && (windowRecord->backBufferBackupDone)) {
// Target for resolve is finalized FBO (probably system backbuffer) and preflip ops have run already. We
// can't do the resolve op, as this would screw up the backbuffer with the final stimulus:
printf("PTB-ERROR: Tried to 'GetImage' from a multisampled 'drawBuffer', but can't perform anti-aliasing pass due to\n");
printf("PTB-ERROR: lack of a dedicated resolve buffer.\n");
printf("PTB-ERROR: You can get what you wanted by either one of two options:\n");
printf("PTB-ERROR: Either enable a processing stage in the imaging pipeline, even if you don't need it, e.g., by setting\n");
printf("PTB-ERROR: the imagingmode argument in the 'OpenWindow' call to kPsychNeedImageProcessing, this will create a\n");
printf("PTB-ERROR: suitable resolve buffer. Or place the 'GetImage' call before any Screen('DrawingFinished') call, then\n");
printf("PTB-ERROR: i can (ab-)use the system backbuffer as a temporary resolve buffer.\n\n");
PsychErrorExitMsg(PsychError_user, "Tried to 'GetImage' from a multi-sampled 'drawBuffer'. Unsupported operation under given conditions.");
}
else {
// Ok, the inputBufferFBO is a suitable temporary resolve buffer. Perform a multisample resolve blit to it:
// A simple glBlitFramebufferEXT() call will do the copy & downsample operation:
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->drawBufferFBO[viewid]]->fboid);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->fboid);
glBlitFramebufferEXT(0, 0, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->width, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->height,
0, 0, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->width, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
// Bind inputBuffer as framebuffer:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->fboid);
viewid = -1;
}
}
}
else {
// Activate system framebuffer:
PsychSetDrawingTarget(NULL);
}
}
else {
// Offscreen window or texture: Select drawing target as usual,
// but set color attachment as read buffer:
PsychSetDrawingTarget(windowRecord);
whichBuffer = GL_COLOR_ATTACHMENT0_EXT;
// We do not support multisampled readout:
if (windowRecord->fboTable[windowRecord->drawBufferFBO[0]]->multisample > 0) {
printf("PTB-ERROR: You tried to Screen('GetImage', ...); from an offscreen window or texture which has multisample anti-aliasing enabled.\n");
printf("PTB-ERROR: This operation is not supported. You must first use Screen('CopyWindow') to create a non-multisampled copy of the\n");
printf("PTB-ERROR: texture or offscreen window, then use 'GetImage' on that copy. The copy will be anti-aliased, so you'll get what you\n");
printf("PTB-ERROR: wanted with a bit more effort. Sorry for the inconvenience, but this is mostly a hardware limitation.\n\n");
PsychErrorExitMsg(PsychError_user, "Tried to 'GetImage' from a multi-sampled texture or offscreen window. Unsupported operation.");
}
}
}
else {
// Normal case: No FBO based imaging - Select drawing target as usual:
PsychSetDrawingTarget(windowRecord);
}
// Select requested read buffer, after some double-check:
if (whichBuffer == 0) PsychErrorExitMsg(PsychError_user, "Invalid or unknown 'bufferName' argument provided.");
glReadBuffer(whichBuffer);
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: In Screen('GetImage'): GL-Readbuffer whichBuffer = %i\n", whichBuffer);
// Get optional floatprecision flag: We return data with float-precision if
// this flag is set. By default we return uint8 data:
PsychCopyInFlagArg(4, FALSE, &floatprecision);
// Get the optional number of channels flag: By default we return 3 channels,
// the Red, Green, and blue color channel:
nrchannels = 3;
PsychCopyInIntegerArg(5, FALSE, &nrchannels);
if (nrchannels < 1 || nrchannels > 4) PsychErrorExitMsg(PsychError_user, "Number of requested channels 'nrchannels' must be between 1 and 4!");
sampleRectWidth=PsychGetWidthFromRect(sampleRect);
sampleRectHeight=PsychGetHeightFromRect(sampleRect);
if (!floatprecision) {
// Readback of standard 8bpc uint8 pixels:
PsychAllocOutUnsignedByteMatArg(1, TRUE, sampleRectHeight, sampleRectWidth, nrchannels, &returnArrayBase);
redPlane= PsychMallocTemp(nrchannels * sizeof(GL_UNSIGNED_BYTE) * sampleRectWidth * sampleRectHeight);
planeSize=sampleRectWidth * sampleRectHeight;
greenPlane= redPlane + planeSize;
bluePlane= redPlane + 2 * planeSize;
alphaPlane= redPlane + 3 * planeSize;
glPixelStorei(GL_PACK_ALIGNMENT,1);
invertedY=windowRect[kPsychBottom]-sampleRect[kPsychBottom];
glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_RED, GL_UNSIGNED_BYTE, redPlane);
if (nrchannels>1) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_GREEN, GL_UNSIGNED_BYTE, greenPlane);
if (nrchannels>2) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_BLUE, GL_UNSIGNED_BYTE, bluePlane);
if (nrchannels>3) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_ALPHA, GL_UNSIGNED_BYTE, alphaPlane);
//in one pass transpose and flip what we read with glReadPixels before returning.
//-glReadPixels insists on filling up memory in sequence by reading the screen row-wise whearas Matlab reads up memory into columns.
//-the Psychtoolbox screen as setup by gluOrtho puts 0,0 at the top left of the window but glReadPixels always believes that it's at the bottom left.
for(ix=0;ix<sampleRectWidth;ix++){
for(iy=0;iy<sampleRectHeight;iy++){
// Compute write-indices for returned data:
redReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 0);
greenReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 1);
blueReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 2);
alphaReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 3);
// Always return RED/LUMINANCE channel:
returnArrayBase[redReturnIndex]=redPlane[ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth];
// Other channels on demand:
if (nrchannels>1) returnArrayBase[greenReturnIndex]=greenPlane[ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth];
if (nrchannels>2) returnArrayBase[blueReturnIndex]=bluePlane[ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth];
if (nrchannels>3) returnArrayBase[alphaReturnIndex]=alphaPlane[ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth];
}
}
}
else {
// Readback of standard 32bpc float pixels into a double matrix:
PsychAllocOutDoubleMatArg(1, TRUE, sampleRectHeight, sampleRectWidth, nrchannels, &returnArrayBaseDouble);
dredPlane= PsychMallocTemp(nrchannels * sizeof(GL_FLOAT) * sampleRectWidth * sampleRectHeight);
planeSize=sampleRectWidth * sampleRectHeight * sizeof(GL_FLOAT);
dgreenPlane= redPlane + planeSize;
dbluePlane= redPlane + 2 * planeSize;
dalphaPlane= redPlane + 3 * planeSize;
glPixelStorei(GL_PACK_ALIGNMENT, 1);
invertedY=windowRect[kPsychBottom]-sampleRect[kPsychBottom];
if (nrchannels==1) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_RED, GL_FLOAT, dredPlane);
if (nrchannels==2) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_LUMINANCE_ALPHA, GL_FLOAT, dredPlane);
if (nrchannels==3) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_RGB, GL_FLOAT, dredPlane);
if (nrchannels==4) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_RGBA, GL_FLOAT, dredPlane);
//in one pass transpose and flip what we read with glReadPixels before returning.
//-glReadPixels insists on filling up memory in sequence by reading the screen row-wise whearas Matlab reads up memory into columns.
//-the Psychtoolbox screen as setup by gluOrtho puts 0,0 at the top left of the window but glReadPixels always believes that it's at the bottom left.
for(ix=0;ix<sampleRectWidth;ix++){
for(iy=0;iy<sampleRectHeight;iy++){
// Compute write-indices for returned data:
redReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 0);
greenReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 1);
blueReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 2);
alphaReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 3);
// Always return RED/LUMINANCE channel:
returnArrayBaseDouble[redReturnIndex]=dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * nrchannels + 0];
// Other channels on demand:
if (nrchannels>1) returnArrayBaseDouble[greenReturnIndex]=dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * nrchannels + 1];
if (nrchannels>2) returnArrayBaseDouble[blueReturnIndex]=dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * nrchannels + 2];
if (nrchannels>3) returnArrayBaseDouble[alphaReturnIndex]=dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * nrchannels + 3];
}
}
}
if (viewid == -1) {
// Need to reset framebuffer binding to get rid of the inputBufferFBO which is bound due to
// multisample resolve ops --> Activate system framebuffer:
PsychSetDrawingTarget(NULL);
}
return(PsychError_none);
}
/*
* PsychGSCreateMovie() -- Create a movie object.
*
* This function tries to open a moviefile (with or without audio/video tracks)
* and create an associated movie object for it.
*
* win = Pointer to window record of associated onscreen window.
* moviename = char* with the name of the moviefile.
* preloadSecs = How many seconds of the movie should be preloaded/prefetched into RAM at movie open time?
* moviehandle = handle to the new movie.
*/
void PsychGSCreateMovie(PsychWindowRecordType *win, const char* moviename, double preloadSecs, int* moviehandle)
{
GstCaps *colorcaps;
GstElement *theMovie = NULL;
GMainLoop *MovieContext = NULL;
GstBus *bus = NULL;
GstFormat fmt;
GstElement *videosink;
gint64 length_format;
GstPad *pad, *peerpad;
const GstCaps *caps;
GstStructure *str;
gint width,height;
gint rate1, rate2;
int i, slotid;
GError *error = NULL;
char movieLocation[FILENAME_MAX];
psych_bool trueValue = TRUE;
char msgerr[10000];
char errdesc[1000];
psych_bool printErrors;
// Suppress output of error-messages if moviehandle == 1000. That means we
// run in our own Posix-Thread, not in the Matlab-Thread. Printing via Matlabs
// printing facilities would likely cause a terrible crash.
printErrors = (*moviehandle == -1000) ? FALSE : TRUE;
// Set movie handle to "failed" initially:
*moviehandle = -1;
// We start GStreamer only on first invocation.
if (firsttime) {
// Initialize GStreamer: The routine is defined in PsychVideoCaptureSupportGStreamer.c
PsychGSCheckInit("movie playback");
firsttime = FALSE;
}
if (win && !PsychIsOnscreenWindow(win)) {
if (printErrors) PsychErrorExitMsg(PsychError_user, "Provided windowPtr is not an onscreen window."); else return;
}
if (NULL == moviename) {
if (printErrors) PsychErrorExitMsg(PsychError_internal, "NULL-Ptr instead of moviename passed!"); else return;
}
if (numMovieRecords >= PSYCH_MAX_MOVIES) {
*moviehandle = -2;
if (printErrors) PsychErrorExitMsg(PsychError_user, "Allowed maximum number of simultaneously open movies exceeded!"); else return;
}
// Search first free slot in movieRecordBANK:
for (i=0; (i < PSYCH_MAX_MOVIES) && (movieRecordBANK[i].theMovie); i++);
if (i>=PSYCH_MAX_MOVIES) {
*moviehandle = -2;
if (printErrors) PsychErrorExitMsg(PsychError_user, "Allowed maximum number of simultaneously open movies exceeded!"); else return;
}
// Slot slotid will contain the movie record for our new movie object:
slotid=i;
// Zero-out new record in moviebank:
memset(&movieRecordBANK[slotid], 0, sizeof(PsychMovieRecordType));
// Create name-string for moviename: If an URI qualifier is at the beginning,
// we're fine and just pass the URI as-is. Otherwise we add the file:// URI prefix.
if (strstr(moviename, "://") || ((strstr(moviename, "v4l") == moviename) && strstr(moviename, "//"))) {
snprintf(movieLocation, sizeof(movieLocation)-1, "%s", moviename);
} else {
snprintf(movieLocation, sizeof(movieLocation)-1, "file:///%s", moviename);
}
strncpy(movieRecordBANK[slotid].movieLocation, movieLocation, FILENAME_MAX);
strncpy(movieRecordBANK[slotid].movieName, moviename, FILENAME_MAX);
// Create movie playback pipeline:
theMovie = gst_element_factory_make ("playbin2", "ptbmovieplaybackpipeline");
// Assign name of movie to play:
g_object_set(G_OBJECT(theMovie), "uri", movieLocation, NULL);
// Connect callback to about-to-finish signal: Signal is emitted as soon as
// end of current playback iteration is approaching. The callback checks if
// looped playback is requested. If so, it schedules a new playback iteration.
g_signal_connect(G_OBJECT(theMovie), "about-to-finish", G_CALLBACK(PsychMovieAboutToFinishCB), &(movieRecordBANK[slotid]));
// Assign message context, message bus and message callback for
// the pipeline to report events and state changes, errors etc.:
MovieContext = g_main_loop_new (NULL, FALSE);
movieRecordBANK[slotid].MovieContext = MovieContext;
bus = gst_pipeline_get_bus(GST_PIPELINE(theMovie));
// Didn't work: g_signal_connect (G_OBJECT(bus), "message::error", G_CALLBACK(PsychMessageErrorCB), NULL);
// g_signal_connect (G_OBJECT(bus), "message::warning", G_CALLBACK(PsychMessageErrorCB), NULL);
gst_bus_add_watch(bus, PsychMovieBusCallback, &(movieRecordBANK[slotid]));
gst_object_unref(bus);
// Assign a fakesink named "ptbsink0" as destination video-sink for
// all video content. This allows us to get hold of the video frame buffers for
// converting them into PTB OpenGL textures:
videosink = gst_element_factory_make ("appsink", "ptbsink0");
if (!videosink) {
printf("PTB-ERROR: Failed to create video-sink appsink ptbsink!\n");
PsychGSProcessMovieContext(movieRecordBANK[slotid].MovieContext, TRUE);
PsychErrorExitMsg(PsychError_system, "Opening the movie failed. Reason hopefully given above.");
};
movieRecordBANK[slotid].videosink = videosink;
// Our OpenGL texture creation routine needs GL_BGRA8 data in G_UNSIGNED_8_8_8_8_REV
// format, but the pipeline usually delivers YUV data in planar format. Therefore
// need to perform colorspace/colorformat conversion. We build a little videobin
// which consists of a ffmpegcolorspace converter plugin connected to our appsink
// plugin which will deliver video data to us for conversion into textures.
// The "sink" pad of the converter plugin is connected as the "sink" pad of our
// videobin, and the videobin is connected to the video-sink output of the pipeline,
// thereby receiving decoded video data. We place a videocaps filter inbetween the
// converter and the appsink to enforce a color format conversion to the "colorcaps"
// we need. colorcaps define the needed data format for efficient conversion into
// a RGBA8 texture:
colorcaps = gst_caps_new_simple ( "video/x-raw-rgb",
"bpp", G_TYPE_INT, 32,
"depth", G_TYPE_INT, 32,
"alpha_mask", G_TYPE_INT, 0x000000FF,
"red_mask", G_TYPE_INT, 0x0000FF00,
"green_mask", G_TYPE_INT, 0x00FF0000,
"blue_mask", G_TYPE_INT, 0xFF000000,
NULL);
/*
// Old style method: Only left here for documentation to show how one can create
// video sub-pipelines via bin's and connect them to each other via ghostpads:
GstElement *videobin = gst_bin_new ("video_output_bin");
GstElement *videocon = gst_element_factory_make ("ffmpegcolorspace", "color_converter");
gst_bin_add_many(GST_BIN(videobin), videocon, videosink, NULL);
GstPad *ghostpad = gst_ghost_pad_new("Video_Ghostsink", gst_element_get_pad(videocon, "sink"));
gst_element_add_pad(videobin, ghostpad);
gst_element_link_filtered(videocon, videosink, colorcaps);
// Assign our special videobin as video-sink of the pipeline:
g_object_set(G_OBJECT(theMovie), "video-sink", videobin, NULL);
*/
// New style method: Leaves the freedom of choice of color converter (if any)
// to the auto-plugger.
// Assign 'colorcaps' as caps to our videosink. This marks the videosink so
// that it can only receive video image data in the format defined by colorcaps,
// i.e., a format that is easy to consume for OpenGL's texture creation on std.
// gpu's. It is the job of the video pipeline's autoplugger to plug in proper
// color & format conversion plugins to satisfy videosink's needs.
gst_app_sink_set_caps(GST_APP_SINK(videosink), colorcaps);
// Assign our special appsink 'videosink' as video-sink of the pipeline:
g_object_set(G_OBJECT(theMovie), "video-sink", videosink, NULL);
gst_caps_unref(colorcaps);
// Get the pad from the final sink for probing width x height of movie frames and nominal framerate of movie:
pad = gst_element_get_pad(videosink, "sink");
PsychGSProcessMovieContext(movieRecordBANK[slotid].MovieContext, FALSE);
// Should we preroll / preload?
if ((preloadSecs > 0) || (preloadSecs == -1)) {
// Preload / Preroll the pipeline:
if (!PsychMoviePipelineSetState(theMovie, GST_STATE_PAUSED, 30.0)) {
PsychGSProcessMovieContext(movieRecordBANK[slotid].MovieContext, TRUE);
PsychErrorExitMsg(PsychError_user, "In OpenMovie: Opening the movie failed. Reason given above.");
}
} else {
// Ready the pipeline:
if (!PsychMoviePipelineSetState(theMovie, GST_STATE_READY, 30.0)) {
PsychGSProcessMovieContext(movieRecordBANK[slotid].MovieContext, TRUE);
PsychErrorExitMsg(PsychError_user, "In OpenMovie: Opening the movie failed. Reason given above.");
}
}
// Query number of available video and audio tracks in movie:
g_object_get (G_OBJECT(theMovie),
"n-video", &movieRecordBANK[slotid].nrVideoTracks,
"n-audio", &movieRecordBANK[slotid].nrAudioTracks,
NULL);
// We need a valid onscreen window handle for real video playback:
if ((NULL == win) && (movieRecordBANK[slotid].nrVideoTracks > 0)) {
if (printErrors) PsychErrorExitMsg(PsychError_user, "No windowPtr to an onscreen window provided. Must do so for movies with videotrack!"); else return;
}
PsychGSProcessMovieContext(movieRecordBANK[slotid].MovieContext, FALSE);
PsychInitMutex(&movieRecordBANK[slotid].mutex);
PsychInitCondition(&movieRecordBANK[slotid].condition, NULL);
if (oldstyle) {
// Install the probe callback for reception of video frames from engine at the sink-pad itself:
gst_pad_add_buffer_probe(pad, G_CALLBACK(PsychHaveVideoDataCallback), &(movieRecordBANK[slotid]));
} else {
// Install callbacks used by the videosink (appsink) to announce various events:
gst_app_sink_set_callbacks(GST_APP_SINK(videosink), &videosinkCallbacks, &(movieRecordBANK[slotid]), PsychDestroyNotifyCallback);
}
// Drop frames if callback can't pull buffers fast enough:
// This together with the max queue lengths of 1 allows to
// maintain audio-video sync by framedropping if needed.
gst_app_sink_set_drop(GST_APP_SINK(videosink), TRUE);
// Only allow one queued buffer before dropping:
gst_app_sink_set_max_buffers(GST_APP_SINK(videosink), 1);
// Assign harmless initial settings for fps and frame size:
rate1 = 0;
rate2 = 1;
width = height = 0;
// Videotrack available?
if (movieRecordBANK[slotid].nrVideoTracks > 0) {
// Yes: Query size and framerate of movie:
peerpad = gst_pad_get_peer(pad);
caps=gst_pad_get_negotiated_caps(peerpad);
if (caps) {
str=gst_caps_get_structure(caps,0);
/* Get some data about the frame */
rate1 = 1; rate2 = 1;
gst_structure_get_fraction(str, "pixel-aspect-ratio", &rate1, &rate2);
movieRecordBANK[slotid].aspectRatio = (double) rate1 / (double) rate2;
gst_structure_get_int(str,"width",&width);
gst_structure_get_int(str,"height",&height);
rate1 = 0; rate2 = 1;
gst_structure_get_fraction(str, "framerate", &rate1, &rate2);
} else {
printf("PTB-DEBUG: No frame info available after preroll.\n");
}
}
if (strstr(moviename, "v4l2:")) {
// Special case: The "movie" is actually a video4linux2 live source.
// Need to make parameters up for now, so it to work as "movie":
rate1 = 30; width = 640; height = 480;
movieRecordBANK[slotid].nrVideoTracks = 1;
// Uglyness at its best ;-)
if (strstr(moviename, "320")) { width = 320; height = 240; };
}
// Release the pad:
gst_object_unref(pad);
// Assign new record in moviebank:
movieRecordBANK[slotid].theMovie = theMovie;
movieRecordBANK[slotid].loopflag = 0;
movieRecordBANK[slotid].frameAvail = 0;
movieRecordBANK[slotid].imageBuffer = NULL;
*moviehandle = slotid;
// Increase counter:
numMovieRecords++;
// Compute basic movie properties - Duration and fps as well as image size:
// Retrieve duration in seconds:
fmt = GST_FORMAT_TIME;
if (gst_element_query_duration(theMovie, &fmt, &length_format)) {
// This returns nsecs, so convert to seconds:
movieRecordBANK[slotid].movieduration = (double) length_format / (double) 1e9;
//printf("PTB-DEBUG: Duration of movie %i [%s] is %lf seconds.\n", slotid, moviename, movieRecordBANK[slotid].movieduration);
} else {
movieRecordBANK[slotid].movieduration = DBL_MAX;
printf("PTB-WARNING: Could not query duration of movie %i [%s] in seconds. Returning infinity.\n", slotid, moviename);
}
// Assign expected framerate, assuming a linear spacing between frames:
movieRecordBANK[slotid].fps = (double) rate1 / (double) rate2;
//printf("PTB-DEBUG: Framerate fps of movie %i [%s] is %lf fps.\n", slotid, moviename, movieRecordBANK[slotid].fps);
// Compute framecount from fps and duration:
movieRecordBANK[slotid].nrframes = (int)(movieRecordBANK[slotid].fps * movieRecordBANK[slotid].movieduration + 0.5);
//printf("PTB-DEBUG: Number of frames in movie %i [%s] is %i.\n", slotid, moviename, movieRecordBANK[slotid].nrframes);
// Define size of images in movie:
movieRecordBANK[slotid].width = width;
movieRecordBANK[slotid].height = height;
// Ready to rock!
return;
}
PsychError SCREENBeginOpenGL(void)
{
static char useString[] = "Screen('BeginOpenGL', windowPtr [, sharecontext=0]);";
static char synopsisString[] = "Prepare window 'windowPtr' for OpenGL rendering by external OpenGL code. "
"This allows to use OpenGL drawing routines other than the ones implemented "
"in Screen() to draw to a Psychtoolbox onscreen- or offscreen window via execution of "
"OpenGL commands. Typical clients of this function are mogl (Richard F. Murrays OpenGL for Matlab wrapper), "
"the new Eyelink-Toolbox and third party Matlab Mex-Files which contain OpenGL rendering routines. "
"You *have to* call this command once before using any of those external drawing commands for the window. "
"After drawing, you *must* switch back to PTB's rendering via the Screen('EndOpenGL', windowPtr); command. "
"Normally, you won't provide the optional flag 'sharecontext', so PTB will automatically isolate the OpenGL "
"state of your code from its internal state. However, if you provide sharecontext=1, then PTB will allow "
"your code to use and affect PTBs internal context. Only do this if you really know what you're doing! "
"If you provide sharecontext=2 then PTB will give you your own private context, but it will synchronize "
"the state of that context with its internal state - Seldomly needed, but here for your convenience. "
"The context state isolation is as strict as possible without seriously affecting performance and functionality: "
"All OpenGL context state is separated, with two exceptions: The framebuffer binding (if any) is always synchronized "
"with PTB (and reset to zero when calling 'EndOpenGL' or another Screen command) to allow external code to transparently "
"render into PTBs internal framebuffers - Needed for the imaging pipeline to work. Ressources like textures, display lists, "
"FBOs, VBOs, PBOs and GLSL shaders are shared between PTB and your code as well for efficiency reasons. Both types of "
"ressource sharing shouldn't be a problem, because either you are a beginner or advanced OpenGL programmer and won't use "
"those facilities anyway, or you are an expert user - in which case you'll know how to prevent any conflicts easily.";
static char seeAlsoString[] = "EndOpenGL SetOpenGLTexture GetOpenGLTexture moglcore";
PsychWindowRecordType *windowRecord;
GLint fboid, coltexid, ztexid, stexid;
//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)); // Number of required 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(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
// Already in userspace mode?
if (PsychIsUserspaceRendering()) PsychErrorExitMsg(PsychError_user, "Tried to call Screen('BeginOpenGL'), but userspace rendering is already active! Missing or mismatched Screen('EndOpenGL')? Check your code.");
// (Optional) context sharing flag provided?
sharecontext = 0;
PsychCopyInIntegerArg(2, FALSE, &sharecontext);
if (sharecontext<0 || sharecontext>2) PsychErrorExitMsg(PsychError_user, "Invalid value for 'sharecontext' provided. Not in range 0 to 2.");
// Master override: If context isolation is disabled then we use the PTB internal context...
if (PsychPrefStateGet_ConserveVRAM() & kPsychDisableContextIsolation) sharecontext = 1;
// Set it as drawing target: This will set up the proper FBO bindings as well:
PsychSetDrawingTarget(windowRecord);
// Store it as a reference for later 'EndOpenGL' call:
preswitchWindowRecord = windowRecord;
// Userspace wants its own private rendering context, optionally updated to match PTBs internal state?
if (sharecontext == 0 || sharecontext == 2) {
// Yes. This is the normal case for 3D rendering. MOGLs and PTBs contexts are separated to
// increase robustness, only ressources like textures, display lists, PBO's, VBO's, FBO's
// and GLSL shaders are shared, but not the current renderstate.
// Make sure 3D rendering is globally enabled, otherwise this is considered a userspace bug:
if (PsychPrefStateGet_3DGfx()==0) PsychErrorExitMsg(PsychError_user, "Tried to call 'BeginOpenGL' for external rendering, but 3D rendering not globally enabled! Call 'InitializeMatlabOpenGL' at the beginning of your script!!");
// Query current FBO binding. We need to manually transfer this to the userspace context, so
// it can render into our window:
if (glBindFramebufferEXT) {
fboid = 0;
glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &fboid);
if (fboid>0) {
// Query attachments of FBO:
glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &coltexid);
glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &ztexid);
glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &stexid);
}
}
// Flush our context before context switch:
glFlush();
// Unbind possible FBOs, so system FB is active in our context:
if (glBindFramebufferEXT && (fboid > 0)) {
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glFlush();
}
// Switch to userspace context for this window, optionally sync state with PTBs context:
PsychOSSetUserGLContext(windowRecord, (sharecontext==2) ? TRUE : FALSE);
// All following ops apply to the usercontext, not our internal context:
// Manually establish proper FBO binding for userspace. This will get reset automaticaly on back-transition
// inside PsychSetGLContext on its first invocation. If we are in non-imaging mode then there's nothing to do.
if (glBindFramebufferEXT && (fboid > 0)) {
if (!glIsFramebufferEXT(fboid)) {
// Special case: Need to bind a special FBO and the underlying OpenGL driver is faulty,
// i.e. it doesn't share FBO names accross our OpenGL contexts as it should according to
// spec.: We manually create a clone of our internal FBO - Create an FBO in the userspace
// context with the same FBO handle, then manually reattach the proper attachments...
if (PsychPrefStateGet_Verbosity()>1) printf("PTB-WARNING: Faulty graphics driver - FBO sharing doesn't work properly, trying work-around. Update your drivers as soon as possible!\n");
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboid);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_EXT, coltexid, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_EXT, ztexid, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_EXT, stexid, 0);
if (GL_FRAMEBUFFER_COMPLETE_EXT != glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT)) {
// Game over :(
PsychErrorExitMsg(PsychError_internal, "Graphics driver malfunction: Failed to clone PTBs internal FBO for userspace GLContext inside SCREENBeginOpenGL as part of workaround code! Upgrade your gfx-drivers!!");
}
// If we reach this point, then the workaround for the worst OS in existence has worked.
}
else {
// Need to bind a special FBO and the system works correctly - no workaround needed. Just bind it in new context:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboid);
}
}
// Is this the first time that the userspace rendering context of this
// onscreen window is selected for real userspace rendering?
if (windowRecord->needsViewportSetup && PsychIsOnscreenWindow(windowRecord)) {
// Yes. Need to perform one-time setup actions for this context:
windowRecord->needsViewportSetup = FALSE;
// Need to setup glViewPort, scissor rectangle, projection and modelview
// matrices to values that match the windows client rectangle. We need to
// do this here because some imaging pipeline display modes, e.g, stereomodes
// for top-bottom stereo or dualview stereo may have altered the useable client
// rendering area after the context was initially created. OpenGL spec states that
// at least the viewport and scissor rectangles are set to the full client window
// area at first bind of a context to its drawable, so we emulate this here on first
// 'BeginOpenGL' to avoid unpleasant surprises for unsuspecting users:
PsychSetupView(windowRecord, FALSE);
}
// Running without imaging pipeline and a stereo mode is active?
if ((windowRecord->stereomode) > 0 && !(windowRecord->imagingMode & kPsychNeedFastBackingStore)) {
// Perform setup work for stereo drawbuffers in fixed function mode:
PsychSwitchFixedFunctionStereoDrawbuffer(windowRecord);
}
}
else {
// Userspace shares context with PTB. Let's disable possibly bound GLSL shaders:
PsychSetShader(windowRecord, 0);
}
// Check for GL errors:
PsychTestForGLErrors();
// Set the userspace flag:
PsychSetUserspaceGLFlag(TRUE);
// Ready for userspace rendering:
return(PsychError_none);
}
/*
* PsychQTCreateMovie() -- Create a movie object.
*
* This function tries to open a Quicktime-Moviefile and create an
* associated movie object for it.
*
* win = Pointer to window record of associated onscreen window.
* moviename = char* with the name of the moviefile.
* preloadSecs = How many seconds of the movie should be preloaded/prefetched into RAM at movie open time?
* moviehandle = handle to the new movie.
*/
void PsychQTCreateMovie(PsychWindowRecordType *win, const char* moviename, double preloadSecs, int* moviehandle)
{
Movie theMovie = NULL;
QTVisualContextRef QTMovieContext = NULL;
QTAudioContextRef QTAudioContext = NULL;
int i, slotid;
OSErr error;
CFStringRef movieLocation;
CFURLRef movieURLLocation;
CFStringRef coreAudioDeviceUID;
psych_bool trueValue = TRUE;
QTNewMoviePropertyElement newMovieProperties[4] = {0};
int propcount = 0;
char msgerr[10000];
char errdesc[1000];
Rect movierect;
psych_bool printErrors;
// Suppress output of error-messages if moviehandle == 1000. That means we
// run in our own Posix-Thread, not in the Matlab-Thread. Printing via Matlabs
// printing facilities would likely cause a terrible crash.
printErrors = (*moviehandle == -1000) ? FALSE : TRUE;
// Set movie handle to "failed" initially:
*moviehandle = -1;
// We startup the Quicktime subsystem only on first invocation.
if (firsttime) {
#if PSYCH_SYSTEM == PSYCH_WINDOWS
// Initialize Quicktime for Windows compatibility layer: This will fail if
// QT isn't installed on the Windows machine...
error = InitializeQTML(0);
if (error!=noErr) {
if (printErrors) {
PsychErrorExitMsg(PsychError_internal, "Quicktime Media Layer initialization failed: Quicktime not properly installed?!?");
} else return;
}
#endif
// Initialize Quicktime-Subsystem:
error = EnterMovies();
if (error!=noErr) {
if (printErrors) PsychErrorExitMsg(PsychError_internal, "Quicktime EnterMovies() failed!!!"); else return;
}
firsttime = FALSE;
}
if (!PsychIsOnscreenWindow(win)) {
if (printErrors) PsychErrorExitMsg(PsychError_user, "Provided windowPtr is not an onscreen window."); else return;
}
if (NULL==moviename) {
if (printErrors) PsychErrorExitMsg(PsychError_internal, "NULL-Ptr instead of moviename passed!"); else return;
}
if (numMovieRecords >= PSYCH_MAX_MOVIES) {
*moviehandle = -2;
if (printErrors) PsychErrorExitMsg(PsychError_user, "Allowed maximum number of simultaneously open movies exceeded!"); else return;
}
// Search first free slot in movieRecordBANK:
for (i=0; (i < PSYCH_MAX_MOVIES) && (movieRecordBANK[i].theMovie); i++);
if (i>=PSYCH_MAX_MOVIES) {
*moviehandle = -2;
if (printErrors) PsychErrorExitMsg(PsychError_user, "Allowed maximum number of simultaneously open movies exceeded!"); else return;
}
// Slot slotid will contain the movie record for our new movie object:
slotid=i;
// Create name-string for moviename:
movieLocation = CFStringCreateWithCString (kCFAllocatorDefault, moviename, kCFStringEncodingASCII);
// Zero-out new record in moviebank:
movieRecordBANK[slotid].theMovie=NULL;
movieRecordBANK[slotid].QTMovieContext=NULL;
movieRecordBANK[slotid].QTAudioContext=NULL;
movieRecordBANK[slotid].QTMovieGWorld=NULL;
if (!PSYCH_USE_QT_GWORLDS) {
// Create QTGLTextureContext:
#if PSYCH_SYSTEM != PSYCH_WINDOWS
error = QTOpenGLTextureContextCreate (kCFAllocatorDefault,
win->targetSpecific.contextObject,
win->targetSpecific.pixelFormatObject,
NULL,
&QTMovieContext);
#endif
if (error!=noErr) {
if (printErrors) PsychErrorExitMsg(PsychError_internal, "OpenGL Quicktime visual context creation failed!!!"); else return;
}
}
// The Movie location
newMovieProperties[propcount].propClass = kQTPropertyClass_DataLocation;
if (strstr(moviename, "http:") || strstr(moviename, "ftp:")) {
// Open movie from URL, e.g., http- or ftp- server:
movieURLLocation = CFURLCreateWithString(kCFAllocatorDefault, movieLocation, NULL);
newMovieProperties[propcount].propID = kQTDataLocationPropertyID_CFURL;
newMovieProperties[propcount].propValueSize = sizeof(movieURLLocation);
newMovieProperties[propcount++].propValueAddress = (void*) &movieURLLocation;
}
else {
// Open movie file from filesystem:
newMovieProperties[propcount].propID = kQTDataLocationPropertyID_CFStringPosixPath;
newMovieProperties[propcount].propValueSize = sizeof(CFStringRef);
newMovieProperties[propcount++].propValueAddress = &movieLocation;
}
if (!PSYCH_USE_QT_GWORLDS) {
// The Movie visual context
newMovieProperties[propcount].propClass = kQTPropertyClass_Context;
newMovieProperties[propcount].propID = kQTContextPropertyID_VisualContext;
newMovieProperties[propcount].propValueSize = sizeof(QTVisualContextRef);
newMovieProperties[propcount++].propValueAddress = &QTMovieContext;
}
if (TRUE) {
// Create QTAudioContext for default CoreAudio device:
coreAudioDeviceUID = NULL; // Use default audio-output device.
error =QTAudioContextCreateForAudioDevice (kCFAllocatorDefault,
coreAudioDeviceUID,
NULL,
&QTAudioContext);
if (error!=noErr) {
if (printErrors) PsychErrorExitMsg(PsychError_internal, "Quicktime audio context creation failed!!!"); else return;
}
// The Movie audio context
newMovieProperties[propcount].propClass = kQTPropertyClass_Context;
newMovieProperties[propcount].propID = kQTContextPropertyID_AudioContext;
newMovieProperties[propcount].propValueSize = sizeof(QTAudioContextRef);
newMovieProperties[propcount++].propValueAddress = &QTAudioContext;
}
// The Movie active
newMovieProperties[propcount].propClass = kQTPropertyClass_NewMovieProperty;
newMovieProperties[propcount].propID = kQTNewMoviePropertyID_Active;
newMovieProperties[propcount].propValueSize = sizeof(trueValue);
newMovieProperties[propcount++].propValueAddress = &trueValue;
// Instantiate the Movie
error = NewMovieFromProperties(propcount, newMovieProperties, 0, NULL, &theMovie);
if (error!=noErr) {
QTVisualContextRelease(QTMovieContext);
QTAudioContextRelease(QTAudioContext);
switch(error) {
case -2000:
case -50:
case -43:
sprintf(errdesc, "File not found.");
break;
case -2048:
sprintf(errdesc, "This is not a file that Quicktime understands.");
break;
case -2003:
sprintf(errdesc, "Can't find media handler (codec) for this movie.");
break;
default:
sprintf(errdesc, "Unknown: Check http://developer.apple.com/documentation/QuickTime/APIREF/ErrorCodes.htm#//apple_ref/doc/constant_group/Error_Codes");
}
sprintf(msgerr, "Couldn't load movie %s! Quicktime error code %i [%s]", moviename, (int) error, errdesc);
*moviehandle = (int) error;
if (printErrors) PsychErrorExitMsg(PsychError_user, msgerr); else return;
}
CFRelease(movieLocation);
if (PSYCH_USE_QT_GWORLDS) {
// Determine size of images in movie:
GetMovieBox(theMovie, &movierect);
// Only create a GWorld if movie frames contain at least 1 pixel. This way we skip GWorld
// setup on "movies" which only consist of sound tracks.
if ((movierect.right - movierect.left != 0) && (movierect.bottom - movierect.top != 0)) {
// Create GWorld for this movie object:
// error = QTNewGWorld(&movieRecordBANK[slotid].QTMovieGWorld, k32ABGRPixelFormat, &movierect, NULL, NULL, 0);
error = QTNewGWorld(&movieRecordBANK[slotid].QTMovieGWorld, 0, &movierect, NULL, NULL, 0);
if (error!=noErr) {
QTAudioContextRelease(QTAudioContext);
DisposeMovie(movieRecordBANK[slotid].theMovie);
movieRecordBANK[slotid].theMovie=NULL;
if (printErrors) PsychErrorExitMsg(PsychError_internal, "Quicktime GWorld creation failed!!!"); else return;
}
// Attach this GWorld as rendering target for Quicktime:
SetMovieGWorld(theMovie, movieRecordBANK[slotid].QTMovieGWorld, NULL);
}
}
// Preload preloadSecs seconds of movie into system RAM for faster playback:
if (preloadSecs > 0) LoadMovieIntoRam(theMovie, 0, ((long) preloadSecs + 0.5) * GetMovieTimeScale(theMovie), keepInRam);
// Special setting - 1 means: Load whole movie into RAM:
if (preloadSecs == -1) LoadMovieIntoRam(theMovie, 0, GetMovieDuration(theMovie), keepInRam);
// We don't preroll: Didn't help for async playback, but leads to failure in
// manual playback mode: PrerollMovie(theMovie, 0, FloatToFixed(1));
// MoviesTask() it to make sure start of plaback will be as stutter-free as possible:
MoviesTask(theMovie, 10000);
// Assign new record in moviebank:
movieRecordBANK[slotid].theMovie=theMovie;
movieRecordBANK[slotid].QTMovieContext=QTMovieContext;
movieRecordBANK[slotid].QTAudioContext=QTAudioContext;
movieRecordBANK[slotid].loopflag = 0;
*moviehandle = slotid;
// Increase counter:
numMovieRecords++;
// Compute basic movie properties - Duration and fps as well as image size:
// Compute duration in seconds:
movieRecordBANK[slotid].movieduration = (double) GetMovieDuration(theMovie) / (double) GetMovieTimeScale(theMovie);
// Compute expected framerate, assuming a linear spacing between frames: It is derived as
// reciprocal of the duration of the first video frame in the movie:
movieRecordBANK[slotid].fps = PsychDetermineMovieFramecountAndFps(theMovie, NULL);
// Determine size of images in movie:
GetMovieBox(theMovie, &movierect);
movieRecordBANK[slotid].width = movierect.right - movierect.left;
movieRecordBANK[slotid].height = movierect.bottom - movierect.top;
// We set nrframes == -1 to indicate that this value is not yet available.
// Will do counting on first query for this parameter as it is very time-consuming:
movieRecordBANK[slotid].nrframes = -1;
return;
}
PsychError SCREENGetWindowInfo(void)
{
const char *FieldNames[]={ "Beamposition", "LastVBLTimeOfFlip", "LastVBLTime", "VBLCount", "StereoMode", "ImagingMode", "MultiSampling", "MissedDeadlines", "StereoDrawBuffer",
"GuesstimatedMemoryUsageMB", "VBLStartline", "VBLEndline", "VideoRefreshFromBeamposition", "GLVendor", "GLRenderer", "GLVersion",
"GLSupportsFBOUpToBpc", "GLSupportsBlendingUpToBpc", "GLSupportsTexturesUpToBpc", "GLSupportsFilteringUpToBpc", "GLSupportsPrecisionColors",
"GLSupportsFP32Shading", "BitsPerColorComponent" };
const int fieldCount = 23;
PsychGenericScriptType *s;
PsychWindowRecordType *windowRecord;
double beamposition, lastvbl;
int beamposonly = 0;
CGDirectDisplayID displayId;
psych_uint64 postflip_vblcount;
double vbl_startline;
long scw, sch;
bool onscreen;
//all subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(2)); //The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(1)); //The required number of inputs
PsychErrorExit(PsychCapNumOutputArgs(1)); //The maximum number of outputs
// Get the window record:
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
onscreen = PsychIsOnscreenWindow(windowRecord);
// Query beamposonly flag: Defaults to zero.
PsychCopyInIntegerArg(2, FALSE, &beamposonly);
if (onscreen) {
// Query rasterbeam position: Will return -1 if unsupported.
PsychGetCGDisplayIDFromScreenNumber(&displayId, windowRecord->screenNumber);
beamposition = (double) PsychGetDisplayBeamPosition(displayId, windowRecord->screenNumber);
}
else {
beamposition = -1;
}
if (beamposonly) {
// Return the measured beamposition:
PsychCopyOutDoubleArg(1, FALSE, beamposition);
}
else {
// Return all information:
PsychAllocOutStructArray(1, FALSE, 1, fieldCount, FieldNames, &s);
// Rasterbeam position:
PsychSetStructArrayDoubleElement("Beamposition", 0, beamposition, s);
// Time of last vertical blank when a double-buffer swap occured:
PsychSetStructArrayDoubleElement("LastVBLTimeOfFlip", 0, windowRecord->time_at_last_vbl, s);
// Try to determine system time of last VBL on display, independent of any
// flips / bufferswaps.
lastvbl = -1;
postflip_vblcount = 0;
#if PSYCH_SYSTEM == PSYCH_OSX
// On OS/X we can query the OS for the system time of last VBL, so we can
// use the most recent VBL timestamp as baseline for timing calculations,
// instead of one far in the past.
if (onscreen) { lastvbl = PsychOSGetVBLTimeAndCount(windowRecord->screenNumber, &postflip_vblcount); }
#endif
// If we couldn't determine this information we just set lastvbl to the last known
// vbl timestamp of last flip -- better than nothing...
if (lastvbl < 0) lastvbl = windowRecord->time_at_last_vbl;
PsychSetStructArrayDoubleElement("LastVBLTime", 0, lastvbl, s);
PsychSetStructArrayDoubleElement("VBLCount", 0, (double) postflip_vblcount, s);
// Misc. window parameters:
PsychSetStructArrayDoubleElement("StereoMode", 0, windowRecord->stereomode, s);
PsychSetStructArrayDoubleElement("ImagingMode", 0, windowRecord->imagingMode, s);
PsychSetStructArrayDoubleElement("MultiSampling", 0, windowRecord->multiSample, s);
PsychSetStructArrayDoubleElement("MissedDeadlines", 0, windowRecord->nr_missed_deadlines, s);
PsychSetStructArrayDoubleElement("StereoDrawBuffer", 0, windowRecord->stereodrawbuffer, s);
PsychSetStructArrayDoubleElement("GuesstimatedMemoryUsageMB", 0, (double) windowRecord->surfaceSizeBytes / 1024 / 1024, s);
PsychSetStructArrayDoubleElement("BitsPerColorComponent", 0, (double) windowRecord->bpc, s);
// Query real size of the underlying display in order to define the vbl_startline:
PsychGetScreenSize(windowRecord->screenNumber, &scw, &sch);
vbl_startline = (double) sch;
PsychSetStructArrayDoubleElement("VBLStartline", 0, vbl_startline, s);
// And VBL endline:
PsychSetStructArrayDoubleElement("VBLEndline", 0, windowRecord->VBL_Endline, s);
// Video refresh interval duration from beamposition method:
PsychSetStructArrayDoubleElement("VideoRefreshFromBeamposition", 0, windowRecord->ifi_beamestimate, s);
// Renderer information:
PsychSetDrawingTarget(windowRecord);
PsychSetStructArrayStringElement("GLVendor", 0, glGetString(GL_VENDOR), s);
PsychSetStructArrayStringElement("GLRenderer", 0, glGetString(GL_RENDERER), s);
PsychSetStructArrayStringElement("GLVersion", 0, glGetString(GL_VERSION), s);
// FBO's supported, and how deep?
if (windowRecord->gfxcaps & kPsychGfxCapFBO) {
if (windowRecord->gfxcaps & kPsychGfxCapFPFBO32) {
PsychSetStructArrayDoubleElement("GLSupportsFBOUpToBpc", 0, 32, s);
} else
if (windowRecord->gfxcaps & kPsychGfxCapFPFBO16) {
PsychSetStructArrayDoubleElement("GLSupportsFBOUpToBpc", 0, 16, s);
} else PsychSetStructArrayDoubleElement("GLSupportsFBOUpToBpc", 0, 8, s);
}
else {
PsychSetStructArrayDoubleElement("GLSupportsFBOUpToBpc", 0, 0, s);
}
// How deep is alpha blending supported?
if (windowRecord->gfxcaps & kPsychGfxCapFPBlend32) {
PsychSetStructArrayDoubleElement("GLSupportsBlendingUpToBpc", 0, 32, s);
} else if (windowRecord->gfxcaps & kPsychGfxCapFPBlend16) {
PsychSetStructArrayDoubleElement("GLSupportsBlendingUpToBpc", 0, 16, s);
} else PsychSetStructArrayDoubleElement("GLSupportsBlendingUpToBpc", 0, 8, s);
// How deep is texture mapping supported?
if (windowRecord->gfxcaps & kPsychGfxCapFPTex32) {
PsychSetStructArrayDoubleElement("GLSupportsTexturesUpToBpc", 0, 32, s);
} else if (windowRecord->gfxcaps & kPsychGfxCapFPTex16) {
PsychSetStructArrayDoubleElement("GLSupportsTexturesUpToBpc", 0, 16, s);
} else PsychSetStructArrayDoubleElement("GLSupportsTexturesUpToBpc", 0, 8, s);
// How deep is texture filtering supported?
if (windowRecord->gfxcaps & kPsychGfxCapFPFilter32) {
PsychSetStructArrayDoubleElement("GLSupportsFilteringUpToBpc", 0, 32, s);
} else if (windowRecord->gfxcaps & kPsychGfxCapFPFilter16) {
PsychSetStructArrayDoubleElement("GLSupportsFilteringUpToBpc", 0, 16, s);
} else PsychSetStructArrayDoubleElement("GLSupportsFilteringUpToBpc", 0, 8, s);
if (windowRecord->gfxcaps & kPsychGfxCapVCGood) {
PsychSetStructArrayDoubleElement("GLSupportsPrecisionColors", 0, 1, s);
} else PsychSetStructArrayDoubleElement("GLSupportsPrecisionColors", 0, 0, s);
if (windowRecord->gfxcaps & kPsychGfxCapFP32Shading) {
PsychSetStructArrayDoubleElement("GLSupportsFP32Shading", 0, 1, s);
} else PsychSetStructArrayDoubleElement("GLSupportsFP32Shading", 0, 0, s);
}
// Done.
return(PsychError_none);
}
PsychError SCREENLoadNormalizedGammaTable(void)
{
int i, screenNumber, numEntries, inM, inN, inP, loadOnNextFlip, physicalDisplay, outputId;
float *outRedTable, *outGreenTable, *outBlueTable, *inRedTable, *inGreenTable, *inBlueTable;
double *inTable, *outTable;
PsychWindowRecordType *windowRecord;
//all subfunctions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychErrorExit(PsychCapNumOutputArgs(1));
PsychErrorExit(PsychCapNumInputArgs(4));
// Get optional physicalDisplay argument - It defaults to zero on OS/X, -1 on Linux:
physicalDisplay = -1;
PsychCopyInIntegerArg(4, FALSE, &physicalDisplay);
// Read in the screen number:
// On OS/X we also accept screen indices for physical displays (as opposed to active dispays).
// This only makes a difference in mirror-mode, where there is only 1 active display, but that
// corresponds to two physical displays which can have different gamma setting requirements:
if ((PSYCH_SYSTEM == PSYCH_OSX) && (physicalDisplay > 0)) {
PsychCopyInIntegerArg(1, TRUE, &screenNumber);
if (screenNumber < 1) PsychErrorExitMsg(PsychError_user, "A 'screenNumber' that is smaller than one provided, although 'physicalDisplay' flag set. This is not allowed!");
// Invert screenNumber as a sign its a physical display, not an active display:
screenNumber = -1 * screenNumber;
}
else {
PsychCopyInScreenNumberArg(1, TRUE, &screenNumber);
}
if ((PSYCH_SYSTEM == PSYCH_LINUX) && (physicalDisplay > -1)) {
// Affect one specific display output for given screen:
outputId = physicalDisplay;
}
else {
// Other OS'es, and Linux with default setting: Affect all outputs
// for a screen.
outputId = -1;
}
// Load and sanity check the input matrix:
inM = -1; inN = -1; inP = -1;
if (!PsychAllocInDoubleMatArg(2, FALSE, &inM, &inN, &inP, &inTable)) {
// Special case: Allow passing in an empty gamma table argument. This
// triggers auto-load of identity LUT and setup of GPU for identity passthrough:
inM = 0; inN = 3; inP = 1;
}
// Sanity check dimensions:
if((inN != 3) || (inP != 1)) PsychErrorExitMsg(PsychError_user, "The gamma table must have 3 columns (Red, Green, Blue).");
// Identity passthrouh setup requested?
if (inM == 0) {
// Yes. Try to enable it, return its status code:
PsychAllocInWindowRecordArg(1, TRUE, &windowRecord);
i = PsychSetGPUIdentityPassthrough(windowRecord, screenNumber, TRUE);
PsychCopyOutDoubleArg(1, FALSE, (double) i);
// Done.
return(PsychError_none);
}
#if PSYCH_SYSTEM != PSYCH_WINDOWS
// OS-X and Linux allow tables with other than 256 slots:
// OS/X either passes them to hw if in native size, or performs
// software interpolation to convert it into native size. We allow any table size with 1 - x slots.
// A table size of 1 row will have a special meaning. It interprets the 1 row of the table as gamma formula
// min, max, gamma and lets the OS compute a corresponding gamma correction table.
// A table size of zero rows will trigger an internal upload of an identity table via byte transfer.
// On Linux we need to interpolate ourselves on non-matching table sizes.
#else
// Windows requires 256 slots:
if((inM != 256) && (inM != 0)) {
PsychErrorExitMsg(PsychError_user, "The gamma table must have 256 rows.");
}
#endif
// Copy in optional loadOnNextFlip - flag. It defaults to zero. If provided
// with a non-zero value, we will defer actual update of the gamma table to
// the next bufferswap as initiated via Screen('Flip').
loadOnNextFlip = 0;
PsychCopyInIntegerArg(3, FALSE, &loadOnNextFlip);
if (loadOnNextFlip>0) {
if ((PSYCH_SYSTEM == PSYCH_OSX) && (physicalDisplay > 0)) PsychErrorExitMsg(PsychError_user, "Non-zero 'loadOnNextFlip' flag not allowed if 'physicalDisplays' flag is non-zero!");
if ((PSYCH_SYSTEM == PSYCH_LINUX) && (physicalDisplay > -1)) PsychErrorExitMsg(PsychError_user, "Non-zero 'loadOnNextFlip' flag not allowed if 'physicalDisplays' setting is positive!");
// Allocate tables in associated windowRecord: We will update during next
// Flip operation for specified windowRecord.
PsychAllocInWindowRecordArg(1, TRUE, &windowRecord);
// Sanity checks:
if (!PsychIsOnscreenWindow(windowRecord)) PsychErrorExitMsg(PsychError_user, "Target window for gamma table upload is not an onscreen window!");
if (windowRecord->inRedTable && loadOnNextFlip!=2) PsychErrorExitMsg(PsychError_user, "This window has already a new gamma table assigned for upload on next Flip!");
if (windowRecord->inRedTable && windowRecord->inTableSize != inM) {
free(windowRecord->inRedTable); windowRecord->inRedTable = NULL;
free(windowRecord->inGreenTable); windowRecord->inGreenTable = NULL;
free(windowRecord->inBlueTable); windowRecord->inBlueTable = NULL;
}
if (windowRecord->inRedTable == NULL) {
// Allocate persistent memory:
inRedTable=malloc(sizeof(float) * inM);
inGreenTable=malloc(sizeof(float) * inM);
inBlueTable=malloc(sizeof(float) * inM);
// Assign the pointers to the windowRecord:
windowRecord->inRedTable = inRedTable;
windowRecord->inGreenTable = inGreenTable;
windowRecord->inBlueTable = inBlueTable;
windowRecord->inTableSize = inM;
}
else {
inRedTable = windowRecord->inRedTable;
inGreenTable = windowRecord->inGreenTable;
inBlueTable = windowRecord->inBlueTable;
}
windowRecord->loadGammaTableOnNextFlip = (loadOnNextFlip == 1) ? 1 : 0;
}
else {
// Allocate temporary tables: We will update immediately.
inRedTable=PsychMallocTemp(sizeof(float) * inM);
inGreenTable=PsychMallocTemp(sizeof(float) * inM);
inBlueTable=PsychMallocTemp(sizeof(float) * inM);
}
for(i=0;i<inM;i++){
inRedTable[i]=(float)inTable[PsychIndexElementFrom3DArray(inM, 3, 0, i, 0, 0)];
inGreenTable[i]=(float)inTable[PsychIndexElementFrom3DArray(inM, 3, 0, i, 1, 0)];
inBlueTable[i]=(float)inTable[PsychIndexElementFrom3DArray(inM, 3, 0, i, 2, 0)];
if(inRedTable[i]>1 || inRedTable[i]< 0 || inGreenTable[i] > 1 || inGreenTable[i] < 0 || inBlueTable[i] >1 || inBlueTable[i] < 0)
PsychErrorExitMsg(PsychError_user, "Gamma Table Values must be in interval 0 =< x =< 1");
}
if (loadOnNextFlip < 2) {
//first read the existing gamma table so we can return it.
PsychReadNormalizedGammaTable(screenNumber, outputId, &numEntries, &outRedTable, &outGreenTable, &outBlueTable);
PsychAllocOutDoubleMatArg(1, FALSE, numEntries, 3, 0, &outTable);
for(i=0;i<numEntries;i++){
outTable[PsychIndexElementFrom3DArray(numEntries, 3, 0, i, 0, 0)]=(double)outRedTable[i];
outTable[PsychIndexElementFrom3DArray(numEntries, 3, 0, i, 1, 0)]=(double)outGreenTable[i];
outTable[PsychIndexElementFrom3DArray(numEntries, 3, 0, i, 2, 0)]=(double)outBlueTable[i];
}
}
//Now set the new gamma table
if (loadOnNextFlip == 0) PsychLoadNormalizedGammaTable(screenNumber, outputId, inM, inRedTable, inGreenTable, inBlueTable);
return(PsychError_none);
}
PsychError SCREENOpenVideoCapture(void)
{
PsychWindowRecordType *windowRecord;
int deviceIndex;
int capturehandle = -1;
double framerate;
int width;
int height;
PsychRectType roirectangle;
psych_bool roiassigned;
int reqdepth = 0;
int num_dmabuffers = 0;
int allow_lowperf_fallback = 1;
char* moviename;
int recordingflags;
int engineId;
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()) {PsychGiveHelp(); return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(9)); // Max. 9 input args.
PsychErrorExit(PsychRequireNumInputArgs(1)); // Min. 1 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, "OpenVideoCapture called on something else than an onscreen window.");
}
// Get the device index. We default to the first device if none is given:
deviceIndex=0;
PsychCopyInIntegerArg(2, FALSE, &deviceIndex);
// Get the optional roi rectangle:
roiassigned = PsychCopyInRectArg(3, FALSE, roirectangle);
if (roiassigned && IsPsychRectEmpty(roirectangle)) PsychErrorExitMsg(PsychError_user, "OpenVideoCapture called with invalid (empty) roirectangle argument.");
// Query (optional) output texture pixel depth: By default, we take whatever we get from the capture device:
PsychCopyInIntegerArg(4, FALSE, &reqdepth);
if (reqdepth<0) PsychErrorExitMsg(PsychError_user, "OpenVideoCapture called with invalid (negative) pixeldepth argument.");
// Query number of ringbuffers to use. Our default is coded in the OS dependent subroutines.
PsychCopyInIntegerArg(5, FALSE, &num_dmabuffers);
if (num_dmabuffers<0) PsychErrorExitMsg(PsychError_user, "OpenVideoCapture called with invalid (negative) numbuffers argument.");
// Query, if use of low-performance fallback code is allowed if high-perf engine fails:
PsychCopyInIntegerArg(6, FALSE, &allow_lowperf_fallback);
if (allow_lowperf_fallback<0) PsychErrorExitMsg(PsychError_user, "OpenVideoCapture called with invalid (negative) allowfallback flag.");
// Query optional moviename for recording the grabbed video into a Quicktime movie file:
moviename = NULL;
PsychAllocInCharArg(7, FALSE, &moviename);
// Query optional movie recording flags:
// 0 = Record video, stream to disk immediately (slower, but unlimited recording duration).
// 1 = Record video, stream to memory, then at end of recording to disk (limited duration by RAM size, but faster).
// 2 = Record audio as well.
// 4 = Do not return capture data via Screen('GetCapturedImage') during video recording to disc.
// 8 = Avoid some performance optimizations which may cause trouble with some codecs.
// 16= Use multi-threading for automatic background processing and cpu offloading.
// 32= Return high quality textures via 'GetCapturedImage' if recording in parallel --> Quality tradeoff live feed vs. recording.
// 64= Return timestamps in engine time instead of GetSecs() time.
recordingflags = 0;
PsychCopyInIntegerArg(8, FALSE, &recordingflags);
// Copy in optional id of video capture engine to use. We default to the one set via the Screen('Preference', 'DefaultVideocaptureEngine');
// setting, which by itself defaults to LibDC1394 (type 1) on Linux, ARVideo (type 2) and Quicktime/SG (type 0) on OS/X for now.
engineId = PsychPrefStateGet_VideoCaptureEngine();
PsychCopyInIntegerArg(9, FALSE, &engineId);
if (engineId < 0 || engineId > 3) PsychErrorExitMsg(PsychError_user, "OpenVideoCapture called with invalid 'captureEngineType'. Valid are 0,1,2,3.");
if (engineId == 2) {
printf("\n\n");
printf("PTB-INFO: Your script explicitely requests use of video capture engine type 2 - the ARVideo video capture engine.\n");
printf("PTB-INFO: This engine has been permanently disabled and removed from Psychtoolbox since beginning of the year 2011.\n");
printf("PTB-INFO: We recommend use of the GStreamer video capture engine (engine type 3) as a technically superior replacement\n");
printf("PTB-INFO: on GNU-Linux and MS-Windows. For Mac OS/X for now we recommend use of the Quicktime engine (engine type 0)\n");
printf("PTB-INFO: as an interims solution. The Quicktime engine will be eventually replaced on OS/X by the GStreamer engine as well.\n");
printf("PTB-INFO: In most cases, the selected replacement should work without need for any further changes to your code.\n\n");
}
// Try to open the capture device and create & initialize a corresponding capture object.
// A MATLAB handle to the video capture object is returned upon successfull operation.
if (roiassigned) {
PsychOpenVideoCaptureDevice(engineId, windowRecord, deviceIndex, &capturehandle, roirectangle, reqdepth, num_dmabuffers, allow_lowperf_fallback, moviename, recordingflags);
}
else {
PsychOpenVideoCaptureDevice(engineId, windowRecord, deviceIndex, &capturehandle, NULL, reqdepth, num_dmabuffers, allow_lowperf_fallback, moviename, recordingflags);
}
// Upon sucessfull completion, we'll have a valid handle in 'capturehandle'. Return it to Matlab-world:
PsychCopyOutDoubleArg(1, TRUE, (double) capturehandle);
// Ready!
return(PsychError_none);
}
/* PsychEnableNative10BitFramebuffer() - Enable/Disable native 10 bpc RGB framebuffer modes.
*
* This function enables or disables the native ARGB2101010 framebuffer readout mode of supported
* graphics hardware. Currently the ATI Radeon X1000/HD2000/HD3000 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, as well as enable
* flags to see if a change is required at all, and the OpenGL context for some specific
* fixups. A value of NULL will try to apply the operation to all heads, but may only work
* for *disabling* 10 bpc mode, not for enabling it -- Mostly useful for a master reset to
* system default, e.g., as part of error handling or Screen shutdown handling.
* 'enable' True = Enable ABGR2101010 support, False = Disable ARGB2101010 support, reenable ARGB8888 support.
*
*/
psych_bool PsychEnableNative10BitFramebuffer(PsychWindowRecordType* windowRecord, psych_bool enable)
{
#if PSYCH_SYSTEM == PSYCH_OSX || PSYCH_SYSTEM == PSYCH_LINUX
int i, si, ei, headid, headiter, screenId;
unsigned int lutreg, ctlreg, value, status;
int gpuMaintype, gpuMinortype;
// Child protection:
if (windowRecord && !PsychIsOnscreenWindow(windowRecord)) PsychErrorExitMsg(PsychError_internal, "Invalid non-onscreen windowRecord provided!!!");
// Either screenid from windowRecord or our special -1 "all Screens" Id:
screenId = (windowRecord) ? windowRecord->screenNumber : -1;
// We only support Radeon GPU's, nothing else:
if (!PsychGetGPUSpecs(screenId, &gpuMaintype, &gpuMinortype, NULL, NULL) ||
(gpuMaintype != kPsychRadeon) || (gpuMinortype >= 0xffff)) {
return(FALSE);
}
// Define range of screens: Either a single specific one, or all:
si = (screenId!=-1) ? screenId : 0;
ei = (screenId!=-1) ? screenId+1 : PsychGetNumDisplays();
// Loop over all target screens:
for (i = si; i < ei; i++) {
// Iterate over range of all assigned heads for this screenId 'i' and reconfigure them:
for (headiter = 0; headiter < kPsychMaxPossibleCrtcs; headiter++) {
// Map screenid to headid for headiter'th head:
headid = PsychScreenToCrtcId(i, headiter);
// We're done as soon as we encounter invalid negative headid.
if (headid < 0) break;
// Select Radeon HW registers for corresponding heads:
if (gpuMinortype < 0x40) {
// DCE-3 and earlier:
lutreg = (headid == 0) ? RADEON_D1GRPH_LUT_SEL : RADEON_D2GRPH_LUT_SEL;
ctlreg = (headid == 0) ? RADEON_D1GRPH_CONTROL : RADEON_D2GRPH_CONTROL;
}
else {
// DCE-4 and later:
if (headid > DCE4_MAXHEADID) {
printf("PTB-ERROR: Invalid headId %i (greater than max %i) provided for DCE-4+ display engine!\n", headid, DCE4_MAXHEADID);
return(false);
}
lutreg = EVERGREEN_DC_LUT_10BIT_BYPASS + crtcoff[headid];
ctlreg = EVERGREEN_GRPH_CONTROL + crtcoff[headid];
}
// Enable or Disable?
if (enable) {
// Enable:
// Switch hardware LUT's to bypass mode:
// We set bit 8 to enable "bypass LUT in 2101010 mode":
value = PsychOSKDReadRegister(screenId, lutreg, &status);
if (status) {
printf("PTB-ERROR: Failed to set 10 bit framebuffer mode (LUTReg read failed).\n");
return(false);
}
// Set the bypass bit:
value = value | 0x1 << 8;
PsychOSKDWriteRegister(screenId, lutreg, value, &status);
if (status) {
printf("PTB-ERROR: Failed to set 10 bit framebuffer mode (LUTReg write failed).\n");
return(false);
}
// Only reconfigure framebuffer scanout if this is really our true Native10bpc hack:
// This is usually skipped on FireGL/FirePro GPU's as their drivers do it already...
if (windowRecord->specialflags & kPsychNative10bpcFBActive) {
// Switch CRTC to ABGR2101010 readout mode:
// We set bit 8 to enable that mode:
value = PsychOSKDReadRegister(screenId, ctlreg, &status);
if (status) {
printf("PTB-ERROR: Failed to set 10 bit framebuffer mode (CTLReg read failed).\n");
return(false);
}
// Set 2101010 mode bit:
value = value | 0x1 << 8;
PsychOSKDWriteRegister(screenId, ctlreg, value, &status);
if (status) {
printf("PTB-ERROR: Failed to set 10 bit framebuffer mode (CTLReg write failed).\n");
return(false);
}
}
// Pipe should be in 10 bpc mode now...
if (PsychPrefStateGet_Verbosity() > 2) printf("PTB-INFO: System framebuffer switched to ARGB2101010 mode for screen %i [head %i].\n", i, headid);
} else {
// Disable:
// Only reconfigure framebuffer scanout if this is really our true Native10bpc hack:
// This is usually skipped on FireGL/FirePro GPU's as their drivers do it already...
if (windowRecord->specialflags & kPsychNative10bpcFBActive) {
// Switch CRTC to ABGR8888 readout mode:
// We clear bit 8 to enable that mode:
value = PsychOSKDReadRegister(screenId, ctlreg, &status);
if (status) {
// This codepath gets always called in PsychCloseWindow(), so we should skip it
// silently if register read fails, as this is expected on MS-Windows and on all
// non-Radeon hardware and if kernel driver isn't loaded:
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-ERROR: Failed to set 8 bit framebuffer mode (CTLReg read failed).\n");
return(false);
}
else if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: In disable 10bpc: Readreg. ctlreg yields %lx\n", value);
// Clear 2101010 mode bit:
value = value & ~(0x1 << 8);
PsychOSKDWriteRegister(screenId, ctlreg, value, &status);
if (status) {
printf("PTB-ERROR: Failed to set 8 bit framebuffer mode (CTLReg write failed).\n");
return(false);
}
else if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: In disable 10bpc: ctlreg reset\n");
// Wait 500 msecs for GPU to settle:
PsychWaitIntervalSeconds(0.5);
}
// Switch hardware LUT's to standard mapping mode:
// We clear bit 8 to disable "bypass LUT in 2101010 mode":
value = PsychOSKDReadRegister(screenId, lutreg, &status);
if (status) {
printf("PTB-ERROR: Failed to set 8 bit framebuffer mode (LUTReg read failed).\n");
return(false);
}
else if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: In disable 10bpc: Readreg. lutreg yields %lx\n", value);
// Clear LUT bypass bit:
value = value & ~(0x1 << 8);
PsychOSKDWriteRegister(screenId, lutreg, value, &status);
if (status) {
printf("PTB-ERROR: Failed to set 8 bit framebuffer mode (LUTReg write failed).\n");
return(false);
}
else if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: In disable 10bpc: lutreg reset\n");
// Pipe should be in 8 bpc mode now...
if (PsychPrefStateGet_Verbosity() > 2) printf("PTB-INFO: System framebuffer switched to standard ARGB8888 mode for screen %i [head %i].\n", i, headid);
}
} // Next display head...
} // Next screenId.
// Done.
return(TRUE);
#else
// This cool stuff not supported on the uncool Windows OS:
return(FALSE);
#endif
}
PsychError SCREENCreateMovie(void)
{
static char useString[] = "moviePtr = Screen('CreateMovie', windowPtr, movieFile [, width][, height][, frameRate=30][, movieOptions]);";
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, movie creation and recording is only supported on OS/X and Windows, as it "
"needs Apple's Quicktime to be installed. It can use any Quicktime codec that is installed "
"on your system. Currently only single-track video encoding is supported, audio support is tbd.\n\n"
"Movie creation is a 3 step procedure:\n"
"1. Create a movie and define encoding options via 'CreateMovie'.\n"
"2. Add video frames to the movie via calls to 'AddFrameToMovie'.\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. "
"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 usually provides lossless encoding.\n"
"CodecFOURCCId=id FOURCC id. The FOURCC of a desired video codec as a number. Defaults to H.264 codec.\n"
"Choice of codec and quality defines a tradeoff between filesize, quality, processing demand and speed, "
"as well as on which target devices you'll be able to play your movie.\n"
"CodecFOURCC=xxxx FOURCC as a four character text string instead of a number.\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;
char defaultOptions[2] = "";
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()) {PsychGiveHelp(); return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(6)); // Max. 6 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 = PsychGetWidthFromRect(windowRecord->rect);
height = PsychGetHeightFromRect(windowRecord->rect);
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);
// Create movie of given size and framerate with given options:
moviehandle = PsychCreateNewMovieFile(moviefile, width, height, framerate, movieOptions);
if (0 > moviehandle) {
printf("See http://developer.apple.com/documentation/QuickTime/APIREF/ErrorCodes.htm#//apple_ref/doc/constant_group/Error_Codes.\n\n");
PsychErrorExitMsg(PsychError_user, "CreateMovie failed for reason mentioned above.");
}
// Return handle to it:
PsychCopyOutDoubleArg(1, FALSE, (double) moviehandle);
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);
}
PsychError SCREENWaitBlanking(void)
{
PsychWindowRecordType *windowRecord;
int waitFrames, framesWaited;
double tvbl, ifi;
long screenwidth, screenheight;
int vbl_startline, beampos, lastline;
psych_uint64 vblCount, vblRefCount;
CGDirectDisplayID cgDisplayID;
GLint read_buffer, draw_buffer;
// All subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(2)); //The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(1)); //The required number of inputs
PsychErrorExit(PsychCapNumOutputArgs(1)); //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);
if(!PsychIsOnscreenWindow(windowRecord))
PsychErrorExitMsg(PsychError_user, "Tried to call 'WaitBlanking' on something else than an onscreen window!");
// Get the number of frames to wait:
waitFrames = 0;
PsychCopyInIntegerArg(2, FALSE, &waitFrames);
// We default to wait at least one interval if no argument supplied:
waitFrames = (waitFrames < 1) ? 1 : waitFrames;
// Enable this windowRecords framebuffer as current drawingtarget:
// This is needed to make sure that Offscreen windows work propely.
PsychSetDrawingTarget(windowRecord);
// Retrieve display handle for beamposition queries:
PsychGetCGDisplayIDFromScreenNumber(&cgDisplayID, windowRecord->screenNumber);
// Retrieve final vbl_startline, aka physical height of the display in pixels:
PsychGetScreenSize(windowRecord->screenNumber, &screenwidth, &screenheight);
vbl_startline = (int) screenheight;
// Query duration of a monitor refresh interval: We try to use the measured interval,
// but fallback of the nominal value reported by the operating system if necessary:
if ((ifi = windowRecord->VideoRefreshInterval)<=0) {
if (PsychGetNominalFramerate(windowRecord->screenNumber) > 0) {
// Valid nominal framerate returned by OS: Calculate nominal IFI from it.
ifi = 1.0 / ((double) PsychGetNominalFramerate(windowRecord->screenNumber));
}
else {
// No reasonable value available! We fallback to an assumed 60 Hz refresh...
ifi = 1.0 / 60.0;
}
}
// Query vblcount to test if this method works correctly:
PsychOSGetVBLTimeAndCount(windowRecord, &vblRefCount);
// Check if beamposition queries are supported by this OS and working properly:
if (-1 != PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber) && windowRecord->VBL_Endline >= 0) {
// Beamposition queries supported and fine. We can wait for VBL without bufferswap-tricks:
// This is the OS-X way of doing things. We query the rasterbeamposition and compare it
// to the known values for the VBL area. If we enter VBL, we take a timestamp and return -
// or wait for the next VBL if waitFrames>0
// Query current beamposition when entering WaitBlanking:
beampos = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber);
// Are we in VBL when entering WaitBlanking? If so, we should wait for one additional frame,
// because by definition, WaitBlanking should always wait for at least one monitor refresh
// interval...
if ((beampos<=windowRecord->VBL_Endline) && (beampos>=vbl_startline)) waitFrames++;
while(waitFrames > 0) {
// Enough time for a sleep? If the beam is far away from VBL area, we try to sleep to
// yield some CPU time to other processes in the system -- we are nice citizens ;)
beampos = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber);
while (( ((float)(vbl_startline - beampos)) / (float) windowRecord->VBL_Endline * ifi) > 0.003) {
// At least 3 milliseconds left until retrace. We sleep for 1 millisecond.
PsychWaitIntervalSeconds(0.001);
beampos = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber);
}
// Less than 3 ms away from retrace. Busy-Wait for retrace...
lastline = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber);
beampos = lastline;
while ((beampos < vbl_startline) && (beampos >= lastline)) {
lastline = beampos;
beampos = (long) PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber);
}
// Retrace! Take system timestamp of VBL onset:
PsychGetAdjustedPrecisionTimerSeconds(&tvbl);
// If this wasn't the last frame to wait, we need to wait for end of retrace before
// repeating the loop, because otherwise we would detect the same VBL and skip frames.
// If it is the last frame, we skip it and return as quickly as possible to save the
// Matlab script some extra Millisecond for drawing...
if (waitFrames>1) {
beampos = vbl_startline;
while ((beampos<=windowRecord->VBL_Endline) && (beampos>=vbl_startline)) { beampos = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber); };
}
// Done with this refresh interval...
// Decrement remaining number of frames to wait:
waitFrames--;
}
}
else if (vblRefCount > 0) {
// Display beamposition queries unsupported, but vblank count queries seem to work. Try those.
// Should work on Linux and OS/X:
while(waitFrames > 0) {
vblCount = vblRefCount;
// Wait for next vblank counter increment - aka start of next frame (its vblank):
while (vblCount == vblRefCount) {
// Requery:
PsychOSGetVBLTimeAndCount(windowRecord, &vblCount);
// Yield at least 100 usecs. This is accurate as this code-path
// only executes on OS/X and Linux, never on Windows (as of 01/06/2011):
PsychYieldIntervalSeconds(0.000100);
}
vblRefCount = vblCount;
// Done with this refresh interval...
// Decrement remaining number of frames to wait:
waitFrames--;
}
}
else {
// Other methods unsupported. We use the doublebuffer swap method of waiting for retrace.
//
// Working principle: On each frame, we first copy the content of the (user visible) frontbuffer into the backbuffer.
// Then we ask the OS to perform a front-backbuffer swap on next vertical retrace and go to sleep via glFinish() et al.
// until the OS signals swap-completion. This way PTB's/Matlabs execution will stall until VBL, when swap happens and
// we get woken up. We repeat this procedure 'waitFrames' times, then we take a high precision timestamp and exit the
// Waitblanking loop. As backbuffer and frontbuffer are identical (due to the copy) at swap time, the visual display
// won't change at all for the subject.
// This method should work reliably, but it has one drawback: A random wakeup delay (scheduling jitter) is added after
// retrace has been entered, so Waitblanking returns only after the beam has left retrace state on older hardware.
// This means a bit less time (1 ms?) for stimulus drawing on Windows than on OS-X where Waitblanking returns faster.
// Child protection:
if (windowRecord->windowType != kPsychDoubleBufferOnscreen) {
PsychErrorExitMsg(PsychError_internal, "WaitBlanking tried to perform swap-waiting on a single buffered window!");
}
// Setup buffers for front->back copy op:
// Backup old read- writebuffer assignments:
glGetIntegerv(GL_READ_BUFFER, &read_buffer);
glGetIntegerv(GL_DRAW_BUFFER, &draw_buffer);
// Set read- and writebuffer properly:
glReadBuffer(GL_FRONT);
glDrawBuffer(GL_BACK);
// Reset viewport to full-screen default:
glViewport(0, 0, screenwidth, screenheight);
glScissor(0, 0, screenwidth, screenheight);
// Reset color buffer writemask to "All enabled":
glColorMask(TRUE, TRUE, TRUE, TRUE);
glDisable(GL_BLEND);
glPixelZoom(1,1);
// Disable draw shader:
PsychSetShader(windowRecord, 0);
// Swap-Waiting loop for 'waitFrames' frames:
while(waitFrames > 0) {
// Copy current content of front buffer into backbuffer:
glRasterPos2i(0, screenheight);
glCopyPixels(0, 0, screenwidth, screenheight, GL_COLOR);
// Ok, front- and backbuffer are now identical, so a bufferswap
// will be a visual no-op.
// Enable beamsyncing of bufferswaps to VBL:
PsychOSSetVBLSyncLevel(windowRecord, 1);
// Trigger bufferswap in sync with retrace:
PsychOSFlipWindowBuffers(windowRecord);
// Wait for swap-completion, aka beginning of VBL:
PsychWaitPixelSyncToken(windowRecord);
// VBL happened - Take system timestamp:
PsychGetAdjustedPrecisionTimerSeconds(&tvbl);
// This code-chunk is an alternate way of syncing, only used for debugging:
if (false) {
// Disable beamsyncing of bufferswaps to VBL:
PsychOSSetVBLSyncLevel(windowRecord, 0);
// Swap buffers immediately without vsync:
PsychOSFlipWindowBuffers(windowRecord);
}
// Decrement remaining number of frames to wait:
waitFrames--;
} // Do it again...
// Enable beamsyncing of bufferswaps to VBL:
PsychOSSetVBLSyncLevel(windowRecord, 1);
// Restore assignment of read- writebuffers and such:
glEnable(GL_BLEND);
glReadBuffer(read_buffer);
glDrawBuffer(draw_buffer);
// Done with Windows waitblanking...
}
// Compute number of frames waited: It is timestamp of return of this waitblanking minus
// timestamp of return of last waitblanking, divided by duration of a monitor refresh
// interval, mathematically rounded to an integral number:
framesWaited = (int) (((tvbl - windowRecord->time_at_last_vbl) / ifi) + 0.5f);
// Update timestamp for next invocation of Waitblanking:
windowRecord->time_at_last_vbl = tvbl;
// Return optional number of frames waited:
PsychCopyOutDoubleArg(1, FALSE, (double) framesWaited);
// Done.
return(PsychError_none);
}
/*
* PsychQTGetTextureFromMovie() -- Create an OpenGL texture map from a specific videoframe from given movie object.
*
* win = Window pointer of onscreen window for which a OpenGL texture should be created.
* moviehandle = Handle to the movie object.
* checkForImage = true == Just check if new image available, false == really retrieve the image, blocking if necessary.
* timeindex = When not in playback mode, this allows specification of a requested frame by presentation time.
* If set to -1, or if in realtime playback mode, this parameter is ignored and the next video frame is returned.
* out_texture = Pointer to the Psychtoolbox texture-record where the new texture should be stored.
* presentation_timestamp = A ptr to a double variable, where the presentation timestamp of the returned frame should be stored.
*
* Returns true (1) on success, false (0) if no new image available, -1 if no new image available and there won't be any in future.
*/
int PsychQTGetTextureFromMovie(PsychWindowRecordType *win, int moviehandle, int checkForImage, double timeindex, PsychWindowRecordType *out_texture, double *presentation_timestamp)
{
static TimeValue myNextTimeCached = -2;
static TimeValue nextFramesTimeCached = -2;
TimeValue myCurrTime;
TimeValue myNextTime;
TimeValue nextFramesTime=0;
short myFlags;
OSType myTypes[1];
OSErr error = noErr;
Movie theMovie;
CVOpenGLTextureRef newImage = NULL;
QTVisualContextRef theMoviecontext;
unsigned int failcount=0;
float lowerLeft[2];
float lowerRight[2];
float upperRight[2];
float upperLeft[2];
GLuint texid;
Rect rect;
float rate;
double targetdelta, realdelta, frames;
PsychRectType outRect;
if (!PsychIsOnscreenWindow(win)) {
PsychErrorExitMsg(PsychError_user, "Need onscreen window ptr!!!");
}
// Activate OpenGL context of target window:
PsychSetGLContext(win);
// Explicitely disable Apple's Client storage extensions. For now they are not really useful to us.
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
if (moviehandle < 0 || moviehandle >= PSYCH_MAX_MOVIES) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided.");
}
if ((timeindex!=-1) && (timeindex < 0 || timeindex >= 10000.0)) {
PsychErrorExitMsg(PsychError_user, "Invalid timeindex provided.");
}
if (NULL == out_texture && !checkForImage) {
PsychErrorExitMsg(PsychError_internal, "NULL-Ptr instead of out_texture ptr passed!!!");
}
// Fetch references to objects we need:
theMovie = movieRecordBANK[moviehandle].theMovie;
theMoviecontext = movieRecordBANK[moviehandle].QTMovieContext;
if (theMovie == NULL) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided. No movie associated with this handle.");
}
// Check if end of movie is reached. Rewind, if so...
if (IsMovieDone(theMovie) && movieRecordBANK[moviehandle].loopflag > 0) {
if (GetMovieRate(theMovie)>0) {
GoToBeginningOfMovie(theMovie);
} else {
GoToEndOfMovie(theMovie);
}
}
// Is movie actively playing (automatic async playback, possibly with synced sound)?
// If so, then we ignore the 'timeindex' parameter, because the automatic playback
// process determines which frames should be delivered to PTB when. This function will
// simply wait or poll for arrival/presence of a new frame that hasn't been fetched
// in previous calls.
if (0 == GetMovieRate(theMovie)) {
// Movie playback inactive. We are in "manual" mode: No automatic async playback,
// no synced audio output. The user just wants to manually fetch movie frames into
// textures for manual playback in a standard Matlab-loop.
// First pass - checking for new image?
if (checkForImage) {
// Image for specific point in time requested?
if (timeindex >= 0) {
// Yes. We try to retrieve the next possible image for requested timeindex.
myCurrTime = (TimeValue) ((timeindex * (double) GetMovieTimeScale(theMovie)) + 0.5f);
}
else {
// No. We just retrieve the next frame, given the current movie time.
myCurrTime = GetMovieTime(theMovie, NULL);
}
// Retrieve timeindex of the closest image sample after myCurrTime:
myFlags = nextTimeStep + nextTimeEdgeOK; // We want the next frame in the movie's media.
myTypes[0] = VisualMediaCharacteristic; // We want video samples.
GetMovieNextInterestingTime(theMovie, myFlags, 1, myTypes, myCurrTime, FloatToFixed(1), &myNextTime, &nextFramesTime);
error = GetMoviesError();
if (error != noErr) {
PsychErrorExitMsg(PsychError_internal, "Failed to fetch texture from movie for given timeindex!");
}
// Found useful event?
if (myNextTime == -1) {
if (PsychPrefStateGet_Verbosity() > 3) printf("PTB-WARNING: Bogus timevalue in movie track for movie %i. Trying to keep going.\n", moviehandle);
// No. Just push timestamp to current time plus a little bit in the hope
// this will get us unstuck:
myNextTime = myCurrTime + (TimeValue) 1;
nextFramesTime = (TimeValue) 0;
}
if (myNextTime != myNextTimeCached) {
// Set movies current time to myNextTime, so the next frame will be fetched from there:
SetMovieTimeValue(theMovie, myNextTime);
// nextFramesTime is the timeindex to which we need to advance for retrieval of next frame: (see code below)
nextFramesTime=myNextTime + nextFramesTime;
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: Current timevalue in movie track for movie %i is %lf secs.\n", moviehandle, (double) myNextTime / (double) GetMovieTimeScale(theMovie));
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: Next timevalue in movie track for movie %i is %lf secs.\n", moviehandle, (double) nextFramesTime / (double) GetMovieTimeScale(theMovie));
// Cache values for 2nd pass:
myNextTimeCached = myNextTime;
nextFramesTimeCached = nextFramesTime;
}
else {
// Somehow got stuck? Do nothing...
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: Seem to be a bit stuck at timevalue [for movie %i] of %lf secs. Nudging a bit forward...\n", moviehandle, (double) myNextTime / (double) GetMovieTimeScale(theMovie));
// Nudge the timeindex a bit forware in the hope that this helps:
SetMovieTimeValue(theMovie, GetMovieTime(theMovie, NULL) + 1);
}
}
else {
// This is the 2nd pass: Image fetching. Use cached values from first pass:
// Caching in a static works because we're always called immediately for 2nd
// pass after successfull return from 1st pass, and we're not multi-threaded,
// i.e., don't need to be reentrant or thread-safe here:
myNextTime = myNextTimeCached;
nextFramesTime = nextFramesTimeCached;
myNextTimeCached = -2;
}
}
else {
// myNextTime unavailable if in autoplayback-mode:
myNextTime=-1;
}
// Presentation timestamp requested?
if (presentation_timestamp) {
// Already available?
if (myNextTime==-1) {
// Retrieve the exact presentation timestamp of the retrieved frame (in movietime):
myFlags = nextTimeStep + nextTimeEdgeOK; // We want the next frame in the movie's media.
myTypes[0] = VisualMediaCharacteristic; // We want video samples.
// We search backward for the closest available image for the current time. Either we get the current time
// if we happen to fetch a frame exactly when it becomes ready, or we get a bit earlier timestamp, which is
// the optimal presentation timestamp for this frame:
GetMovieNextInterestingTime(theMovie, myFlags, 1, myTypes, GetMovieTime(theMovie, NULL), FloatToFixed(-1), &myNextTime, NULL);
}
// Convert pts (in Quicktime ticks) to pts in seconds since start of movie and return it:
*presentation_timestamp = (double) myNextTime / (double) GetMovieTimeScale(theMovie);
}
// Allow quicktime visual context task to do its internal bookkeeping and cleanup work:
if (theMoviecontext) QTVisualContextTask(theMoviecontext);
// Perform decompress-operation:
if (checkForImage) MoviesTask(theMovie, 0);
// Should we just check for new image? If so, just return availability status:
if (checkForImage) {
if (PSYCH_USE_QT_GWORLDS) {
// We use GWorlds. In this case we either suceed immediately due to the
// synchronous nature of GWorld rendering, or we fail completely at end
// of non-looping movie:
if (IsMovieDone(theMovie) && movieRecordBANK[moviehandle].loopflag == 0) {
// No new frame available and there won't be any in the future, because this is a non-looping
// movie that has reached its end.
return(-1);
}
// Is this the special case of a movie without video, but only sound? In that case,
// we always return a 'false' because there ain't no image to return.
if (movieRecordBANK[moviehandle].QTMovieGWorld == NULL) return(false);
// Success!
return(true);
}
// Code which uses QTVisualContextTasks...
if (QTVisualContextIsNewImageAvailable(theMoviecontext, NULL)) {
// New frame ready!
return(true);
}
else if (IsMovieDone(theMovie) && movieRecordBANK[moviehandle].loopflag == 0) {
// No new frame available and there won't be any in the future, because this is a non-looping
// movie that has reached its end.
return(-1);
}
else {
// No new frame available yet:
return(false);
}
}
if (!PSYCH_USE_QT_GWORLDS) {
// Blocking wait-code for non-GWorld mode:
// Try up to 1000 iterations for arrival of requested image data in wait-mode:
failcount=0;
while ((failcount < 1000) && !QTVisualContextIsNewImageAvailable(theMoviecontext, NULL)) {
PsychWaitIntervalSeconds(0.005);
MoviesTask(theMovie, 0);
failcount++;
}
// No new frame available and there won't be any in the future, because this is a non-looping
// movie that has reached its end.
if ((failcount>=1000) && IsMovieDone(theMovie) && (movieRecordBANK[moviehandle].loopflag == 0)) {
return(-1);
}
// Fetch new OpenGL texture with the new movie image frame:
error = QTVisualContextCopyImageForTime(theMoviecontext, kCFAllocatorDefault, NULL, &newImage);
if ((error!=noErr) || newImage == NULL) {
PsychErrorExitMsg(PsychError_internal, "OpenGL<->Quicktime texture fetch failed!!!");
}
// Disable client storage, if it was enabled:
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
// Build a standard PTB texture record:
CVOpenGLTextureGetCleanTexCoords (newImage, lowerLeft, lowerRight, upperRight, upperLeft);
texid = CVOpenGLTextureGetName(newImage);
// Assign texture rectangle:
PsychMakeRect(outRect, upperLeft[0], upperLeft[1], lowerRight[0], lowerRight[1]);
// Set texture orientation as if it were an inverted Offscreen window: Upside-down.
out_texture->textureOrientation = (CVOpenGLTextureIsFlipped(newImage)) ? 3 : 4;
// Assign OpenGL texture id:
out_texture->textureNumber = texid;
// Store special texture object as part of the PTB texture record:
out_texture->targetSpecific.QuickTimeGLTexture = newImage;
}
else {
// Synchronous texture fetch code for GWorld rendering mode:
// At this point, the GWorld should contain the source image for creating a
// standard OpenGL texture:
// Disable client storage, if it was enabled:
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
// Build a standard PTB texture record:
// Assign texture rectangle:
GetMovieBox(theMovie, &rect);
// Hack: Need to extend rect by 4 pixels, because GWorlds are 4 pixels-aligned via
// image row padding:
rect.right = rect.right + 4;
PsychMakeRect(out_texture->rect, rect.left, rect.top, rect.right, rect.bottom);
// Set NULL - special texture object as part of the PTB texture record:
out_texture->targetSpecific.QuickTimeGLTexture = NULL;
// Set texture orientation as if it were an inverted Offscreen window: Upside-down.
out_texture->textureOrientation = 3;
// Setup a pointer to our GWorld as texture data pointer:
out_texture->textureMemorySizeBytes = 0;
// Quicktime textures are aligned on 4 Byte boundaries:
out_texture->textureByteAligned = 4;
// Lock GWorld:
if(!LockPixels(GetGWorldPixMap(movieRecordBANK[moviehandle].QTMovieGWorld))) {
// Locking surface failed! We abort.
PsychErrorExitMsg(PsychError_internal, "PsychQTGetTextureFromMovie(): Locking GWorld pixmap surface failed!!!");
}
// This will retrieve an OpenGL compatible pointer to the GWorlds pixel data and assign it to our texmemptr:
out_texture->textureMemory = (GLuint*) GetPixBaseAddr(GetGWorldPixMap(movieRecordBANK[moviehandle].QTMovieGWorld));
// Let PsychCreateTexture() do the rest of the job of creating, setting up and
// filling an OpenGL texture with GWorlds content:
PsychCreateTexture(out_texture);
// Undo hack from above after texture creation: Now we need the real width of the
// texture for proper texture coordinate assignments in drawing code et al.
rect.right = rect.right - 4;
PsychMakeRect(outRect, rect.left, rect.top, rect.right, rect.bottom);
// Unlock GWorld surface. We do a glFinish() before, for safety reasons...
//glFinish();
UnlockPixels(GetGWorldPixMap(movieRecordBANK[moviehandle].QTMovieGWorld));
// Ready to use the texture... We're done.
}
// Normalize texture rectangle and assign it:
PsychNormalizeRect(outRect, out_texture->rect);
rate = FixedToFloat(GetMovieRate(theMovie));
// Detection of dropped frames: This is a heuristic. We'll see how well it works out...
if (rate && presentation_timestamp) {
// Try to check for dropped frames in playback mode:
// Expected delta between successive presentation timestamps:
targetdelta = 1.0f / (movieRecordBANK[moviehandle].fps * rate);
// Compute real delta, given rate and playback direction:
if (rate>0) {
realdelta = *presentation_timestamp - movieRecordBANK[moviehandle].last_pts;
if (realdelta<0) realdelta = 0;
}
else {
realdelta = -1.0 * (*presentation_timestamp - movieRecordBANK[moviehandle].last_pts);
if (realdelta<0) realdelta = 0;
}
frames = realdelta / targetdelta;
// Dropped frames?
if (frames > 1 && movieRecordBANK[moviehandle].last_pts>=0) {
movieRecordBANK[moviehandle].nr_droppedframes += (int) (frames - 1 + 0.5);
}
movieRecordBANK[moviehandle].last_pts = *presentation_timestamp;
}
// Manually advance movie time, if in fetch mode:
if (0 == GetMovieRate(theMovie)) {
// We are in manual fetch mode: Need to manually advance movie time to next
// media sample:
if (nextFramesTime == myNextTime) {
// Invalid value? Try to hack something that gets us unstuck:
myNextTime = GetMovieTime(theMovie, NULL);
nextFramesTime = myNextTime + (TimeValue) 1;
}
SetMovieTimeValue(theMovie, nextFramesTime);
}
// Check if end of movie is reached. Rewind, if so...
if (IsMovieDone(theMovie) && movieRecordBANK[moviehandle].loopflag > 0) {
if (GetMovieRate(theMovie)>0) {
GoToBeginningOfMovie(theMovie);
} else {
GoToEndOfMovie(theMovie);
}
}
return(TRUE);
}
// This also works as 'AddFrameToMovie', as almost all code is shared with 'GetImage'.
// Only difference is where the fetched pixeldata is sent: To the movie encoder or to
// a matlab/octave matrix.
PsychError SCREENGetImage(void)
{
PsychRectType windowRect, sampleRect;
int nrchannels, invertedY, stride;
size_t ix, iy, sampleRectWidth, sampleRectHeight, redReturnIndex, greenReturnIndex, blueReturnIndex, alphaReturnIndex, planeSize;
int viewid = 0;
psych_uint8 *returnArrayBase, *redPlane;
float *dredPlane;
double *returnArrayBaseDouble;
PsychWindowRecordType *windowRecord;
GLboolean isDoubleBuffer, isStereo;
char* buffername = NULL;
psych_bool floatprecision = FALSE;
GLenum whichBuffer = 0;
int frameduration = 1;
int moviehandle = 0;
unsigned int twidth, theight, numChannels, bitdepth;
unsigned char* framepixels;
psych_bool isOES;
// Called as 2nd personality "AddFrameToMovie" ?
psych_bool isAddMovieFrame = PsychMatch(PsychGetFunctionName(), "AddFrameToMovie");
// All sub functions should have these two lines
if (isAddMovieFrame) {
PsychPushHelp(useString2, synopsisString2, seeAlsoString);
}
else {
PsychPushHelp(useString, synopsisString, seeAlsoString);
}
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//cap the numbers of inputs and outputs
PsychErrorExit(PsychCapNumInputArgs(5)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(1)); //The maximum number of outputs
// Get windowRecord for this window:
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
// Embedded subset has very limited support for readback formats :
isOES = PsychIsGLES(windowRecord);
// Make sure we don't execute on an onscreen window with pending async flip, as this would interfere
// by touching the system backbuffer -> Impaired timing of the flip thread and undefined readback
// of image data due to racing with the ops of the flipperthread on the same drawable.
//
// Note: It would be possible to allow drawBuffer readback if the drawBuffer is not multi-sampled
// or if we can safely multisample-resolve without touching the backbuffer, but checking for all
// special cases adds ugly complexity and is not really worth the effort, so we don't allow this.
//
// If this passes then PsychSetDrawingTarget() below will trigger additional validations to check
// if execution of 'GetImage' is allowed under the current conditions for offscreen windows and
// textures:
if (PsychIsOnscreenWindow(windowRecord) && (windowRecord->flipInfo->asyncstate > 0)) {
PsychErrorExitMsg(PsychError_user, "Calling this function on an onscreen window with a pending asynchronous flip is not allowed!");
}
// Set window as drawingtarget: Even important if this binding is changed later on!
// We need to make sure all needed transitions are done - esp. in non-imaging mode,
// so backbuffer is in a useable state:
PsychSetDrawingTarget(windowRecord);
// Disable shaders:
PsychSetShader(windowRecord, 0);
// Soft-Reset drawingtarget. This is important to make sure no FBO's are bound,
// otherwise the following glGets for GL_DOUBLEBUFFER and GL_STEREO will retrieve
// wrong results, leading to totally wrong read buffer assignments down the road!!
PsychSetDrawingTarget((PsychWindowRecordType*) 0x1);
// Queries only available on desktop OpenGL:
if (!isOES) {
glGetBooleanv(GL_DOUBLEBUFFER, &isDoubleBuffer);
glGetBooleanv(GL_STEREO, &isStereo);
}
else {
// Make something reasonable up:
isStereo = FALSE;
isDoubleBuffer = TRUE;
}
// Force "quad-buffered" stereo mode if our own homegrown implementation is active:
if (windowRecord->stereomode == kPsychFrameSequentialStereo) isStereo = TRUE;
// Assign read buffer:
if(PsychIsOnscreenWindow(windowRecord)) {
// Onscreen window: We read from the front- or front-left buffer by default.
// This works on single-buffered and double buffered contexts in a consistent fashion:
// Copy in optional override buffer name:
PsychAllocInCharArg(3, FALSE, &buffername);
// Override buffer name provided?
if (buffername) {
// Which one is it?
// "frontBuffer" is always a valid choice:
if (PsychMatch(buffername, "frontBuffer")) whichBuffer = GL_FRONT;
// Allow selection of left- or right front stereo buffer in stereo mode:
if (PsychMatch(buffername, "frontLeftBuffer") && isStereo) whichBuffer = GL_FRONT_LEFT;
if (PsychMatch(buffername, "frontRightBuffer") && isStereo) whichBuffer = GL_FRONT_RIGHT;
// Allow selection of backbuffer in double-buffered mode:
if (PsychMatch(buffername, "backBuffer") && isDoubleBuffer) whichBuffer = GL_BACK;
// Allow selection of left- or right back stereo buffer in stereo mode:
if (PsychMatch(buffername, "backLeftBuffer") && isStereo && isDoubleBuffer) whichBuffer = GL_BACK_LEFT;
if (PsychMatch(buffername, "backRightBuffer") && isStereo && isDoubleBuffer) whichBuffer = GL_BACK_RIGHT;
// Allow AUX buffer access for debug purposes:
if (PsychMatch(buffername, "aux0Buffer")) whichBuffer = GL_AUX0;
if (PsychMatch(buffername, "aux1Buffer")) whichBuffer = GL_AUX1;
if (PsychMatch(buffername, "aux2Buffer")) whichBuffer = GL_AUX2;
if (PsychMatch(buffername, "aux3Buffer")) whichBuffer = GL_AUX3;
// If 'drawBuffer' is requested, but imaging pipeline inactive, ie., there is no real 'drawBuffer', then we
// map this to the backbuffer, as on a non-imaging configuration, the backbuffer is pretty much exactly the
// equivalent of the 'drawBuffer':
if (PsychMatch(buffername, "drawBuffer") && !(windowRecord->imagingMode & kPsychNeedFastBackingStore)) whichBuffer = GL_BACK;
}
else {
// Default is frontbuffer:
whichBuffer = GL_FRONT;
}
}
else {
// Offscreen window or texture: They only have one buffer, which is the
// backbuffer in double-buffered mode and the frontbuffer in single buffered mode:
whichBuffer=(isDoubleBuffer) ? GL_BACK : GL_FRONT;
}
// Enable this windowRecords framebuffer as current drawingtarget. This should
// also allow us to "GetImage" from Offscreen windows:
if ((windowRecord->imagingMode & kPsychNeedFastBackingStore) || (windowRecord->imagingMode & kPsychNeedFastOffscreenWindows)) {
// Special case: Imaging pipeline active - We need to activate system framebuffer
// so we really read the content of the framebuffer and not of some FBO:
if (PsychIsOnscreenWindow(windowRecord)) {
// It's an onscreen window:
// Homegrown frame-sequential stereo active? Need to remap some stuff:
if (windowRecord->stereomode == kPsychFrameSequentialStereo) {
// Back/Front buffers map to backleft/frontleft buffers:
if (whichBuffer == GL_BACK) whichBuffer = GL_BACK_LEFT;
if (whichBuffer == GL_FRONT) whichBuffer = GL_FRONT_LEFT;
// Special case: Want to read from stereo front buffer?
if ((whichBuffer == GL_FRONT_LEFT) || (whichBuffer == GL_FRONT_RIGHT)) {
// These don't really exist in our homegrown implementation. Their equivalents are the
// regular system front/backbuffers. Due to the bufferswaps happening every video
// refresh cycle and the complex logic on when and how to blit finalizedFBOs into
// the system buffers and the asynchronous execution of the parallel flipper thread,
// we don't know which buffer (GL_BACK or GL_FRONT) corresponds to the leftFront or
// rightFront buffer. Let's be stupid and just return the current front buffer for
// FRONT_LEFT and the current back buffer for FRONT_RIGHT, but warn user about the
// ambiguity:
whichBuffer = (whichBuffer == GL_FRONT_LEFT) ? GL_FRONT : GL_BACK;
if (PsychPrefStateGet_Verbosity() > 2) {
printf("PTB-WARNING: In Screen('GetImage'): You selected retrieval of one of the stereo front buffers, while our homegrown frame-sequential\n");
printf("PTB-WARNING: In Screen('GetImage'): stereo display mode is active. This will impair presentation timing and may cause flicker. The\n");
printf("PTB-WARNING: In Screen('GetImage'): mapping of 'frontLeftBuffer' and 'frontRightBuffer' to actual stimulus content is very ambiguous\n");
printf("PTB-WARNING: In Screen('GetImage'): in this mode. You may therefore end up with the content of the wrong buffer returned! Check results\n");
printf("PTB-WARNING: In Screen('GetImage'): carefully! Better read from 'backLeftBuffer' or 'backRightBuffer' for well defined results.\n\n");
}
}
}
// Homegrown frame-sequential stereo active and backleft or backright buffer requested?
if (((whichBuffer == GL_BACK_LEFT) || (whichBuffer == GL_BACK_RIGHT)) && (windowRecord->stereomode == kPsychFrameSequentialStereo)) {
// We can get the equivalent of the backLeft/RightBuffer from the finalizedFBO's in this mode. Get their content:
viewid = (whichBuffer == GL_BACK_RIGHT) ? 1 : 0;
whichBuffer = GL_COLOR_ATTACHMENT0_EXT;
// Bind finalizedFBO as framebuffer to read from:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->finalizedFBO[viewid]]->fboid);
// Make sure binding gets released at end of routine:
viewid = -1;
} // No frame-sequential stereo: Full imaging pipeline active and one of the drawBuffer's requested?
else if (buffername && (PsychMatch(buffername, "drawBuffer")) && (windowRecord->imagingMode & kPsychNeedFastBackingStore)) {
// Activate drawBufferFBO:
PsychSetDrawingTarget(windowRecord);
whichBuffer = GL_COLOR_ATTACHMENT0_EXT;
// Is the drawBufferFBO multisampled?
viewid = (((windowRecord->stereomode > 0) && (windowRecord->stereodrawbuffer == 1)) ? 1 : 0);
if (windowRecord->fboTable[windowRecord->drawBufferFBO[viewid]]->multisample > 0) {
// It is! We can't read from a multisampled FBO. Need to perform a multisample resolve operation and read
// from the resolved unisample buffer instead. This is only safe if the unisample buffer is either a dedicated
// FBO, or - in case its the final system backbuffer etc. - if preflip operations haven't been performed yet.
// If non dedicated buffer (aka finalizedFBO) and preflip ops have already happened, then the backbuffer contains
// final content for an upcoming Screen('Flip') and we can't use (and therefore taint) that buffer.
if ((windowRecord->inputBufferFBO[viewid] == windowRecord->finalizedFBO[viewid]) && (windowRecord->backBufferBackupDone)) {
// Target for resolve is finalized FBO (probably system backbuffer) and preflip ops have run already. We
// can't do the resolve op, as this would screw up the backbuffer with the final stimulus:
printf("PTB-ERROR: Tried to 'GetImage' from a multisampled 'drawBuffer', but can't perform anti-aliasing pass due to\n");
printf("PTB-ERROR: lack of a dedicated resolve buffer.\n");
printf("PTB-ERROR: You can get what you wanted by either one of two options:\n");
printf("PTB-ERROR: Either enable a processing stage in the imaging pipeline, even if you don't need it, e.g., by setting\n");
printf("PTB-ERROR: the imagingmode argument in the 'OpenWindow' call to kPsychNeedImageProcessing. This will create a\n");
printf("PTB-ERROR: suitable resolve buffer. Or place the 'GetImage' call before any Screen('DrawingFinished') call, then\n");
printf("PTB-ERROR: i can (ab-)use the system backbuffer as a temporary resolve buffer.\n\n");
PsychErrorExitMsg(PsychError_user, "Tried to 'GetImage' from a multi-sampled 'drawBuffer'. Unsupported operation under given conditions.");
}
else {
// Ok, the inputBufferFBO is a suitable temporary resolve buffer. Perform a multisample resolve blit to it:
// A simple glBlitFramebufferEXT() call will do the copy & downsample operation:
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->drawBufferFBO[viewid]]->fboid);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->fboid);
glBlitFramebufferEXT(0, 0, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->width, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->height,
0, 0, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->width, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
// Bind inputBuffer as framebuffer:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->fboid);
viewid = -1;
}
}
}
else {
// No: Activate system framebuffer:
PsychSetDrawingTarget(NULL);
}
}
else {
// Offscreen window or texture: Select drawing target as usual,
// but set color attachment as read buffer:
PsychSetDrawingTarget(windowRecord);
whichBuffer = GL_COLOR_ATTACHMENT0_EXT;
// We do not support multisampled readout:
if (windowRecord->fboTable[windowRecord->drawBufferFBO[0]]->multisample > 0) {
printf("PTB-ERROR: You tried to Screen('GetImage', ...); from an offscreen window or texture which has multisample anti-aliasing enabled.\n");
printf("PTB-ERROR: This operation is not supported. You must first use Screen('CopyWindow') to create a non-multisampled copy of the\n");
printf("PTB-ERROR: texture or offscreen window, then use 'GetImage' on that copy. The copy will be anti-aliased, so you'll get what you\n");
printf("PTB-ERROR: wanted with a bit more effort. Sorry for the inconvenience, but this is mostly a hardware limitation.\n\n");
PsychErrorExitMsg(PsychError_user, "Tried to 'GetImage' from a multi-sampled texture or offscreen window. Unsupported operation.");
}
}
}
else {
// Normal case: No FBO based imaging - Select drawing target as usual:
PsychSetDrawingTarget(windowRecord);
}
if (!isOES) {
// Select requested read buffer, after some double-check:
if (whichBuffer == 0) PsychErrorExitMsg(PsychError_user, "Invalid or unknown 'bufferName' argument provided.");
glReadBuffer(whichBuffer);
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: In Screen('GetImage'): GL-Readbuffer whichBuffer = %i\n", whichBuffer);
}
else {
// OES: No way to select readbuffer, it is "hard-coded" by system spec, depending
// on framebuffer. For bound FBO, always color attachment zero, for system framebuffer,
// always front buffer on single-buffered setup, back buffer on double-buffered setup:
if (buffername && PsychIsOnscreenWindow(windowRecord) && (whichBuffer != GL_COLOR_ATTACHMENT0_EXT)) {
// Some part of the real system framebuffer of an onscreen window explicitely requested.
if ((windowRecord->windowType == kPsychSingleBufferOnscreen) && (whichBuffer != GL_FRONT) && (PsychPrefStateGet_Verbosity() > 1)) {
printf("PTB-WARNING: Tried to Screen('GetImage') single-buffered framebuffer '%s', but only 'frontBuffer' supported on OpenGL-ES. Returning that instead.\n", buffername);
}
if ((windowRecord->windowType == kPsychDoubleBufferOnscreen) && (whichBuffer != GL_BACK) && (PsychPrefStateGet_Verbosity() > 1)) {
printf("PTB-WARNING: Tried to Screen('GetImage') double-buffered framebuffer '%s', but only 'backBuffer' supported on OpenGL-ES. Returning that instead.\n", buffername);
}
}
}
if (whichBuffer == GL_COLOR_ATTACHMENT0_EXT) {
// FBO of texture / offscreen window / onscreen drawBuffer/inputBuffer
// has size of clientrect -- potentially larger or smaller than backbuffer:
PsychCopyRect(windowRect, windowRecord->clientrect);
}
else {
// Non-FBO backed texture / offscreen window / onscreen window has size
// of raw rect (==clientrect for non-onscreen, == backbuffer size for onscreen):
PsychCopyRect(windowRect, windowRecord->rect);
}
// Retrieve optional read rectangle:
if(!PsychCopyInRectArg(2, FALSE, sampleRect)) PsychCopyRect(sampleRect, windowRect);
if (IsPsychRectEmpty(sampleRect)) return(PsychError_none);
// Compute sampling rectangle:
if ((PsychGetWidthFromRect(sampleRect) >= INT_MAX) || (PsychGetHeightFromRect(sampleRect) >= INT_MAX)) {
PsychErrorExitMsg(PsychError_user, "Too big 'rect' argument provided. Both width and height of the rect must not exceed 2^31 pixels!");
}
sampleRectWidth = (size_t) PsychGetWidthFromRect(sampleRect);
sampleRectHeight= (size_t) PsychGetHeightFromRect(sampleRect);
// Regular image fetch to runtime, or adding to a movie?
if (!isAddMovieFrame) {
// Regular fetch:
// Get optional floatprecision flag: We return data with float-precision if
// this flag is set. By default we return uint8 data:
PsychCopyInFlagArg(4, FALSE, &floatprecision);
// Get the optional number of channels flag: By default we return 3 channels,
// the Red, Green, and blue color channel:
nrchannels = 3;
PsychCopyInIntegerArg(5, FALSE, &nrchannels);
if (nrchannels < 1 || nrchannels > 4) PsychErrorExitMsg(PsychError_user, "Number of requested channels 'nrchannels' must be between 1 and 4!");
if (!floatprecision) {
// Readback of standard 8bpc uint8 pixels:
// No Luminance + Alpha on OES:
if (isOES && (nrchannels == 2)) PsychErrorExitMsg(PsychError_user, "Number of requested channels 'nrchannels' == 2 not supported on OpenGL-ES!");
PsychAllocOutUnsignedByteMatArg(1, TRUE, (int) sampleRectHeight, (int) sampleRectWidth, (int) nrchannels, &returnArrayBase);
if (isOES) {
// We only do RGBA reads on OES, then discard unwanted stuff ourselves:
redPlane = (psych_uint8*) PsychMallocTemp((size_t) 4 * sampleRectWidth * sampleRectHeight);
}
else {
redPlane = (psych_uint8*) PsychMallocTemp((size_t) nrchannels * sampleRectWidth * sampleRectHeight);
}
planeSize = sampleRectWidth * sampleRectHeight;
glPixelStorei(GL_PACK_ALIGNMENT,1);
invertedY = (int) (windowRect[kPsychBottom] - sampleRect[kPsychBottom]);
if (isOES) {
glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RGBA, GL_UNSIGNED_BYTE, redPlane);
stride = 4;
}
else {
stride = nrchannels;
if (nrchannels==1) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RED, GL_UNSIGNED_BYTE, redPlane);
if (nrchannels==2) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, redPlane);
if (nrchannels==3) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RGB, GL_UNSIGNED_BYTE, redPlane);
if (nrchannels==4) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RGBA, GL_UNSIGNED_BYTE, redPlane);
}
//in one pass transpose and flip what we read with glReadPixels before returning.
//-glReadPixels insists on filling up memory in sequence by reading the screen row-wise whearas Matlab reads up memory into columns.
//-the Psychtoolbox screen as setup by gluOrtho puts 0,0 at the top left of the window but glReadPixels always believes that it's at the bottom left.
for(ix=0; ix < sampleRectWidth; ix++){
for(iy=0; iy < sampleRectHeight; iy++){
// Compute write-indices for returned data:
redReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 0);
greenReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 1);
blueReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 2);
alphaReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 3);
// Always return RED/LUMINANCE channel:
returnArrayBase[redReturnIndex] = redPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 0];
// Other channels on demand:
if (nrchannels>1) returnArrayBase[greenReturnIndex] = redPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 1];
if (nrchannels>2) returnArrayBase[blueReturnIndex] = redPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 2];
if (nrchannels>3) returnArrayBase[alphaReturnIndex] = redPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 3];
}
}
}
else {
// Readback of standard 32bpc float pixels into a double matrix:
// No Luminance + Alpha on OES:
if (isOES && (nrchannels == 2)) PsychErrorExitMsg(PsychError_user, "Number of requested channels 'nrchannels' == 2 not supported on OpenGL-ES!");
// Only float readback on floating point FBO's with EXT_color_buffer_float support:
if (isOES && ((whichBuffer != GL_COLOR_ATTACHMENT0_EXT) || (windowRecord->bpc < 16) || !glewIsSupported("GL_EXT_color_buffer_float"))) {
printf("PTB-ERROR: Tried to 'GetImage' pixels in floating point format from a non-floating point surface, or not supported by your hardware.\n");
PsychErrorExitMsg(PsychError_user, "'GetImage' of floating point values from given object not supported on OpenGL-ES!");
}
PsychAllocOutDoubleMatArg(1, TRUE, (int) sampleRectHeight, (int) sampleRectWidth, (int) nrchannels, &returnArrayBaseDouble);
if (isOES) {
dredPlane = (float*) PsychMallocTemp((size_t) 4 * sizeof(float) * sampleRectWidth * sampleRectHeight);
stride = 4;
}
else {
dredPlane = (float*) PsychMallocTemp((size_t) nrchannels * sizeof(float) * sampleRectWidth * sampleRectHeight);
stride = nrchannels;
}
planeSize = sampleRectWidth * sampleRectHeight * sizeof(float);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
invertedY = (int) (windowRect[kPsychBottom]-sampleRect[kPsychBottom]);
if (!isOES) {
if (nrchannels==1) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RED, GL_FLOAT, dredPlane);
if (nrchannels==2) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_LUMINANCE_ALPHA, GL_FLOAT, dredPlane);
if (nrchannels==3) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RGB, GL_FLOAT, dredPlane);
if (nrchannels==4) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RGBA, GL_FLOAT, dredPlane);
}
else {
glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RGBA, GL_FLOAT, dredPlane);
}
//in one pass transpose and flip what we read with glReadPixels before returning.
//-glReadPixels insists on filling up memory in sequence by reading the screen row-wise whearas Matlab reads up memory into columns.
//-the Psychtoolbox screen as setup by gluOrtho puts 0,0 at the top left of the window but glReadPixels always believes that it's at the bottom left.
for(ix=0; ix < sampleRectWidth; ix++){
for(iy=0; iy < sampleRectHeight; iy++){
// Compute write-indices for returned data:
redReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 0);
greenReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 1);
blueReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 2);
alphaReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 3);
// Always return RED/LUMINANCE channel:
returnArrayBaseDouble[redReturnIndex] = dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 0];
// Other channels on demand:
if (nrchannels>1) returnArrayBaseDouble[greenReturnIndex] = dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 1];
if (nrchannels>2) returnArrayBaseDouble[blueReturnIndex] = dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 2];
if (nrchannels>3) returnArrayBaseDouble[alphaReturnIndex] = dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 3];
}
}
}
}
if (isAddMovieFrame) {
// Adding of image to a movie requested:
// Get optional moviehandle:
moviehandle = 0;
PsychCopyInIntegerArg(4, FALSE, &moviehandle);
if (moviehandle < 0) PsychErrorExitMsg(PsychError_user, "Provided 'moviehandle' is negative. Must be greater or equal to zero!");
// Get optional frameduration:
frameduration = 1;
PsychCopyInIntegerArg(5, FALSE, &frameduration);
if (frameduration < 1) PsychErrorExitMsg(PsychError_user, "Number of requested framedurations 'frameduration' is negative. Must be greater than zero!");
framepixels = PsychGetVideoFrameForMoviePtr(moviehandle, &twidth, &theight, &numChannels, &bitdepth);
if (framepixels) {
glPixelStorei(GL_PACK_ALIGNMENT,1);
invertedY = (int) (windowRect[kPsychBottom] - sampleRect[kPsychBottom]);
if (isOES) {
if (bitdepth != 8) PsychErrorExitMsg(PsychError_user, "AddFrameToMovie failed due to wrong bpc value. Only 8 bpc supported on OpenGL-ES.");
if (numChannels == 4) {
// OES: BGRA supported?
if (glewIsSupported("GL_EXT_read_format_bgra")) {
// Yep: Readback in a compatible and acceptably fast format:
glReadPixels((int) sampleRect[kPsychLeft], invertedY, twidth, theight, GL_BGRA, GL_UNSIGNED_BYTE, framepixels);
}
else {
// Suboptimal readback path. will also cause swapped colors in movie writing:
glReadPixels((int) sampleRect[kPsychLeft], invertedY, twidth, theight, GL_RGBA, GL_UNSIGNED_BYTE, framepixels);
}
}
else if (numChannels == 3) {
glReadPixels((int) sampleRect[kPsychLeft], invertedY, twidth, theight, GL_RGB, GL_UNSIGNED_BYTE, framepixels);
}
else PsychErrorExitMsg(PsychError_user, "AddFrameToMovie failed due to wrong number of channels. Only 3 or 4 channels are supported on OpenGL-ES.");
}
else {
// Desktop-GL: Use optimal format and support 16 bpc bitdepth as well.
switch (numChannels) {
case 4:
glReadPixels((int) sampleRect[kPsychLeft], invertedY, twidth, theight, GL_BGRA, (bitdepth <= 8) ? GL_UNSIGNED_INT_8_8_8_8 : GL_UNSIGNED_SHORT, framepixels);
break;
case 3:
glReadPixels((int) sampleRect[kPsychLeft], invertedY, twidth, theight, GL_RGB, (bitdepth <= 8) ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT, framepixels);
break;
case 1:
glReadPixels((int) sampleRect[kPsychLeft], invertedY, twidth, theight, GL_RED, (bitdepth <= 8) ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT, framepixels);
break;
default:
PsychErrorExitMsg(PsychError_user, "AddFrameToMovie failed due to wrong number of channels. Only 1, 3 or 4 channels are supported on OpenGL.");
break;
}
}
// Add frame to movie, mark it as "upside down", with invalid -1 timestamp and a duration of frameduration ticks:
if (PsychAddVideoFrameToMovie(moviehandle, frameduration, TRUE, -1) != 0) {
PsychErrorExitMsg(PsychError_user, "AddFrameToMovie failed with error above!");
}
}
else {
PsychErrorExitMsg(PsychError_user, "Invalid 'moviePtr' provided. Doesn't correspond to a movie open for recording!");
}
}
if (viewid == -1) {
// Need to reset framebuffer binding to get rid of the inputBufferFBO which is bound due to
// multisample resolve ops, or of other special FBO bindings --> Activate system framebuffer:
PsychSetDrawingTarget(NULL);
}
return(PsychError_none);
}
/*
* PsychOpenVideoCaptureDevice() -- Create a video capture object.
*
* This function tries to open a video capture device and return the associated captureHandle for it.
*
* engineId = Type of video capture engine to use: 0 == Quicktime sequence grabbers, 1 == LibDC1394-V2 IIDC Firewire.
* win = Pointer to window record of associated onscreen window.
* deviceIndex = Index of the grabber device. (Currently ignored)
* capturehandle = handle to the new capture object.
* capturerectangle = If non-NULL a ptr to a PsychRectangle which contains the ROI for capture.
* The following arguments are currently ignored on Windows and OS-X:
* reqdepth = Number of layers for captured output textures. (0=Don't care, 1=LUMINANCE8, 2=LUMINANCE8_ALPHA8, 3=RGB8, 4=RGBA8)
* num_dmabuffers = Number of buffers in the ringbuffer queue (e.g., DMA buffers) - This is OS specific. Zero = Don't care.
* allow_lowperf_fallback = If set to 1 then PTB can use a slower, low-performance fallback path to get nasty devices working.
* targetmoviefilename = NULL == Only live capture, non-NULL == Pointer to char-string with name of target QT file for video recording.
* recordingflags = Only used for recording: Request audio recording, ram recording vs. disk recording and such...
* // Query optional movie recording flags:
* // 0 = Record video, stream to disk immediately (slower, but unlimited recording duration).
* // 1 = Record video, stream to memory, then at end of recording to disk (limited duration by RAM size, but faster).
* // 2 = Record audio as well.
*
* bitdepth = Number of bits per color component / channel, aka bpc.
*
*/
psych_bool PsychOpenVideoCaptureDevice(int engineId, PsychWindowRecordType *win, int deviceIndex, int* capturehandle, double* capturerectangle,
int reqdepth, int num_dmabuffers, int allow_lowperf_fallback, char* targetmoviefilename, unsigned int recordingflags, int bitdepth)
{
int i, slotid;
psych_bool dispatched = FALSE;
*capturehandle = -1;
// Sanity checking:
if (!PsychIsOnscreenWindow(win)) {
PsychErrorExitMsg(PsychError_user, "Provided windowPtr is not an onscreen window.");
}
if (numCaptureRecords >= PSYCH_MAX_CAPTUREDEVICES) {
PsychErrorExitMsg(PsychError_user, "Allowed maximum number of simultaneously open capture devices exceeded!");
}
// Search first free slot in mastervidcapRecordBANK:
for (i=0; (i < PSYCH_MAX_CAPTUREDEVICES) && (mastervidcapRecordBANK[i].engineId != -1); i++) {};
if (i>=PSYCH_MAX_CAPTUREDEVICES) {
PsychErrorExitMsg(PsychError_user, "Allowed maximum number of simultaneously open capture devices exceeded!");
}
// Slot slotid will contain the record for our new capture object:
slotid=i;
// Decide which engine to use and dispatch into proper open function:
#ifdef PTBVIDEOCAPTURE_LIBDC
if (engineId == 1) {
// LibDC1394 video capture:
if (!PsychDCOpenVideoCaptureDevice(slotid, win, deviceIndex, capturehandle, capturerectangle, reqdepth,
num_dmabuffers, allow_lowperf_fallback, targetmoviefilename, recordingflags, bitdepth)) {
// Probably won't ever reach this point due to error handling triggered in subfunction... anyway...
return(FALSE);
}
dispatched = TRUE;
}
#endif
#ifdef PTB_USE_GSTREAMER
if (engineId == 3) {
// GStreamer video capture:
if (!PsychGSOpenVideoCaptureDevice(slotid, win, deviceIndex, capturehandle, capturerectangle, reqdepth,
num_dmabuffers, allow_lowperf_fallback, targetmoviefilename, recordingflags, bitdepth)) {
// Probably won't ever reach this point due to error handling triggered in subfunction... anyway...
return(FALSE);
}
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.");
// Ok, new capture device for requested capture engine created...
// Assign new record:
mastervidcapRecordBANK[slotid].engineId = engineId;
// Assign final handle:
*capturehandle = slotid;
// Increase counter:
numCaptureRecords++;
// Ready.
return(TRUE);
}
PsychError SCREENOpenOffscreenWindow(void)
{
int screenNumber, depth, targetScreenNumber;
PsychRectType rect;
PsychColorType color;
PsychWindowRecordType *exampleWindowRecord, *windowRecord, *targetWindow;
psych_bool wasColorSupplied;
char* texturePointer;
size_t xSize, ySize, nbytes;
psych_bool bigendian;
GLubyte *rpb;
int ix;
GLenum fboInternalFormat;
psych_bool needzbuffer;
psych_bool overridedepth = FALSE;
int usefloatformat = 0;
int specialFlags = 0;
int multiSample = 0;
// Detect endianity (byte-order) of machine:
ix=255;
rpb=(GLubyte*) &ix;
bigendian = ( *rpb == 255 ) ? FALSE : TRUE;
ix = 0; rpb = NULL;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//cap the number of inputs
PsychErrorExit(PsychCapNumInputArgs(6)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(2)); //The maximum number of outputs
//1-User supplies a window ptr 2-User supplies a screen number 3-User supplies rect and pixel size
if(PsychIsWindowIndexArg(1)){
PsychAllocInWindowRecordArg(1, TRUE, &exampleWindowRecord);
// Assign normalized copy of example windows rect -- Top-Left corner is always (0,0)
PsychNormalizeRect(exampleWindowRecord->clientrect, rect);
// We copy depth only from exampleWindow if it is a offscreen window (=texture). Copying from
// onscreen windows doesn't make sense, e.g. depth=16 for onscreen means RGBA8 window, but it
// would map onto a LUMINANCE+ALPHA texture for the offscreen window! We always use 32 bit RGBA8
// in such a case.
depth=(PsychIsOffscreenWindow(exampleWindowRecord)) ? exampleWindowRecord->depth : 32;
// unless it is a FBO backed onscreen window in imaging mode: Then we can use the depth from it.
if (exampleWindowRecord->imagingMode & kPsychNeedFastBackingStore || exampleWindowRecord->imagingMode & kPsychNeedFastOffscreenWindows) depth = exampleWindowRecord->depth;
targetScreenNumber=exampleWindowRecord->screenNumber;
targetWindow=exampleWindowRecord;
} else if(PsychIsScreenNumberArg(1)){
PsychCopyInScreenNumberArg(1, TRUE, &screenNumber);
PsychGetScreenRect(screenNumber, rect);
depth=32; // Always use RGBA8 in this case! See above...
targetScreenNumber=screenNumber;
targetWindow=NULL;
} else if(PsychIsUnaffiliatedScreenNumberArg(1)){ //that means -1 or maybe also NaN if we add that option.
// Default to a depth of 32 bpp:
depth = 32;
targetWindow = NULL;
// Get first open onscreen window as target window:
PsychFindScreenWindowFromScreenNumber(kPsychUnaffiliatedWindow, &targetWindow);
if (targetWindow == NULL) PsychErrorExitMsg(PsychError_user, "Could not find any open onscreen window to act as parent for this offscreen window. Open an onscreen window first!");
targetScreenNumber = targetWindow->screenNumber;
PsychGetScreenRect(targetScreenNumber, rect);
} else {
targetScreenNumber = 0; // Make compiler happy.
PsychErrorExit(PsychError_invalidNumdex);
}
if (targetWindow==NULL) {
// Get target window of screen:
PsychFindScreenWindowFromScreenNumber(targetScreenNumber, &targetWindow);
if (targetWindow == NULL) PsychErrorExitMsg(PsychError_user, "Could not find any open onscreen window to act as parent for this offscreen window. Open an onscreen window first!");
targetScreenNumber = targetWindow->screenNumber;
}
//Depth and rect argument supplied as arguments override those inherited from reference screen or window.
//Note that PsychCopyIn* prefix means that value will not be overwritten if the arguments are not present.
PsychCopyInRectArg(3,FALSE, rect);
if (IsPsychRectEmpty(rect)) PsychErrorExitMsg(PsychError_user, "Invalid rect value provided: Empty rects are not allowed.");
// Copy in optional depth: This gets overriden in many ways if imaging pipeline is on:
if (PsychCopyInIntegerArg(4,FALSE, &depth)) overridedepth = TRUE;
// If any of the no longer supported values 0, 1, 2 or 4 is provided, we
// silently switch to 32 bits per pixel, which is the safest and fastest setting:
if (depth==0 || depth==1 || depth==2 || depth==4) depth=32;
// Final sanity check:
if (!(targetWindow->imagingMode & kPsychNeedFastOffscreenWindows) && !(targetWindow->imagingMode & kPsychNeedFastBackingStore) && (depth==64 || depth==128)) {
PsychErrorExitMsg(PsychError_user, "Invalid depth value provided. Must be 8 bpp, 16 bpp, 24 bpp or 32 bpp, unless you enable the imaging pipeline, which provides you with more options!");
}
if (depth!=8 && depth!=16 && depth!=24 && depth!=32 && depth!=64 && depth!=128) {
PsychErrorExitMsg(PsychError_user, "Invalid depth value provided. Must be 8 bpp, 16 bpp, 24 bpp, 32 bpp, or if imagingmode is enabled also 64 bpp or 128 bpp!");
}
// If the imaging pipeline is enabled for the associated onscreen window and fast backing store, aka FBO's
// is requested, then we only accept depths of at least 32 bit, i.e. RGBA windows. We override any lower
// precision spec. This is because some common hardware only supports rendering to RGBA textures, not to
// RGB, LA or Luminance textures.
if ((targetWindow->imagingMode & kPsychNeedFastBackingStore || targetWindow->imagingMode & kPsychNeedFastOffscreenWindows) && (depth < 32)) depth = 32;
// Find the color for the window background.
wasColorSupplied=PsychCopyInColorArg(kPsychUseDefaultArgPosition, FALSE, &color);
// If none provided, use a proper white-value for this window:
if(!wasColorSupplied) PsychLoadColorStruct(&color, kPsychIndexColor, PsychGetWhiteValueFromWindow(targetWindow));
// Get the optional specialmode flag:
PsychCopyInIntegerArg(5, FALSE, &specialFlags);
// OpenGL-ES only supports GL_TEXTURE_2D targets, so enforce these via flags setting 1:
if (PsychIsGLES(targetWindow)) specialFlags |= 1;
// This command converts whatever color we got into RGBA format:
PsychCoerceColorMode(&color);
// printf("R=%i G=%i B=%i A=%i I=%i", color.value.rgba.r, color.value.rgba.g,color.value.rgba.b,color.value.rgba.a,color.value.index);
// First allocate the offscreen window record to store stuff into. If we exit with an error PsychErrorExit() should
// call PsychPurgeInvalidWindows which will clean up the window record.
PsychCreateWindowRecord(&windowRecord); // This also fills the window index field.
// This offscreen window is implemented as a Psychtoolbox texture:
windowRecord->windowType=kPsychTexture;
// We need to assign the screen number of the onscreen-window, so PsychCreateTexture()
// can query the size of the screen/onscreen-window...
windowRecord->screenNumber = targetScreenNumber;
// Assign the computed depth:
windowRecord->depth=depth;
// Default number of channels:
windowRecord->nrchannels=depth / 8;
// Assign the computed rect, but normalize it to start with top-left at (0,0):
PsychNormalizeRect(rect, windowRecord->rect);
// Client rect of an offscreen window is always == rect of it:
PsychCopyRect(windowRecord->clientrect, windowRecord->rect);
// Until here no OpenGL commands executed. Now we need a valid context: Set targetWindow
// as drawing target. This will perform neccessary context-switch and all backbuffer
// backup/restore/whatever operations to make sure we can do what we want without
// possibly screwing any offscreen windows and bindings:
if (PsychIsOnscreenWindow(targetWindow) || PsychIsOffscreenWindow(targetWindow)) {
// This is a possible on-/offscreen drawingtarget:
PsychSetDrawingTarget(targetWindow);
}
else {
// This must be a proxy-window object: Can't transition to it!
// But we can safe-reset the current drawingtarget...
PsychSetDrawingTarget((PsychWindowRecordType*) 0x1);
// ...and then switch to the OpenGL context of the 'targetWindow' proxy object:
PsychSetGLContext(targetWindow);
// Ok, framebuffer and bindings are safe and disabled, context is set. We
// should be safe to continue with the proxy...
}
// From here on we have a defined context and state. We can detach the drawing target whenever
// we want, as everything is backed up somewhere for later reinit.
// Create offscreen window either new style as FBO, or old style as texture:
if ((targetWindow->imagingMode & kPsychNeedFastBackingStore) || (targetWindow->imagingMode & kPsychNeedFastOffscreenWindows)) {
// Imaging mode for this window enabled: Use new way of creating the offscreen window:
// We safely unbind any FBO bindings and drawingtargets:
PsychSetDrawingTarget((PsychWindowRecordType*) 0x1);
// Overriden for imagingmode: There we always have 4 channels...
windowRecord->nrchannels=4;
// Start off with standard 8 bpc fixed point:
fboInternalFormat = GL_RGBA8; windowRecord->depth=32; usefloatformat = 0;
// Need 16 bpc fixed point precision?
if (targetWindow->imagingMode & kPsychNeed16BPCFixed) {
fboInternalFormat = (targetWindow->gfxcaps & kPsychGfxCapSNTex16) ? GL_RGBA16_SNORM : GL_RGBA16;
windowRecord->depth=64;
usefloatformat = 0;
}
// Need 16 bpc floating point precision?
if (targetWindow->imagingMode & kPsychNeed16BPCFloat) { fboInternalFormat = GL_RGBA_FLOAT16_APPLE; windowRecord->depth=64; usefloatformat = 1; }
// Need 32 bpc floating point precision?
if (targetWindow->imagingMode & kPsychNeed32BPCFloat) { fboInternalFormat = GL_RGBA_FLOAT32_APPLE; windowRecord->depth=128; usefloatformat = 2; }
// Override depth value provided?
if (overridedepth) {
// Manual depth specified: Override with that depth:
switch(depth) {
case 32:
fboInternalFormat = GL_RGBA8; windowRecord->depth=32; usefloatformat = 0;
break;
case 64:
fboInternalFormat = GL_RGBA_FLOAT16_APPLE; windowRecord->depth=64; usefloatformat = 1;
// Need fallback for lack of float 16 support?
if (!(targetWindow->gfxcaps & kPsychGfxCapFPTex16) && !PsychIsGLES(targetWindow)) {
// Yes. Try 16 bit signed normalized texture instead:
if (PsychPrefStateGet_Verbosity() > 4)
printf("PTB-INFO:OpenOffscreenWindow: Code requested 16 bpc float precision, but this is unsupported. Trying to use 15 bit snorm precision instead.\n");
fboInternalFormat = GL_RGBA16_SNORM; windowRecord->depth=64; usefloatformat = 0;
if (!(targetWindow->gfxcaps & kPsychGfxCapSNTex16)) {
printf("PTB-ERROR:OpenOffscreenWindow: Code requested 16 bpc float precision, but this is unsupported by this graphics card.\n");
printf("PTB-ERROR:OpenOffscreenWindow: Tried to use 16 bit snorm format instead, but failed as this is unsupported as well.\n");
}
}
break;
case 128:
fboInternalFormat = GL_RGBA_FLOAT32_APPLE; windowRecord->depth=128; usefloatformat = 2;
break;
default:
fboInternalFormat = GL_RGBA8; windowRecord->depth=32; usefloatformat = 0;
}
}
// Floating point framebuffer on OpenGL-ES requested?
if (PsychIsGLES(targetWindow) && (usefloatformat > 0)) {
// Yes. We only support 32 bpc float framebuffers with alpha-blending. On less supportive hardware we fail:
if (!(targetWindow->gfxcaps & kPsychGfxCapFPTex32) || !(targetWindow->gfxcaps & kPsychGfxCapFPFBO32)) {
PsychErrorExitMsg(PsychError_user, "Sorry, the requested offscreen window color resolution of 32 bpc floating point is not supported by your graphics card. Game over.");
}
// Supported. Upgrade requested format to 32 bpc float, whatever it was before:
fboInternalFormat = GL_RGBA_FLOAT32_APPLE; windowRecord->depth=128; usefloatformat = 2;
}
// Do we need additional depth buffer attachments?
needzbuffer = (PsychPrefStateGet_3DGfx()>0) ? TRUE : FALSE;
// Copy in optional multiSample argument: It defaults to zero, aka multisampling disabled.
PsychCopyInIntegerArg(6, FALSE, &multiSample);
if (multiSample < 0) PsychErrorExitMsg(PsychError_user, "Invalid negative multiSample level provided!");
// Multisampled anti-aliasing requested?
if (multiSample > 0) {
// Yep. Supported by GPU?
if (!(targetWindow->gfxcaps & kPsychGfxCapFBOMultisample)) {
// No. We fall back to non-multisampled mode:
multiSample = 0;
// Tell user if warnings enabled:
if (PsychPrefStateGet_Verbosity() > 1) {
printf("PTB-WARNING: You requested stimulus anti-aliasing via multisampling by setting the multiSample parameter of Screen('OpenOffscreenWindow', ...) to a non-zero value.\n");
printf("PTB-WARNING: You also requested use of the imaging pipeline. Unfortunately, your combination of operating system, graphics hardware and driver does not\n");
printf("PTB-WARNING: support simultaneous use of the imaging pipeline and multisampled anti-aliasing.\n");
printf("PTB-WARNING: Will therefore continue without anti-aliasing...\n\n");
printf("PTB-WARNING: A driver upgrade may resolve this issue. Users of MacOS-X need at least OS/X 10.5.2 Leopard for support on recent ATI hardware.\n\n");
}
}
}
// Allocate framebuffer object for this Offscreen window:
if (!PsychCreateFBO(&(windowRecord->fboTable[0]), fboInternalFormat, needzbuffer, (int) PsychGetWidthFromRect(rect), (int) PsychGetHeightFromRect(rect), multiSample, specialFlags)) {
// Failed!
PsychErrorExitMsg(PsychError_user, "Creation of Offscreen window in imagingmode failed for some reason :(");
}
// Assign this FBO as drawBuffer for mono channel of our Offscreen window:
windowRecord->drawBufferFBO[0] = 0;
windowRecord->fboCount = 1;
// Assign it as texture as well:
windowRecord->textureNumber = windowRecord->fboTable[0]->coltexid;
windowRecord->textureMemorySizeBytes = 0;
windowRecord->textureMemory = NULL;
windowRecord->texturetarget = (specialFlags & 0x1) ? GL_TEXTURE_2D : GL_TEXTURE_RECTANGLE_EXT;
windowRecord->surfaceSizeBytes = (size_t) (PsychGetWidthFromRect(rect) * PsychGetHeightFromRect(rect) * (windowRecord->depth / 8));
// Set bpc for FBO backed offscreen window:
windowRecord->bpc = (int) (windowRecord->depth / 4);
// Initial setup done, continues below after some shared code...
}
else {
// Traditional texture creation code:
// Special case for alpha-channel: DBL_MAX signals maximum alpha
// value requested. In our own code we need to manually map this to
// the maximum uint8 alpha value of 255:
if (color.value.rgba.a == DBL_MAX) color.value.rgba.a = 255;
// Allocate the texture memory:
// We only allocate the amount really needed for given format, aka numMatrixPlanes - Bytes per pixel.
xSize = (size_t) PsychGetWidthFromRect(rect);
ySize = (size_t) PsychGetHeightFromRect(rect);
windowRecord->textureMemorySizeBytes = ((size_t) (depth/8)) * xSize * ySize;
windowRecord->textureMemory = malloc(windowRecord->textureMemorySizeBytes);
texturePointer=(char*) windowRecord->textureMemory;
// printf("depth=%i xsize=%i ysize=%i mem=%i ptr=%p", depth, xSize, ySize, windowRecord->textureMemorySizeBytes, texturePointer);
// Fill with requested background color:
nbytes=0;
switch (depth) {
case 8: // Pure LUMINANCE texture:
memset((void*) texturePointer, (int) color.value.rgba.r, windowRecord->textureMemorySizeBytes);
break;
case 16: // LUMINANCE + ALPHA
while (nbytes < windowRecord->textureMemorySizeBytes) {
*(texturePointer++) = (psych_uint8) color.value.rgba.r;
*(texturePointer++) = (psych_uint8) color.value.rgba.a;
nbytes+=2;
}
break;
case 24: // RGB:
while (nbytes < windowRecord->textureMemorySizeBytes) {
*(texturePointer++) = (psych_uint8) color.value.rgba.r;
*(texturePointer++) = (psych_uint8) color.value.rgba.g;
*(texturePointer++) = (psych_uint8) color.value.rgba.b;
nbytes+=3;
}
break;
case 32: // RGBA
if (bigendian) {
// Code for big-endian machines, e.g., PowerPC:
while (nbytes < windowRecord->textureMemorySizeBytes) {
*(texturePointer++) = (psych_uint8) color.value.rgba.a;
*(texturePointer++) = (psych_uint8) color.value.rgba.r;
*(texturePointer++) = (psych_uint8) color.value.rgba.g;
*(texturePointer++) = (psych_uint8) color.value.rgba.b;
nbytes+=4;
}
}
else {
// Code for little-endian machines, e.g., IntelPC, IntelMAC, aka Pentium.
while (nbytes < windowRecord->textureMemorySizeBytes) {
*(texturePointer++) = (psych_uint8) color.value.rgba.b;
*(texturePointer++) = (psych_uint8) color.value.rgba.g;
*(texturePointer++) = (psych_uint8) color.value.rgba.r;
*(texturePointer++) = (psych_uint8) color.value.rgba.a;
nbytes+=4;
}
}
break;
}
}
// Shared setup code for FBO vs. non-FBO Offscreen windows:
// Assign parent window and copy its inheritable properties:
PsychAssignParentWindow(windowRecord, targetWindow);
// Texture orientation is type 2 aka upright, non-transposed aka Offscreen window:
windowRecord->textureOrientation = 2;
if ((windowRecord->imagingMode & kPsychNeedFastBackingStore) || (windowRecord->imagingMode & kPsychNeedFastOffscreenWindows)) {
// Last step for FBO backed Offscreen window: Clear it to its background color:
PsychSetDrawingTarget(windowRecord);
// Set default draw shader:
PsychSetShader(windowRecord, -1);
// Set background fill color:
PsychSetGLColor(&color, windowRecord);
// Setup alpha-blending:
PsychUpdateAlphaBlendingFactorLazily(windowRecord);
// Fullscreen fill of a non-onscreen window:
PsychGLRect(windowRecord->rect);
// Multisampling requested? If so, we need to enable it:
if (multiSample > 0) {
glEnable(GL_MULTISAMPLE);
while (glGetError() != GL_NO_ERROR);
}
// Ready. Unbind it.
PsychSetDrawingTarget(NULL);
}
else {
// Old-style setup for non-FBO Offscreen windows:
// Special texture format?
if (specialFlags & 0x1) windowRecord->texturetarget = GL_TEXTURE_2D;
// Let's create and bind a new texture object and fill it with our new texture data.
PsychCreateTexture(windowRecord);
}
// Assign GLSL filter-/lookup-shaders if needed:
PsychAssignHighPrecisionTextureShaders(windowRecord, targetWindow, usefloatformat, (specialFlags & 2) ? 1 : 0);
// specialFlags setting 8? Disable auto-mipmap generation:
if (specialFlags & 0x8) windowRecord->specialflags |= kPsychDontAutoGenMipMaps;
// A specialFlags setting of 32? Protect texture against deletion via Screen('Close') without providing a explicit handle:
if (specialFlags & 32) windowRecord->specialflags |= kPsychDontDeleteOnClose;
// Window ready. Mark it valid and return handle to userspace:
PsychSetWindowRecordValid(windowRecord);
//Return the window index and the rect argument.
PsychCopyOutDoubleArg(1, FALSE, windowRecord->windowIndex);
PsychCopyOutRectArg(2, FALSE, rect);
// Ready.
return(PsychError_none);
}
/*
* PsychGSGetTextureFromMovie() -- Create an OpenGL texture map from a specific videoframe from given movie object.
*
* win = Window pointer of onscreen window for which a OpenGL texture should be created.
* moviehandle = Handle to the movie object.
* checkForImage = true == Just check if new image available, false == really retrieve the image, blocking if necessary.
* timeindex = When not in playback mode, this allows specification of a requested frame by presentation time.
* If set to -1, or if in realtime playback mode, this parameter is ignored and the next video frame is returned.
* out_texture = Pointer to the Psychtoolbox texture-record where the new texture should be stored.
* presentation_timestamp = A ptr to a double variable, where the presentation timestamp of the returned frame should be stored.
*
* Returns true (1) on success, false (0) if no new image available, -1 if no new image available and there won't be any in future.
*/
int PsychGSGetTextureFromMovie(PsychWindowRecordType *win, int moviehandle, int checkForImage, double timeindex,
PsychWindowRecordType *out_texture, double *presentation_timestamp)
{
GstElement *theMovie;
unsigned int failcount=0;
double rate;
double targetdelta, realdelta, frames;
// PsychRectType outRect;
GstBuffer *videoBuffer = NULL;
gint64 bufferIndex;
double deltaT = 0;
GstEvent *event;
if (!PsychIsOnscreenWindow(win)) {
PsychErrorExitMsg(PsychError_user, "Need onscreen window ptr!!!");
}
if (moviehandle < 0 || moviehandle >= PSYCH_MAX_MOVIES) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided.");
}
if ((timeindex!=-1) && (timeindex < 0 || timeindex >= 10000.0)) {
PsychErrorExitMsg(PsychError_user, "Invalid timeindex provided.");
}
if (NULL == out_texture && !checkForImage) {
PsychErrorExitMsg(PsychError_internal, "NULL-Ptr instead of out_texture ptr passed!!!");
}
// Fetch references to objects we need:
theMovie = movieRecordBANK[moviehandle].theMovie;
if (theMovie == NULL) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided. No movie associated with this handle.");
}
// Allow context task to do its internal bookkeeping and cleanup work:
PsychGSProcessMovieContext(movieRecordBANK[moviehandle].MovieContext, FALSE);
// If this is a pure audio "movie" with no video tracks, we always return failed,
// as those certainly don't have movie frames associated.
if (movieRecordBANK[moviehandle].nrVideoTracks == 0) return((checkForImage) ? -1 : FALSE);
// Get current playback rate:
rate = movieRecordBANK[moviehandle].rate;
// Is movie actively playing (automatic async playback, possibly with synced sound)?
// If so, then we ignore the 'timeindex' parameter, because the automatic playback
// process determines which frames should be delivered to PTB when. This function will
// simply wait or poll for arrival/presence of a new frame that hasn't been fetched
// in previous calls.
if (0 == rate) {
// Movie playback inactive. We are in "manual" mode: No automatic async playback,
// no synced audio output. The user just wants to manually fetch movie frames into
// textures for manual playback in a standard Matlab-loop.
// First pass - checking for new image?
if (checkForImage) {
// Image for specific point in time requested?
if (timeindex >= 0) {
// Yes. We try to retrieve the next possible image for requested timeindex.
// Seek to target timeindex:
PsychGSSetMovieTimeIndex(moviehandle, timeindex, FALSE);
}
else {
// No. We just retrieve the next frame, given the current position.
// Nothing to do so far...
}
// Check for frame availability happens down there in the shared check code...
}
}
// Should we just check for new image? If so, just return availability status:
if (checkForImage) {
PsychLockMutex(&movieRecordBANK[moviehandle].mutex);
if ((((0 != rate) && movieRecordBANK[moviehandle].frameAvail) || ((0 == rate) && movieRecordBANK[moviehandle].preRollAvail)) &&
!gst_app_sink_is_eos(GST_APP_SINK(movieRecordBANK[moviehandle].videosink))) {
// New frame available. Unlock and report success:
//printf("PTB-DEBUG: NEW FRAME %d\n", movieRecordBANK[moviehandle].frameAvail);
PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex);
return(true);
}
// Is this the special case of a movie without video, but only sound? In that case
// we always return a 'false' because there ain't no image to return. We check this
// indirectly - If the imageBuffer is NULL then the video callback hasn't been called.
if (oldstyle && (NULL == movieRecordBANK[moviehandle].imageBuffer)) {
PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex);
return(false);
}
// None available. Any chance there will be one in the future?
if (gst_app_sink_is_eos(GST_APP_SINK(movieRecordBANK[moviehandle].videosink)) && movieRecordBANK[moviehandle].loopflag == 0) {
// No new frame available and there won't be any in the future, because this is a non-looping
// movie that has reached its end.
PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex);
return(-1);
}
else {
// No new frame available yet:
PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex);
//printf("PTB-DEBUG: NO NEW FRAME\n");
return(false);
}
}
// If we reach this point, then an image fetch is requested. If no new data
// is available we shall block:
PsychLockMutex(&movieRecordBANK[moviehandle].mutex);
// printf("PTB-DEBUG: Blocking fetch start %d\n", movieRecordBANK[moviehandle].frameAvail);
if (((0 != rate) && !movieRecordBANK[moviehandle].frameAvail) ||
((0 == rate) && !movieRecordBANK[moviehandle].preRollAvail)) {
// No new frame available. Perform a blocking wait:
PsychTimedWaitCondition(&movieRecordBANK[moviehandle].condition, &movieRecordBANK[moviehandle].mutex, 10.0);
// Recheck:
if (((0 != rate) && !movieRecordBANK[moviehandle].frameAvail) ||
((0 == rate) && !movieRecordBANK[moviehandle].preRollAvail)) {
// Game over! Wait timed out after 10 secs.
PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex);
printf("PTB-ERROR: No new video frame received after timeout of 10 seconds! Something's wrong. Aborting fetch.\n");
return(FALSE);
}
// At this point we should have at least one frame available.
// printf("PTB-DEBUG: After blocking fetch start %d\n", movieRecordBANK[moviehandle].frameAvail);
}
// We're here with at least one frame available and the mutex lock held.
// Preroll case is simple:
movieRecordBANK[moviehandle].preRollAvail = 0;
// Perform texture fetch & creation:
if (oldstyle) {
// Reset frame available flag:
movieRecordBANK[moviehandle].frameAvail = 0;
// This will retrieve an OpenGL compatible pointer to the pixel data and assign it to our texmemptr:
out_texture->textureMemory = (GLuint*) movieRecordBANK[moviehandle].imageBuffer;
} else {
// Active playback mode?
if (0 != rate) {
// Active playback mode: One less frame available after our fetch:
movieRecordBANK[moviehandle].frameAvail--;
if (PsychPrefStateGet_Verbosity()>4) printf("PTB-DEBUG: Pulling from videosink, %d buffers avail...\n", movieRecordBANK[moviehandle].frameAvail);
// Clamp frameAvail to queue lengths:
if ((int) gst_app_sink_get_max_buffers(GST_APP_SINK(movieRecordBANK[moviehandle].videosink)) < movieRecordBANK[moviehandle].frameAvail) {
movieRecordBANK[moviehandle].frameAvail = gst_app_sink_get_max_buffers(GST_APP_SINK(movieRecordBANK[moviehandle].videosink));
}
// This will pull the oldest video buffer from the videosink. It would block if none were available,
// but that won't happen as we wouldn't reach this statement if none were available. It would return
// NULL if the stream would be EOS or the pipeline off, but that shouldn't ever happen:
videoBuffer = gst_app_sink_pull_buffer(GST_APP_SINK(movieRecordBANK[moviehandle].videosink));
} else {
// Passive fetch mode: Use prerolled buffers after seek:
// These are available even after eos...
videoBuffer = gst_app_sink_pull_preroll(GST_APP_SINK(movieRecordBANK[moviehandle].videosink));
}
// We can unlock early, thanks to videosink's internal buffering:
PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex);
if (videoBuffer) {
// Assign pointer to videoBuffer's data directly: Avoids one full data copy compared to oldstyle method.
out_texture->textureMemory = (GLuint*) GST_BUFFER_DATA(videoBuffer);
// Assign pts presentation timestamp in pipeline stream time and convert to seconds:
movieRecordBANK[moviehandle].pts = (double) GST_BUFFER_TIMESTAMP(videoBuffer) / (double) 1e9;
if (GST_CLOCK_TIME_IS_VALID(GST_BUFFER_DURATION(videoBuffer)))
deltaT = (double) GST_BUFFER_DURATION(videoBuffer) / (double) 1e9;
bufferIndex = GST_BUFFER_OFFSET(videoBuffer);
} else {
printf("PTB-ERROR: No new video frame received in gst_app_sink_pull_buffer! Something's wrong. Aborting fetch.\n");
return(FALSE);
}
if (PsychPrefStateGet_Verbosity()>4) printf("PTB-DEBUG: ...done.\n");
}
// Assign presentation_timestamp:
if (presentation_timestamp) *presentation_timestamp = movieRecordBANK[moviehandle].pts;
// Activate OpenGL context of target window:
PsychSetGLContext(win);
#if PSYCH_SYSTEM == PSYCH_OSX
// Explicitely disable Apple's Client storage extensions. For now they are not really useful to us.
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
#endif
// Build a standard PTB texture record:
PsychMakeRect(out_texture->rect, 0, 0, movieRecordBANK[moviehandle].width, movieRecordBANK[moviehandle].height);
// Set NULL - special texture object as part of the PTB texture record:
out_texture->targetSpecific.QuickTimeGLTexture = NULL;
// Set texture orientation as if it were an inverted Offscreen window: Upside-down.
out_texture->textureOrientation = 3;
// We use zero client storage memory bytes:
out_texture->textureMemorySizeBytes = 0;
// Textures are aligned on 4 Byte boundaries because texels are RGBA8:
out_texture->textureByteAligned = 4;
// Assign texturehandle of our cached texture, if any, so it gets recycled now:
out_texture->textureNumber = movieRecordBANK[moviehandle].cached_texture;
// Let PsychCreateTexture() do the rest of the job of creating, setting up and
// filling an OpenGL texture with content:
PsychCreateTexture(out_texture);
// After PsychCreateTexture() the cached texture object from our cache is used
// and no longer available for recycling. We mark the cache as empty:
// It will be filled with a new textureid for recycling if a texture gets
// deleted in PsychMovieDeleteTexture()....
movieRecordBANK[moviehandle].cached_texture = 0;
// Detection of dropped frames: This is a heuristic. We'll see how well it works out...
// TODO: GstBuffer videoBuffer provides special flags that should allow to do a more
// robust job, although nothing's wrong with the current approach per se...
if (rate && presentation_timestamp) {
// Try to check for dropped frames in playback mode:
// Expected delta between successive presentation timestamps:
targetdelta = 1.0f / (movieRecordBANK[moviehandle].fps * rate);
// Compute real delta, given rate and playback direction:
if (rate > 0) {
realdelta = *presentation_timestamp - movieRecordBANK[moviehandle].last_pts;
if (realdelta < 0) realdelta = 0;
}
else {
realdelta = -1.0 * (*presentation_timestamp - movieRecordBANK[moviehandle].last_pts);
if (realdelta < 0) realdelta = 0;
}
frames = realdelta / targetdelta;
// Dropped frames?
if (frames > 1 && movieRecordBANK[moviehandle].last_pts >= 0) {
movieRecordBANK[moviehandle].nr_droppedframes += (int) (frames - 1 + 0.5);
}
movieRecordBANK[moviehandle].last_pts = *presentation_timestamp;
}
// Unlock.
if (oldstyle) {
PsychUnlockMutex(&movieRecordBANK[moviehandle].mutex);
} else {
gst_buffer_unref(videoBuffer);
videoBuffer = NULL;
}
// Manually advance movie time, if in fetch mode:
if (0 == rate) {
// We are in manual fetch mode: Need to manually advance movie to next
// media sample:
event = gst_event_new_step(GST_FORMAT_BUFFERS, 1, 1.0, TRUE, FALSE);
gst_element_send_event(theMovie, event);
// Block until seek completed, failed, or timeout of 30 seconds reached:
gst_element_get_state(theMovie, NULL, NULL, (GstClockTime) (30 * 1e9));
}
return(TRUE);
}
PsychError SCREENGetCapturedImage(void)
{
PsychWindowRecordType *windowRecord;
PsychWindowRecordType *textureRecord;
PsychRectType rect;
double summed_intensity;
int capturehandle = -1;
int waitForImage = TRUE;
int specialmode = 0;
double timeout, tnow;
double presentation_timestamp = 0;
int rc=-1;
double targetmemptr = 0;
double* tsummed = NULL;
psych_uint8 *targetmatrixptr = NULL;
static rawcapimgdata rawCaptureBuffer = {0, 0, 0, NULL};
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()) {PsychGiveHelp(); return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(6)); // Max. 6 input args.
PsychErrorExit(PsychRequireNumInputArgs(2)); // Min. 2 input args required.
PsychErrorExit(PsychCapNumOutputArgs(4)); // Max. 4 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) && !PsychIsOffscreenWindow(windowRecord)) {
PsychErrorExitMsg(PsychError_user, "GetCapturedImage called on something else than an onscreen window or offscreen window.");
}
// Get the handle:
PsychCopyInIntegerArg(2, TRUE, &capturehandle);
if (capturehandle==-1) {
PsychErrorExitMsg(PsychError_user, "GetCapturedImage called without valid handle to a capture object.");
}
// Get the 'waitForImage' flag: If waitForImage == true == 1, we'll do a blocking wait for
// arrival of a new image. Otherwise we will return with a 0-Handle if there
// isn't any new image available.
PsychCopyInIntegerArg(3, FALSE, &waitForImage);
// Special case waitForImage == 4? This would ask to call into the capture driver, but
// not wait for any image to arrive and not return any information. This is only useful
// on OS/X and Windows when using the capture engine for video recording to harddisk. In
// that case we are not interested at all in the captured live video, we just want it to
// get written to harddisk in the background. To keep the video encoder going, we need to
// call its SGIdle() routine and waitForImage==4 does just that, call SGIdle().
if (waitForImage == 4) {
// Perform the null-call to the capture engine, ie a SGIdle() on OS/X and Windows:
PsychGetTextureFromCapture(windowRecord, capturehandle, 4, 0.0, NULL, NULL, NULL, NULL);
// Done. Nothing to return...
return(PsychError_none);
}
// Get the optional textureRecord for the optional texture handle. If the calling script
// provides the texture handle of an existing Psychtoolbox texture that has a matching
// format, then that texture is recycled by overwriting its previous content with the
// image data from the new captured image. This can save some overhead for texture destruction
// and recreation. While this is probably not noticeable on mid- to high-end gfx cards with
// rectangle texture support, it can provide a significant speedup on low-end gfx cards with
// only power-of-two texture support.
textureRecord = NULL;
if ((PsychGetNumInputArgs()>=4) && PsychIsWindowIndexArg(4)) PsychAllocInWindowRecordArg(4, FALSE, &textureRecord);
// Get the optional specialmode flag:
PsychCopyInIntegerArg(5, FALSE, &specialmode);
// Set a 10 second maximum timeout for waiting for new frames:
PsychGetAdjustedPrecisionTimerSeconds(&timeout);
timeout+=10;
while (rc==-1) {
// We pass a checkForImage value of 2 if waitForImage>0. This way we can signal if we are in polling or blocking mode.
// With the libdc1394 engine this allows to do a real blocking wait in the driver -- much more efficient than the spin-waiting approach!
rc = PsychGetTextureFromCapture(windowRecord, capturehandle, ((waitForImage>0 && waitForImage<3) ? 2 : 1), 0.0, NULL, &presentation_timestamp, NULL, &rawCaptureBuffer);
PsychGetAdjustedPrecisionTimerSeconds(&tnow);
if (rc==-2 || (tnow > timeout)) {
// No image available and there won't be any in the future, because capture has been stopped or there is a timeout:
if (tnow > timeout) printf("PTB-WARNING: In Screen('GetCapturedImage') timed out waiting for a new frame. No video data in over 10 seconds!\n");
// No new texture available: Return a negative handle:
PsychCopyOutDoubleArg(1, TRUE, -1);
// ...and an invalid timestamp:
PsychCopyOutDoubleArg(2, FALSE, -1);
PsychCopyOutDoubleArg(3, FALSE, 0);
PsychCopyOutDoubleArg(4, FALSE, 0);
// Ready!
return(PsychError_none);
}
else if (rc==-1 && (waitForImage == 0 || waitForImage == 3)) {
// We should just poll once and no new texture available: Return a null-handle:
PsychCopyOutDoubleArg(1, TRUE, 0);
// ...and the current timestamp:
PsychCopyOutDoubleArg(2, FALSE, presentation_timestamp);
PsychCopyOutDoubleArg(3, FALSE, 0);
PsychCopyOutDoubleArg(4, FALSE, 0);
// Ready!
return(PsychError_none);
}
else if (rc==-1 && waitForImage != 0) {
// No new texture available yet. Just sleep a bit and then retry...
PsychYieldIntervalSeconds(0.002);
}
}
// rc == 0 --> New image available: Go ahead...
if (waitForImage!=2 && waitForImage!=3) {
// Ok, we need a texture for the image. Did script provide an old one for recycling?
if (textureRecord) {
// Old texture provided for reuse? Some basic sanity check: Everything else is
// up to the lower level PsychGetTextureFromCapture() routine.
if(!PsychIsOffscreenWindow(textureRecord)) {
PsychErrorExitMsg(PsychError_user, "GetCapturedImage provided with something else than a texture as fourth call parameter.");
}
}
else {
// No old texture provided: Create a new texture record:
PsychCreateWindowRecord(&textureRecord);
// Set mode to 'Texture':
textureRecord->windowType=kPsychTexture;
// We need to assign the screen number of the onscreen-window.
textureRecord->screenNumber=windowRecord->screenNumber;
// It defaults to a 32 bit texture for captured images. On Linux, this will be overriden,
// if optimized formats exist for our purpose:
textureRecord->depth=32;
textureRecord->nrchannels = 4;
// Create default rectangle which describes the dimensions of the image. Will be overwritten
// later on.
PsychMakeRect(rect, 0, 0, 10, 10);
PsychCopyRect(textureRecord->rect, rect);
// Other setup stuff:
textureRecord->textureMemorySizeBytes= 0;
textureRecord->textureMemory=NULL;
// Assign parent window and copy its inheritable properties:
PsychAssignParentWindow(textureRecord, windowRecord);
// Set textureNumber to zero, which means "Not cached, do not recycle"
// Todo: Texture recycling like in PsychMovieSupport for higher efficiency!
textureRecord->textureNumber = 0;
}
// Power-of-two texture requested?
if (specialmode & 0x01) {
// Yes. Spec it:
textureRecord->texturetarget = GL_TEXTURE_2D;
}
}
else {
// Just want to return summed_intensity and timestamp, not real texture...
textureRecord = NULL;
}
// Default to no calculation of summed image intensity:
tsummed = NULL;
if ((PsychGetNumOutputArgs() > 3) && !(specialmode & 0x2)) {
// Return sum of pixel intensities for all channels of this image: Need to
// assign the output pointer for this to happen:
tsummed = &summed_intensity;
}
// Try to fetch an image from the capture object and return it as texture:
targetmatrixptr = NULL;
// Shall we return a Matlab matrix?
if ((PsychGetNumOutputArgs() > 3) && (specialmode & 0x2)) {
// We shall return a matrix with raw image data. Allocate a uint8 matrix
// of sufficient size:
PsychAllocOutUnsignedByteMatArg(4, TRUE, rawCaptureBuffer.depth, rawCaptureBuffer.w, rawCaptureBuffer.h, &targetmatrixptr);
tsummed = NULL;
}
// Shall we return data into preallocated memory buffer?
if (specialmode & 0x4) {
// Copy in memory address (which itself is encoded in a double value):
PsychCopyInDoubleArg(6, TRUE, &targetmemptr);
targetmatrixptr = (psych_uint8*) PsychDoubleToPtr(targetmemptr);
}
if (targetmatrixptr == NULL) {
// Standard fetch of a texture and its timestamp:
rc = PsychGetTextureFromCapture(windowRecord, capturehandle, 0, 0.0, textureRecord, &presentation_timestamp, tsummed, NULL);
}
else {
// Fetch of a memory raw image buffer + timestamp + possibly a texture:
rawCaptureBuffer.data = (void*) targetmatrixptr;
rc = PsychGetTextureFromCapture(windowRecord, capturehandle, 0, 0.0, textureRecord, &presentation_timestamp, tsummed, &rawCaptureBuffer);
}
if (tsummed) {
// Return sum of pixel intensities for all channels of this image:
PsychCopyOutDoubleArg(4, FALSE, summed_intensity);
}
// Real texture requested?
if (textureRecord) {
// Texture ready for consumption.
// Assign GLSL filter-/lookup-shaders if needed: usefloatformat is always == 0 as
// our current capture engine implementations only return 8 bpc fixed textures.
// The 'userRequest' flag is set if specialmode flag is set to 8.
PsychAssignHighPrecisionTextureShaders(textureRecord, windowRecord, 0, (specialmode & 8) ? 1 : 0);
// specialmode setting 16? Disable auto-mipmap generation:
if (specialmode & 16) textureRecord->specialflags |= kPsychDontAutoGenMipMaps;
// Mark it valid and return handle to userspace:
PsychSetWindowRecordValid(textureRecord);
PsychCopyOutDoubleArg(1, TRUE, textureRecord->windowIndex);
}
else {
PsychCopyOutDoubleArg(1, TRUE, 0);
}
// Return presentation timestamp for this image:
PsychCopyOutDoubleArg(2, FALSE, presentation_timestamp);
// Return count of pending frames in buffers or of dropped frames:
PsychCopyOutDoubleArg(3, FALSE, (double) rc);
// Ready!
return(PsychError_none);
}
/* PsychEnableNative10BitFramebuffer() - Enable/Disable native 10 bpc RGB framebuffer modes.
*
* This function enables or disables the native ARGB2101010 framebuffer readout mode of supported
* graphics hardware. Currently the ATI Radeon X1000/HD2000/HD3000 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, as well as enable
* flags to see if a change is required at all, and the OpenGL context for some specific
* fixups. A value of NULL will try to apply the operation to all heads, but may only work
* for *disabling* 10 bpc mode, not for enabling it -- Mostly useful for a master reset to
* system default, e.g., as part of error handling or Screen shutdown handling.
* 'enable' True = Enable ABGR2101010 support, False = Disable ARGB2101010 support, reenable ARGB8888 support.
*
*/
boolean PsychEnableNative10BitFramebuffer(PsychWindowRecordType* windowRecord, boolean enable)
{
int i,si,ei, headid, screenId;
unsigned int lutreg, ctlreg, value, status;
// Child protection:
if (windowRecord && !PsychIsOnscreenWindow(windowRecord)) PsychErrorExitMsg(PsychError_internal, "Invalid non-onscreen windowRecord provided!!!");
// Either screenid from windowRecord or our special -1 "all Screens" Id:
screenId = (windowRecord) ? windowRecord->screenNumber : -1;
// Define range of screens: Either a single specific one, or all:
si = (screenId!=-1) ? screenId : 0;
ei = (screenId!=-1) ? screenId+1 : PsychGetNumDisplays();
#if PSYCH_SYSTEM == PSYCH_OSX || PSYCH_SYSTEM == PSYCH_LINUX
// Loop over all target screens:
for (i=si; i<ei; i++) {
// Map screenid to headid: For now we only support 2 heads and assume
// screenId 0 == head 0, all others equal head 1:
headid = (i<=0) ? 0 : 1;
// Select Radeon HW registers for corresponding heads:
lutreg = (headid == 0) ? RADEON_D1GRPH_LUT_SEL : RADEON_D2GRPH_LUT_SEL;
ctlreg = (headid == 0) ? RADEON_D1GRPH_CONTROL : RADEON_D2GRPH_CONTROL;
// Enable or Disable?
if (enable) {
// Enable:
// Switch hardware LUT's to bypass mode:
// We set bit 8 to enable "bypass LUT in 2101010 mode":
value = PsychOSKDReadRegister(screenId, lutreg, &status);
if (status) {
printf("PTB-ERROR: Failed to set 10 bit framebuffer mode (LUTReg read failed).\n");
return(false);
}
// Set the bypass bit:
value = value | 0x1 << 8;
PsychOSKDWriteRegister(screenId, lutreg, value, &status);
if (status) {
printf("PTB-ERROR: Failed to set 10 bit framebuffer mode (LUTReg write failed).\n");
return(false);
}
// Switch CRTC to ABGR2101010 readout mode:
// We set bit 8 to enable that mode:
value = PsychOSKDReadRegister(screenId, ctlreg, &status);
if (status) {
printf("PTB-ERROR: Failed to set 10 bit framebuffer mode (CTLReg read failed).\n");
return(false);
}
// Set 2101010 moe bit:
value = value | 0x1 << 8;
PsychOSKDWriteRegister(screenId, ctlreg, value, &status);
if (status) {
printf("PTB-ERROR: Failed to set 10 bit framebuffer mode (CTLReg write failed).\n");
return(false);
}
// Pipe should be in 10 bpc mode now...
if (PsychPrefStateGet_Verbosity() > 2) printf("PTB-INFO: System framebuffer switched to ARGB2101010 mode for screen %i [head %i].\n", i, headid);
}
else {
// Disable:
// Switch CRTC to ABGR8888 readout mode:
// We clear bit 8 to enable that mode:
value = PsychOSKDReadRegister(screenId, ctlreg, &status);
if (status) {
// This codepath gets always called in PsychCloseWindow(), so we should skip it
// silently if register read fails, as this is expected on MS-Windows and on all
// non-Radeon hardware and if kernel driver isn't loaded:
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-ERROR: Failed to set 8 bit framebuffer mode (CTLReg read failed).\n");
return(false);
}
else if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: In disable 10bpc: Readreg. ctlreg yields %lx\n", value);
// Clear 2101010 mode bit:
value = value & ~(0x1 << 8);
PsychOSKDWriteRegister(screenId, ctlreg, value, &status);
if (status) {
printf("PTB-ERROR: Failed to set 8 bit framebuffer mode (CTLReg write failed).\n");
return(false);
}
else if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: In disable 10bpc: ctlreg reset\n");
// Wait 500 msecs for GPU to settle:
PsychWaitIntervalSeconds(0.5);
// Switch hardware LUT's to standard mapping mode:
// We clear bit 8 to disable "bypass LUT in 2101010 mode":
value = PsychOSKDReadRegister(screenId, lutreg, &status);
if (status) {
printf("PTB-ERROR: Failed to set 8 bit framebuffer mode (LUTReg read failed).\n");
return(false);
}
else if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: In disable 10bpc: Readreg. lutreg yields %lx\n", value);
// Clear LUT bypass bit:
value = value & ~(0x1 << 8);
PsychOSKDWriteRegister(screenId, lutreg, value, &status);
if (status) {
printf("PTB-ERROR: Failed to set 8 bit framebuffer mode (LUTReg write failed).\n");
return(false);
}
else if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: In disable 10bpc: lutreg reset\n");
// Pipe should be in 8 bpc mode now...
if (PsychPrefStateGet_Verbosity() > 2) printf("PTB-INFO: System framebuffer switched to standard ARGB8888 mode for screen %i [head %i].\n", i, headid);
}
// Next display head...
}
#else
// This cool stuff not supported on the uncool Windows OS:
return(FALSE);
#endif
// Done.
return(TRUE);
}
PsychError SCREENSelectStereoDrawBuffer(void)
{
PsychWindowRecordType *windowRecord;
int bufferid=2;
int screenwidth, screenheight;
Boolean Anaglyph;
//all subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(2)); //The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(2)); //The required 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(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
if(!PsychIsOnscreenWindow(windowRecord)) PsychErrorExitMsg(PsychError_user, "Tried to select stereo draw buffer on something else than a onscreen window.");
// Get the buffer id (0==left, 1==right):
PsychCopyInIntegerArg(2, TRUE, &bufferid);
if (bufferid<0 || bufferid>1) PsychErrorExitMsg(PsychError_user, "Invalid bufferid provided: Must be 0 for left-eye or 1 for right-eye buffer.");
// Trying to select other than left buffer on mono-window?
if(windowRecord->windowType!=kPsychDoubleBufferOnscreen || windowRecord->stereomode == kPsychMonoscopic) {
// Yes. Reset to left buffer, which is used for mono mode:
bufferid = 0;
}
// Store assignment in windowRecord:
windowRecord->stereodrawbuffer = bufferid;
// Switch to associated GL-Context:
PsychSetGLContext(windowRecord);
// If the imaging pipeline is active, then we're done.
if (windowRecord->imagingMode & kPsychNeedFastBackingStore) {
// Enable this windowRecords framebuffer as current drawingtarget. In imagingmode this will also
// select the proper backing FBO:
PsychSetDrawingTarget(NULL);
PsychSetDrawingTarget(windowRecord);
// Done for imaging mode:
return(PsychError_none);
}
// The following code is only used for non-imaging mode operations:
PsychSetDrawingTarget(windowRecord);
if(windowRecord->windowType!=kPsychDoubleBufferOnscreen || windowRecord->stereomode == kPsychMonoscopic) {
// Trying to select the draw target buffer on a non-stereo window: We just reset it to monoscopic default.
glDrawBuffer(GL_BACK);
return(PsychError_none);
}
// OpenGL native stereo?
if (windowRecord->stereomode==kPsychOpenGLStereo) {
// OpenGL native stereo via separate back-buffers: Select target draw buffer:
switch(bufferid) {
case 0:
glDrawBuffer(GL_BACK_LEFT);
break;
case 1:
glDrawBuffer(GL_BACK_RIGHT);
break;
}
// Store new assignment:
windowRecord->stereodrawbuffer = bufferid;
}
// Vertical compression stereo?
if (windowRecord->stereomode==kPsychCompressedTLBRStereo || windowRecord->stereomode==kPsychCompressedTRBLStereo) {
PsychSwitchCompressedStereoDrawBuffer(windowRecord, bufferid);
}
// "Free fusion" stereo? Simply place views side-by-side, downscaled by a factor of 2 in horizontal dimension...
if (windowRecord->stereomode==kPsychFreeFusionStereo || windowRecord->stereomode==kPsychFreeCrossFusionStereo) {
// Switch between drawing into left- and right-half of the single framebuffer:
screenwidth=(int) PsychGetWidthFromRect(windowRecord->rect);
screenheight=(int) PsychGetHeightFromRect(windowRecord->rect);
// Store new assignment:
windowRecord->stereodrawbuffer = bufferid;
// Cross fusion instead of fusion requested? Switch left-right if so:
if (windowRecord->stereomode==kPsychFreeCrossFusionStereo) bufferid = 1 - bufferid;
// Setup projection matrix for ortho-projection of full window height, but only
// half window width:
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, screenwidth/2, windowRecord->rect[kPsychBottom], windowRecord->rect[kPsychTop]);
// Switch back to modelview matrix, but leave it unaltered:
glMatrixMode(GL_MODELVIEW);
// When using this stereo modes, we are most likely running on a
// dual display setup with desktop set to "horizontal spanning mode". In this mode,
// we get a virtual onscreen window that is at least twice as wide as its height and
// the left half of the window is displayed on the left monitor, the right half of the
// window is displayed on the right monitor. To make good use of the space, we only
// scale the viewport horizontally to half the window width, but keep it at full height:
// All Screen subfunctions that report the size of the onscreen window to Matlab/Octave/...
// will report it to be only half of its real width, so experiment code can adapt to it.
switch(bufferid) {
case 0:
// Place viewport in the left half of screen:
glViewport(0, 0, screenwidth/2, screenheight);
glScissor(0, 0, screenwidth/2, screenheight);
break;
case 1:
// Place viewport in the right half of screen:
glViewport(screenwidth/2, 0, screenwidth/2, screenheight);
glScissor(screenwidth/2, 0, screenwidth/2, screenheight);
break;
}
}
// And now for the Anaglyph stereo modes, were the left-eye vs. right-eye images are encoded in
// the separate color-channels of the same display. We do this via the OpenGL writemask, which
// allows to selectively enable/disable write operations to the different color channels:
// The alpha channel is always enabled, the red,gree,blue channels are depending on mode and
// bufferid conditionally enabled/disabled:
Anaglyph=FALSE;
switch (windowRecord->stereomode) {
case kPsychAnaglyphRGStereo:
glColorMask(bufferid==0, bufferid==1, FALSE, TRUE);
Anaglyph=TRUE;
break;
case kPsychAnaglyphGRStereo:
glColorMask(bufferid==1, bufferid==0, FALSE, TRUE);
Anaglyph=TRUE;
break;
case kPsychAnaglyphRBStereo:
glColorMask(bufferid==0, FALSE, bufferid==1, TRUE);
Anaglyph=TRUE;
break;
case kPsychAnaglyphBRStereo:
glColorMask(bufferid==1, FALSE, bufferid==0, TRUE);
Anaglyph=TRUE;
break;
}
// Anaglyph mode selected?
// MK: GL_COLOR matrix doesn't seem to work at all on OS-X 10.4.3 +
// Nvidia GeforceFX-Ultra. Therefore this is disabled until the issue
// is resolved. We'll need to do the color->luminance->Gain conversion
// manually if this doesn't work out :(
Anaglyph = FALSE;
/*
if (Anaglyph) {
// Update the red- versus green/blue- gain for color stereo...
float rwgt = 0.3086;
float gwgt = 0.6094;
float bwgt = 0.0820;
PsychTestForGLErrors();
// Note - You might have to transpose the matrix.
float grayscale[4][4] =
{
rwgt, gwgt, bwgt, 0.0,
rwgt, gwgt, bwgt, 0.0,
rwgt, gwgt, bwgt, 0.0,
0.0, 0.0, 0.0, 1.0,
};
glMatrixMode(GL_COLOR);
glLoadMatrixf((const GLfloat*)grayscale);
glMatrixMode(GL_MODELVIEW);
PsychTestForGLErrors();
}
*/
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 SCREENOpenVideoCapture(void)
{
PsychWindowRecordType *windowRecord;
int deviceIndex;
int capturehandle = -1;
double framerate;
int width;
int height;
PsychRectType roirectangle;
Boolean roiassigned;
int reqdepth = 0;
int num_dmabuffers = 0;
int allow_lowperf_fallback = 1;
char* moviename;
int recordingflags;
int engineId;
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()) {PsychGiveHelp(); return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(9)); // Max. 9 input args.
PsychErrorExit(PsychRequireNumInputArgs(1)); // Min. 1 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, "OpenVideoCapture called on something else than an onscreen window.");
}
// Get the device index. We default to the first device if none is given:
deviceIndex=0;
PsychCopyInIntegerArg(2, FALSE, &deviceIndex);
// Get the optional roi rectangle:
roiassigned = PsychCopyInRectArg(3, FALSE, roirectangle);
if (IsPsychRectEmpty(roirectangle)) PsychErrorExitMsg(PsychError_user, "OpenVideoCapture called with invalid (empty) roirectangle argument.");
// Query (optional) output texture pixel depth: By default, we take whatever we get from the capture device:
PsychCopyInIntegerArg(4, FALSE, &reqdepth);
if (reqdepth<0) PsychErrorExitMsg(PsychError_user, "OpenVideoCapture called with invalid (negative) pixeldepth argument.");
// Query number of ringbuffers to use. Our default is coded in the OS dependent subroutines.
PsychCopyInIntegerArg(5, FALSE, &num_dmabuffers);
if (num_dmabuffers<0) PsychErrorExitMsg(PsychError_user, "OpenVideoCapture called with invalid (negative) numbuffers argument.");
// Query, if use of low-performance fallback code is allowed if high-perf engine fails:
PsychCopyInIntegerArg(6, FALSE, &allow_lowperf_fallback);
if (allow_lowperf_fallback<0) PsychErrorExitMsg(PsychError_user, "OpenVideoCapture called with invalid (negative) allowfallback flag.");
// Query optional moviename for recording the grabbed video into a Quicktime movie file:
moviename = NULL;
PsychAllocInCharArg(7, FALSE, &moviename);
// Query optional movie recording flags:
// 0 = Record video, stream to disk immediately (slower, but unlimited recording duration).
// 1 = Record video, stream to memory, then at end of recording to disk (limited duration by RAM size, but faster).
// 2 = Record audio as well.
recordingflags = 0;
PsychCopyInIntegerArg(8, FALSE, &recordingflags);
// Copy in optional id of video capture engine to use. We default to the one set via the Screen('Preference', 'DefaultVideocaptureEngine');
// setting, which by itself defaults to LibDC1394 (type 1) on Linux, and Quicktime/SG (type 0) on all other OSs.
engineId = PsychPrefStateGet_VideoCaptureEngine();
PsychCopyInIntegerArg(9, FALSE, &engineId);
if (engineId<0 || engineId>1) PsychErrorExitMsg(PsychError_user, "OpenVideoCapture called with invalid 'captureEngineType' argument. Valid are zero and one.");
// Try to open the capture device and create & initialize a corresponding capture object.
// A MATLAB handle to the video capture object is returned upon successfull operation.
if (roiassigned) {
PsychOpenVideoCaptureDevice(engineId, windowRecord, deviceIndex, &capturehandle, roirectangle, reqdepth, num_dmabuffers, allow_lowperf_fallback, moviename, recordingflags);
}
else {
PsychOpenVideoCaptureDevice(engineId, windowRecord, deviceIndex, &capturehandle, NULL, reqdepth, num_dmabuffers, allow_lowperf_fallback, moviename, recordingflags);
}
// Upon sucessfull completion, we'll have a valid handle in 'capturehandle'. Return it to Matlab-world:
PsychCopyOutDoubleArg(1, TRUE, (double) capturehandle);
// 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 SCREENConstrainCursor(void)
{
static char useString[] = "Screen('ConstrainCursor', windowIndex, addConstraint [, rect]);";
// 1 2 3
static char synopsisString[] =
"Confine mouse cursor position to a specified area inside onscreen window 'windowIndex'.\n\n"
"If you set 'addConstraint' to 1, then a region constraint is added: 'rect' specifies the "
"rectangle (in window local coordinates) to which the mouse cursor should be confined. If "
"you omit 'rect', then the cursor is confined to the region of the window, ie. can't leave "
"the window. On MS-Windows you can only define one single rectangular region at all, regardless "
"of the number of onscreen windows. On Linux/X11 you can define up to a total of (currently) 1024 "
"confinement regions, e.g., for multiple separate windows, or multiple regions per window.\n"
"Additionally on Linux/X11 you can define empty 'rect's which define a horizontal or vertical line. "
"This adds a horizontal or vertical border line which can not be crossed by the mouse cursor, so you "
"could, e.g., build a complex maze, in which the cursor has to navigate. Please note that this "
"ability will not be present on a future version of Psychtoolbox for Linux with the Wayland display "
"server. While the Wayland implementation will provide the ability to define multiple regions, its "
"semantic will very likely be different, so if you use this special Linux/X11 only feature, your code "
"will not only be non-portable to MS-Windows, but also to future Linux versions which use Wayland instead "
"of the X11 graphics system!\n\n"
"If you set 'addConstraint' to 0 and specify a 'rect', then the specified 'rect' confinement region "
"for the given onscreen window is removed on Linux/X11. If you omit 'rect' on Linux, then all confinement "
"regions for the given onscreen window are removed. On MS-Windows the single globally available confinement "
"region is removed if it was set for the given onscreen window, regardless if you specify 'rect' or not, "
"as there is no ambiguity or choice with only one global rect anyway.\n\n"
"Closing an onscreen window with active cursor constraints will automatically remove all associated "
"cursor confinement regions. This is true for proper close via Screen('Close', windowIndex), Screen('Closeall') or sca, "
"or during a controlled error abort with proper error handling. On Linux, quitting/killing or crashing Octave/Matlab "
"will also release pointer confinement. On MS-Windows, pressing ALT+TAB will release the confinement.\n\n"
"The 'ConstrainCursor' function is not currently supported or supportable on Apple macOS due to macOS "
"operating system limitations. See 'help SetMouse' sections referring to the 'detachFromMouse' parameter for "
"a hint on how you may be able to work around this macOS limitation for some applications.\n\n";
static char seeAlsoString[] = "HideCursorHelper";
PsychWindowRecordType *windowRecord;
int addConstraint;
PsychRectType rect;
// All subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if (PsychIsGiveHelp()) { PsychGiveHelp(); return(PsychError_none); };
PsychErrorExit(PsychCapNumInputArgs(3)); // The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(0)); //The maximum number of outputs
// Get windowRecord:
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
if (!PsychIsOnscreenWindow(windowRecord))
PsychErrorExitMsg(PsychError_user, "Specified window is not an onscreen window, as required.");
// Get flag:
PsychCopyInIntegerArg(2, kPsychArgRequired, &addConstraint);
if (addConstraint) {
// If optional rect is omitted, use full window rect:
if (!PsychCopyInRectArg(3, kPsychArgOptional, rect))
PsychCopyRect(rect, windowRecord->rect);
if (!ValidatePsychRect(rect) || rect[kPsychLeft] < 0 || rect[kPsychTop] < 0 ||
rect[kPsychRight] > PsychGetWidthFromRect(windowRecord->rect) ||
rect[kPsychBottom] > PsychGetHeightFromRect(windowRecord->rect)) {
PsychErrorExitMsg(PsychError_user, "Invalid 'rect' provided. Invalid, or reaches outside the onscreen windows borders.");
}
// Add a new cursor constraint for this window, defined by rect:
if (!PsychOSConstrainPointer(windowRecord, TRUE, rect))
PsychErrorExitMsg(PsychError_user, "Failed to add cursor constraint for onscreen window.");
}
else {
if (PsychCopyInRectArg(3, kPsychArgOptional, rect)) {
// Remove cursor constraint for this window, as defined by rect:
if (!PsychOSConstrainPointer(windowRecord, FALSE, rect))
PsychErrorExitMsg(PsychError_user, "Failed to remove cursor constraint for onscreen window.");
} else {
// Remove all cursor constraints for this window:
if (!PsychOSConstrainPointer(windowRecord, FALSE, NULL))
PsychErrorExitMsg(PsychError_user, "Failed to remove all cursor constraints for onscreen window.");
}
}
return(PsychError_none);
}
