/* Receive messages from the pipeline message bus and handle them: */
static gboolean PsychMovieBusCallback(GstBus *bus, GstMessage *msg, gpointer dataptr)
{
PsychMovieWriterRecordType* dev = (PsychMovieWriterRecordType*) dataptr;
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_EOS:
if (PsychPrefStateGet_Verbosity() > 4) printf("PTB-DEBUG: Moviewriter bus: Message EOS received.\n");
dev->eos = TRUE;
break;
case GST_MESSAGE_WARNING: {
gchar *debug;
GError *error;
gst_message_parse_warning(msg, &error, &debug);
if (PsychPrefStateGet_Verbosity() > 3) {
printf("PTB-WARNING: GStreamer movie writing engine reports this warning:\n"
" Warning from element %s: %s\n", GST_OBJECT_NAME(msg->src), error->message);
printf(" Additional debug info: %s.\n", (debug) ? debug : "None");
}
g_free(debug);
g_error_free(error);
break;
}
case GST_MESSAGE_ERROR: {
gchar *debug;
GError *error;
gst_message_parse_error(msg, &error, &debug);
if (PsychPrefStateGet_Verbosity() > 0) {
printf("PTB-ERROR: GStreamer movie writing engine reports this error:\n"
" Error from element %s: %s\n", GST_OBJECT_NAME(msg->src), error->message);
printf(" Additional debug info: %s.\n\n", (debug) ? debug : "None");
// Special tips for the challenged:
if (strstr(error->message, "property") || (debug && strstr(debug, "property"))) {
// Bailed due to unsupported x264enc parameter "speed-preset". Can be solved by upgrading
// GStreamer or the OS or the VideoCodec= override:
printf("PTB-TIP: The reason this failed is because your GStreamer codec installation is too outdated.\n");
printf("PTB-TIP: Either upgrade your GStreamer (plugin) installation to a more recent version,\n");
printf("PTB-TIP: or upgrade your operating system (e.g., Ubuntu 10.10 'Maverick Meercat' and later are fine).\n");
printf("PTB-TIP: A recent GStreamer installation is required to use all features and get optimal performance.\n");
printf("PTB-TIP: As a workaround, you can manually specify all codec settings, leaving out the unsupported\n");
printf("PTB-TIP: option. See 'help VideoRecording' on how to do that.\n\n");
}
}
g_free(debug);
g_error_free(error);
break;
}
default:
break;
}
return TRUE;
}
/* PsychSynchronizeDisplayScreens() -- (Try to) synchronize display refresh cycles of multiple displays
*
* This tries whatever method is available/appropriate/or requested to synchronize the video refresh
* cycles of multiple graphics cards physical display heads -- corresponding to PTB logical Screens.
*
* The method may or may not be supported on a specific OS/gfx-card combo. It will return a PsychError_unimplemented
* if it can't do what core wants.
*
* numScreens = Ptr to the number of display screens to sync. If numScreens>0, all screens with the screenIds stored
* in the integer array 'screenIds' will be synched. If numScreens == 0, PTB will try to sync all
* available screens in the system. On return, the location will contain the count of synced screens.
*
* screenIds = Either a list with 'numScreens' screenIds for the screens to sync, or NULL if numScreens == 0.
*
* residuals = List with 'numScreens' (on return) values indicating the residual sync error wrt. to the first
* screen (the reference). Ideally all items should contain zero for perfect sync on return.
*
* syncMethod = Numeric Id for the sync method to use: 0 = Don't care, whatever is appropriate. 1 = Only hard
* sync, which is fast and reliable if supported. 2 = Soft sync via drift-syncing. More to come...
*
* syncTimeOut = If some non-immediate method is requested/chosen, it should give up after syncTimeOut seconds if
* it doesn't manage to bring the displays in sync in that timeframe.
*
* allowedResidual = How many scanlines offset after sync are acceptable? Will retry until syncTimeOut if criterion not met.
*
*/
PsychError PsychSynchronizeDisplayScreens(int *numScreens, int* screenIds, int* residuals, unsigned int syncMethod, double syncTimeOut, int allowedResidual)
{
// Currently, we only support a hard, immediate sync of all display heads of a single dual-head gfx-card,
// so we ignore most of our arguments. Well, still check them for validity, but then ignore them after
// successfull validation ;-)
if (numScreens == NULL) PsychErrorExitMsg(PsychError_internal, "NULL-Ptr passed as numScreens argument!");
if (*numScreens < 0 || *numScreens >= PsychGetNumDisplays()) PsychErrorExitMsg(PsychError_internal, "Invalid number passed as numScreens argument! (Negativ or more than available screens)");
if (syncMethod < 0 || syncMethod > 2) PsychErrorExitMsg(PsychError_internal, "Invalid syncMethod argument passed!");
if (syncTimeOut < 0) PsychErrorExitMsg(PsychError_internal, "Invalid (negative) syncTimeOut argument passed!");
if (allowedResidual < 0) PsychErrorExitMsg(PsychError_internal, "Invalid (negative) allowedResidual argument passed!");
// System support:
#if PSYCH_SYSTEM == PSYCH_WINDOWS
if(PsychPrefStateGet_Verbosity() > 1) printf("PTB-WARNING: Synchronization of graphics display heads requested, but this is not supported on MS-Windows.\n");
return(PsychError_unimplemented);
#endif
#if PSYCH_SYSTEM == PSYCH_LINUX
// Dispatch to routine in PsychScreenGlue.c Linux:
return(PsychOSSynchronizeDisplayScreens(numScreens, screenIds, residuals, syncMethod, syncTimeOut, allowedResidual));
#endif
#if PSYCH_SYSTEM == PSYCH_OSX
// Dispatch to routine in PsychScreenGlue.c OSX:
return(PsychOSSynchronizeDisplayScreens(numScreens, screenIds, residuals, syncMethod, syncTimeOut, allowedResidual));
#endif
// Often not reached...
return(PsychError_none);
}
/* Emit a single pixel in top-left corner of window and wait for its rendering
* to complete. Our classic trick to wait for double-buffer swap completion on
* systems where we don't have better system-provided timestamping and syncing
* methods. This needs different implementations on classic OpenGL vs. non-
* immediate mode OpenGL.
*
* A 'flushOnly' flag of TRUE will only flush, not wait.
*
*/
void PsychWaitPixelSyncToken(PsychWindowRecordType *windowRecord, psych_bool flushOnly)
{
// Classic desktop OpenGL in use?
if (PsychIsGLClassic(windowRecord)) {
// Yes. Use our classic fixed-function immediate mode method:
glBegin(GL_POINTS);
glColor4f(0, 0, 0, 0);
glVertex2i(10, 10);
glEnd();
}
else {
// No. Avoid immediate mode functions, they won't work:
GLfloat glverts[2] = { 10, 10 };
glVertexPointer(2, GL_FLOAT, 0, glverts);
glEnableClientState(GL_VERTEX_ARRAY);
glDrawArrays(GL_POINTS, 0, 1);
glDisableClientState(GL_VERTEX_ARRAY);
}
// flushOnly flag - Don't wait for write to happen, just flush it:
if (!flushOnly) {
// Wait for write completion - Used for sync and timestamping:
glFinish();
}
else {
// Only flush:
glFlush();
}
if (flushOnly && (PsychPrefStateGet_Verbosity() > 15)) printf("PTB-DEBUG: PixelSyncToken write + glFlush().\n");
}
/* This callback is called when the pipeline is about to finish playback
* of the current movie stream. If looped playback is enabled, this needs
* to trigger a repetition by rescheduling the movie URI for playback.
*
* Allows gapless playback, but doesn't work reliable on all media types.
*
*/
static void PsychMovieAboutToFinishCB(GstElement *theMovie, gpointer user_data)
{
PsychMovieRecordType* movie = (PsychMovieRecordType*) user_data;
if ((movie->loopflag > 0) && (movie->rate != 0)) {
g_object_set(G_OBJECT(theMovie), "uri", movie->movieLocation, NULL);
if (PsychPrefStateGet_Verbosity() > 4) printf("PTB-DEBUG: About-to-finish received: Rewinding...\n");
}
return;
}
/* PsychOSSetVBLSyncLevel - Enable or disable synchronization of bufferswaps to
* onset of vertical retrace. This is the OS-X version...
*/
void PsychOSSetVBLSyncLevel(PsychWindowRecordType *windowRecord, int swapInterval)
{
CGLError error;
GLint myinterval = (GLint) swapInterval;
psych_bool oldStyle = (PsychPrefStateGet_ConserveVRAM() & kPsychUseOldStyleAsyncFlips) ? TRUE : FALSE;
// Store new setting also in internal helper variable, e.g., to allow workarounds to work:
windowRecord->vSynced = (swapInterval > 0) ? TRUE : FALSE;
error=CGLSetParameter((oldStyle || PsychIsMasterThread()) ? windowRecord->targetSpecific.contextObject : windowRecord->targetSpecific.glswapcontextObject, kCGLCPSwapInterval, &myinterval);
if (error) {
if (PsychPrefStateGet_Verbosity()>1) printf("\nPTB-WARNING: FAILED to %s synchronization to vertical retrace!\n\n", (swapInterval>0) ? "enable" : "disable");
}
error=CGLGetParameter((oldStyle || PsychIsMasterThread()) ? windowRecord->targetSpecific.contextObject : windowRecord->targetSpecific.glswapcontextObject, kCGLCPSwapInterval, &myinterval);
if (error || (myinterval != (GLint) swapInterval)) {
if (PsychPrefStateGet_Verbosity()>1) printf("\nPTB-WARNING: FAILED to %s synchronization to vertical retrace (System ignored setting)!\n\n", (swapInterval>0) ? "enable" : "disable");
}
}
/*
* PsychGSPlaybackRate() - Start- and stop movieplayback, set playback parameters.
*
* moviehandle = Movie to start-/stop.
* playbackrate = zero == Stop playback, non-zero == Play movie with spec. rate,
* e.g., 1 = forward, 2 = double speed forward, -1 = backward, ...
* loop = 0 = Play once. 1 = Loop, aka rewind at end of movie and restart.
* soundvolume = 0 == Mute sound playback, between 0.0 and 1.0 == Set volume to 0 - 100 %.
* Returns Number of dropped frames to keep playback in sync.
*/
int PsychGSPlaybackRate(int moviehandle, double playbackrate, int loop, double soundvolume)
{
int dropped = 0;
GstElement *theMovie = NULL;
if (moviehandle < 0 || moviehandle >= PSYCH_MAX_MOVIES) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided!");
}
// 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 !!!");
}
if (playbackrate != 0) {
// Start playback of movie:
// Set volume and mute state for audio:
g_object_set(G_OBJECT(theMovie), "mute", (soundvolume <= 0) ? TRUE : FALSE, NULL);
g_object_set(G_OBJECT(theMovie), "volume", soundvolume, NULL);
// Set playback rate:
gst_element_seek(theMovie, playbackrate, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE, GST_SEEK_TYPE_NONE, 0, GST_SEEK_TYPE_NONE, 0);
movieRecordBANK[moviehandle].loopflag = loop;
movieRecordBANK[moviehandle].last_pts = -1.0;
movieRecordBANK[moviehandle].nr_droppedframes = 0;
movieRecordBANK[moviehandle].rate = playbackrate;
movieRecordBANK[moviehandle].frameAvail = 0;
movieRecordBANK[moviehandle].preRollAvail = 0;
// Start it:
PsychMoviePipelineSetState(theMovie, GST_STATE_PLAYING, 10.0);
PsychGSProcessMovieContext(movieRecordBANK[moviehandle].MovieContext, FALSE);
}
else {
// Stop playback of movie:
movieRecordBANK[moviehandle].rate = 0;
PsychMoviePipelineSetState(theMovie, GST_STATE_PAUSED, 10.0);
PsychGSProcessMovieContext(movieRecordBANK[moviehandle].MovieContext, FALSE);
// Output count of dropped frames:
if ((dropped=movieRecordBANK[moviehandle].nr_droppedframes) > 0) {
if (PsychPrefStateGet_Verbosity()>2) {
printf("PTB-INFO: Movie playback had to drop %i frames of movie %i to keep playback in sync.\n", movieRecordBANK[moviehandle].nr_droppedframes, moviehandle);
}
}
}
return(dropped);
}
/* Same as PsychOSSetGLContext() but for selecting userspace rendering context,
* optionally copying state from PTBs context.
*/
void PsychOSSetUserGLContext(PsychWindowRecordType *windowRecord, psych_bool copyfromPTBContext)
{
// Child protection:
if (windowRecord->targetSpecific.glusercontextObject == NULL) PsychErrorExitMsg(PsychError_user, "GL Userspace context unavailable! Call InitializeMatlabOpenGL *before* Screen('OpenWindow')!");
if (copyfromPTBContext && (PsychPrefStateGet_Verbosity() > 1)) {
// This was deprecated by the iPhone company as of OSX 10.8 - who are we to question their wisdom? Luckily seldomly needed in practice:
printf("PTB-WARNING: Screen('BeginOpenGL', windowPtr, 2) called to synchronize userspace context state with Screen state. This is unsupported on OSX. Code may misbehave!\n");
}
// Setup new context if it isn't already setup. -> Avoid redundant context switch.
if (CGLGetCurrentContext() != windowRecord->targetSpecific.glusercontextObject) {
CGLSetCurrentContext(windowRecord->targetSpecific.glusercontextObject);
}
}
void PsychOSCloseWindow(PsychWindowRecordType *windowRecord)
{
CGDirectDisplayID cgDisplayID;
// Disable rendering context:
CGLSetCurrentContext(NULL);
// Destroy pixelformat object:
CGLDestroyPixelFormat(windowRecord->targetSpecific.pixelFormatObject);
// Destroy rendering context:
CGLReleaseContext(windowRecord->targetSpecific.contextObject);
if (windowRecord->targetSpecific.glusercontextObject) CGLReleaseContext(windowRecord->targetSpecific.glusercontextObject);
if (windowRecord->targetSpecific.glswapcontextObject) CGLReleaseContext(windowRecord->targetSpecific.glswapcontextObject);
// Last reference to this screen? In that case we have to shutdown the fallback
// vbl timestamping and vblank counting facilities for this screen:
if (screenRefCount[windowRecord->screenNumber] == 1) {
// Last one on this screen will be gone in a second.
// Shutdown and release CVDisplayLink for this windows screen, if any:
if (cvDisplayLink[windowRecord->screenNumber]) {
if (PsychPrefStateGet_Verbosity() > 3) printf("PTB-INFO: Releasing CVDisplayLink for screen %i.\n", windowRecord->screenNumber);
if (CVDisplayLinkIsRunning(cvDisplayLink[windowRecord->screenNumber])) CVDisplayLinkStop(cvDisplayLink[windowRecord->screenNumber]);
PsychYieldIntervalSeconds(0.1);
CVDisplayLinkRelease(cvDisplayLink[windowRecord->screenNumber]);
cvDisplayLink[windowRecord->screenNumber] = NULL;
PsychYieldIntervalSeconds(0.1);
// Teardown shared data structure and mutex:
PsychDestroyMutex(&(cvDisplayLinkData[windowRecord->screenNumber].mutex));
}
}
// Release reference of this window to its screen:
screenRefCount[windowRecord->screenNumber]--;
// Destroy Cocoa onscreen window, if any:
if (windowRecord->targetSpecific.windowHandle) PsychCocoaDisposeWindow(windowRecord);
windowRecord->targetSpecific.windowHandle = NULL;
return;
}
/* 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
}
// Display link callback: Needed so we can actually start the display link:
// Gets apparently called from a separate high-priority thread, close to vblank
// time. "inNow" is the timestamp of last vblank.
static CVReturn PsychCVDisplayLinkOutputCallback(CVDisplayLinkRef displayLink, const CVTimeStamp *inNow, const CVTimeStamp *inOutputTime,
CVOptionFlags flagsIn, CVOptionFlags *flagsOut, void *displayLinkContext)
{
double tVBlank;
CVTimeStamp tVbl;
double tHost;
// Retrieve screenId of associated display screen:
int screenId = (int) (long int) displayLinkContext;
// Extra guard against shutdown races:
if (NULL == cvDisplayLink[screenId]) return(kCVReturnSuccess);
// Translate CoreVideo inNow timestamp with time of last vbl from gpu time
// to host system time, aka our GetSecs() timebase:
memset(&tVbl, 0, sizeof(tVbl));
tVbl.version = 0;
tVbl.flags = kCVTimeStampHostTimeValid;
CVDisplayLinkTranslateTime(displayLink, inNow, &tVbl);
tVBlank = (double) tVbl.hostTime / (double) 1000000000;
// Store timestamp in our shared data structure, also increment virtual vblank counter:
PsychLockMutex(&(cvDisplayLinkData[screenId].mutex));
cvDisplayLinkData[screenId].vblCount++;
cvDisplayLinkData[screenId].vblTimestamp = tVBlank;
PsychUnlockMutex(&(cvDisplayLinkData[screenId].mutex));
// Low-level timestamp debugging requested?
if (PsychPrefStateGet_Verbosity() > 20) {
// Compare CV timestamps against host time for correctness check. We wait 4 msecs,
// then take tHost and hopefully tHost will be at least 4 msecs later than the
// computed vblank timestamp tVBlank:
PsychWaitIntervalSeconds(0.004);
PsychGetAdjustedPrecisionTimerSeconds(&tHost);
// Caution: Don't run from Matlab GUI! This printf will crash Matlab otherwise.
printf("CVCallback: %i : tHost = %lf secs, tVBlank = %lf secs. tHost - tVBlank = %lf secs.\n", screenId, tHost, tVBlank, tHost - tVBlank);
}
return(kCVReturnSuccess);
}
/*
* PsychQTPlaybackRate() - Start- and stop movieplayback, set playback parameters.
*
* moviehandle = Movie to start-/stop.
* playbackrate = zero == Stop playback, non-zero == Play movie with spec. rate,
* e.g., 1 = forward, 2 = double speed forward, -1 = backward, ...
* loop = 0 = Play once. 1 = Loop, aka rewind at end of movie and restart.
* soundvolume = 0 == Mute sound playback, between 0.0 and 1.0 == Set volume to 0 - 100 %.
* Returns Number of dropped frames to keep playback in sync.
*/
int PsychQTPlaybackRate(int moviehandle, double playbackrate, int loop, double soundvolume)
{
int dropped = 0;
Movie theMovie;
if (moviehandle < 0 || moviehandle >= PSYCH_MAX_MOVIES) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided!");
}
// 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 !!!");
}
if (playbackrate != 0) {
// Start playback of movie:
SetMovieAudioMute(theMovie, (soundvolume==0) ? TRUE : FALSE, 0);
SetMovieVolume(theMovie, (short) (soundvolume * 255.0));
movieRecordBANK[moviehandle].loopflag = loop;
movieRecordBANK[moviehandle].last_pts = -1.0;
movieRecordBANK[moviehandle].nr_droppedframes = 0;
SetMoviePreferredRate(theMovie, FloatToFixed(playbackrate));
StartMovie(theMovie);
MoviesTask(theMovie, 10000);
}
else {
// Stop playback of movie:
StopMovie(theMovie);
QTVisualContextTask(movieRecordBANK[moviehandle].QTMovieContext);
// Output count of dropped frames:
if ((dropped=movieRecordBANK[moviehandle].nr_droppedframes) > 0) {
if (PsychPrefStateGet_Verbosity()>2) printf("PTB-INFO: Movie playback had to drop %i frames of movie %i to keep playback in sync.\n", movieRecordBANK[moviehandle].nr_droppedframes, moviehandle);
}
}
return(dropped);
}
/* PsychFixupNative10BitFramebufferEnableAfterEndOfSceneMarker()
*
* Undo changes made by the graphics driver to the framebuffer pixel format control register
* as part of an OpenGL/Graphics op that marks "End of Scene", e.g., a glClear() command, that
* would revert the framebuffers opmode to standard 8bpc mode and thereby kill our 10 bpc mode
* setting.
*
* This routine *must* be called after each such problematic "End of scene" marker command like
* glClear(). The routine does nothing if 10bpc mode is not enabled/requested for the corresponding
* display head associated with the given onscreen window. It rewrites the control register on
* 10 bpc configured windows to basically undo the unwanted change of the gfx-driver *before*
* a vertical retrace cycle starts, ie., before that changes take effect (The register is double-
* buffered and latched to update only at VSYNC time, so we just have to be quick enough).
*
*
* Expected Sequence of operations is:
* 1. Some EOS command like glClear() issued.
* 2. EOS command schedules ctrl register update to "bad" value at next VSYNC.
* 3. This routine gets called, detects need for fixup, glGetError() waits for "2." to finish.
* 4. This routine undos the "bad" value change request by overwriting the latch with our
* "good" value --> Scheduled for next VSYNC. Then it returns...
* 5. At next VSYNC or old "good" value is overwritten/latched with our new old "good" value,
* --> "good value" persists, framebuffer stays in 2101010 configuration --> All good.
*
* So far the theory, let's see if this really works in real world...
*
* This is not needed in Carbon+AGL windowed mode, as the driver doesnt' mess with the control
* register there, but that mode has its own share of drawback, e.g., generally reduced performance
* and less robust stimulus onset timing and timestamping... Life's full of tradeoffs...
*/
void PsychFixupNative10BitFramebufferEnableAfterEndOfSceneMarker(PsychWindowRecordType* windowRecord)
{
#if PSYCH_SYSTEM == PSYCH_OSX || PSYCH_SYSTEM == PSYCH_LINUX
int i,si,ei, headid, screenId;
unsigned int lutreg, ctlreg, value, status;
// Fixup needed? Only if 10bpc mode is supposed to be active! Early exit if not:
if (!(windowRecord->specialflags & kPsychNative10bpcFBActive)) return;
// This command must be called with the OpenGL context of the given windowRecord active, so
// we can rely on glGetError() waiting for the correct pipeline to settle! Wait via glGetError()
// for the end-of-scene marker to finish completely, so our register write happens after
// the "wrong" register write of that command. glFinish() doesn't work here for unknown
// reasons - probably it waits too long or whatever. Pretty shaky this stuff...
glGetError();
// Ok, now rewrite the double-buffered (latched) register with our "good" value for keeping
// the 10 bpc framebuffer online:
// Map windows screen to gfx-headid aka register subset. TODO : We'll need something better,
// more generic, abstracted out for the future, but as a starter this will do:
screenId = windowRecord->screenNumber;
headid = (screenId<=0) ? 0 : 1;
ctlreg = (headid == 0) ? RADEON_D1GRPH_CONTROL : RADEON_D2GRPH_CONTROL;
// One-liner read-modify-write op, which simply sets bit 8 of the register - the "Enable 2101010 mode" bit:
PsychOSKDWriteRegister(screenId, ctlreg, (0x1 << 8) | PsychOSKDReadRegister(screenId, ctlreg, NULL), NULL);
// Debug output, if wanted:
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: PsychFixupNative10BitFramebufferEnableAfterEndOfSceneMarker(): ARGB2101010 bit set on screen %i, head %i.\n", screenId, headid);
#endif
// Done.
return;
}
/* PsychWaitForBufferswapPendingOrFinished()
* Waits until a bufferswap for window windowRecord has either already happened or
* bufferswap is certain.
* Input values:
* windowRecord struct of onscreen window to monitor.
* timestamp = Deadline for abortion of flip detection at input.
*
* Return values:
* timestamp = System time at polling loop exit.
* beamposition = Beamposition at polling loop exit.
*
* Return value: FALSE if swap happened already, TRUE if swap is imminent.
*/
bool PsychWaitForBufferswapPendingOrFinished(PsychWindowRecordType* windowRecord, double* timestamp, int *beamposition)
{
#if PSYCH_SYSTEM == PSYCH_OSX || PSYCH_SYSTEM == PSYCH_LINUX
CGDirectDisplayID displayID;
unsigned int primarySurface, secondarySurface;
unsigned int updateStatus;
double deadline = *timestamp;
// If we are called, we know that 'windowRecord' is an onscreen window.
int screenId = windowRecord->screenNumber;
// Retrieve display id and screen size spec that is needed later...
PsychGetCGDisplayIDFromScreenNumber(&displayID, screenId);
#define RADEON_D1GRPH_UPDATE 0x6144
#define RADEON_D2GRPH_UPDATE 0x6944
#define RADEON_SURFACE_UPDATE_PENDING 4
#define RADEON_SURFACE_UPDATE_TAKEN 8
// Just need to check if GPU low-level access is supported:
if (!PsychOSIsKernelDriverAvailable(screenId)) return;
// Driver is online. Enter polling loop:
while (TRUE) {
// Read surface address registers:
primarySurface = PsychOSKDReadRegister(screenId, (screenId <=0 ) ? RADEON_D1GRPH_PRIMARY_SURFACE_ADDRESS : RADEON_D2GRPH_PRIMARY_SURFACE_ADDRESS, NULL);
secondarySurface = PsychOSKDReadRegister(screenId, (screenId <=0 ) ? RADEON_D1GRPH_SECONDARY_SURFACE_ADDRESS : RADEON_D2GRPH_SECONDARY_SURFACE_ADDRESS, NULL);
// Read update status registers:
updateStatus = PsychOSKDReadRegister(screenId, (screenId <=0 ) ? RADEON_D1GRPH_UPDATE : RADEON_D2GRPH_UPDATE, NULL);
PsychGetAdjustedPrecisionTimerSeconds(timestamp);
if (primarySurface!=windowRecord->gpu_preflip_Surfaces[0] || secondarySurface!=windowRecord->gpu_preflip_Surfaces[1] || (updateStatus & (RADEON_SURFACE_UPDATE_PENDING | RADEON_SURFACE_UPDATE_TAKEN)) || (*timestamp > deadline)) {
// Abort condition: Exit loop.
break;
}
if (PsychPrefStateGet_Verbosity() > 9) {
printf("PTB-DEBUG: Head %i: primarySurface=%p : secondarySurface=%p : updateStatus=%i\n", ((screenId <=0) ? 0:1), primarySurface, secondarySurface, updateStatus);
}
// Sleep 200 microseconds, then retry:
PsychWaitIntervalSeconds(0.0002);
};
// Take timestamp and beamposition:
*beamposition = PsychGetDisplayBeamPosition(&displayID, screenId);
PsychGetAdjustedPrecisionTimerSeconds(timestamp);
// Exit due to timeout?
if (*timestamp > deadline) {
// Mark timestamp as invalid due to timeout:
*timestamp = -1;
}
// Return FALSE if bufferswap happened already, TRUE if swap is still pending:
return((updateStatus & RADEON_SURFACE_UPDATE_PENDING) ? TRUE : FALSE);
#else
// On Windows, we always return "swap happened":
return(FALSE);
#endif
}
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);
}
/* 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 SCREENReadNormalizedGammaTable(void)
{
int i, screenNumber, numEntries, reallutsize, physicalDisplay, outputId;
float *redTable, *greenTable, *blueTable;
double *gammaTable;
//all subfunctions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychErrorExit(PsychCapNumOutputArgs(3));
PsychErrorExit(PsychCapNumInputArgs(2));
// Get optional physicalDisplay argument - It defaults to zero:
physicalDisplay = -1;
PsychCopyInIntegerArg(2, 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;
}
// Retrieve gamma table:
PsychReadNormalizedGammaTable(screenNumber, outputId, &numEntries, &redTable, &greenTable, &blueTable);
// Copy it out to runtime:
PsychAllocOutDoubleMatArg(1, FALSE, numEntries, 3, 0, &gammaTable);
for(i=0;i<numEntries;i++){
gammaTable[PsychIndexElementFrom3DArray(numEntries, 3, 0, i, 0, 0)]=(double)redTable[i];
gammaTable[PsychIndexElementFrom3DArray(numEntries, 3, 0, i, 1, 0)]=(double)greenTable[i];
gammaTable[PsychIndexElementFrom3DArray(numEntries, 3, 0, i, 2, 0)]=(double)blueTable[i];
}
// Copy out optional DAC resolution value:
PsychCopyOutDoubleArg(2, FALSE, (double) PsychGetDacBitsFromDisplay(screenNumber));
// We default to the assumption that the real size of the hardware LUT is identical to
// the size of the returned LUT:
reallutsize = numEntries;
#if PSYCH_SYSTEM == PSYCH_OSX
// On OS-X we query the real LUT size from the OS and return that value:
CGDirectDisplayID displayID;
CFMutableDictionaryRef properties;
CFNumberRef cfGammaLength;
SInt32 lutslotcount;
io_service_t displayService;
kern_return_t kr;
CFMutableArrayRef framebufferTimings0 = 0;
CFDataRef framebufferTimings1 = 0;
IODetailedTimingInformationV2 *framebufferTiming = NULL;
// Retrieve display handle for screen:
PsychGetCGDisplayIDFromScreenNumber(&displayID, screenNumber);
if (PsychPrefStateGet_Verbosity()>5) printf("PTB-DEBUG: Screen %i has framebuffer address %p.\n", screenNumber, CGDisplayBaseAddress(displayID));
// Retrieve low-level IOKit service port for this display:
displayService = CGDisplayIOServicePort(displayID);
// Obtain the properties from that service
kr = IORegistryEntryCreateCFProperties(displayService, &properties, NULL, 0);
if((kr == kIOReturnSuccess) && ((cfGammaLength = (CFNumberRef) CFDictionaryGetValue(properties, CFSTR(kIOFBGammaCountKey)))!=NULL))
{
CFNumberGetValue(cfGammaLength, kCFNumberSInt32Type, &lutslotcount);
CFRelease(properties);
reallutsize = (int) lutslotcount;
}
else {
// Failed!
if (PsychPrefStateGet_Verbosity()>1) printf("PTB-WARNING: Failed to query real size of video LUT for screen %i! Will return safe default of %i slots.\n", screenNumber, reallutsize);
}
if (PsychPrefStateGet_Verbosity()>9) {
CFDictionaryRef currentMode;
CFNumberRef n;
int modeId;
currentMode = CGDisplayCurrentMode(displayID);
n=CFDictionaryGetValue(currentMode, kCGDisplayMode);
CFNumberGetValue(n, kCFNumberIntType, &modeId);
printf("Current mode has id %i\n\n", modeId);
kr = IORegistryEntryCreateCFProperties(displayService, &properties, NULL, 0);
if((kr == kIOReturnSuccess) && ((framebufferTimings0 = (CFMutableArrayRef) CFDictionaryGetValue(properties, CFSTR(kIOFBDetailedTimingsKey) ) )!=NULL))
{
for (i=0; i<CFArrayGetCount(framebufferTimings0); i++) {
if ((framebufferTimings1 = CFArrayGetValueAtIndex(framebufferTimings0, i)) != NULL) {
if ((framebufferTiming = (IODetailedTimingInformationV2*) CFDataGetBytePtr(framebufferTimings1)) != NULL) {
printf("[%i] : VActive = %li, VBL = %li, VSYNC = %li, VSYNCWIDTH = %li , VBORDERBOT = %li, VTOTAL = %li \n", i, framebufferTiming->verticalActive, framebufferTiming->verticalBlanking, framebufferTiming->verticalSyncOffset, framebufferTiming->verticalSyncPulseWidth, framebufferTiming->verticalBorderBottom, framebufferTiming->verticalActive + framebufferTiming->verticalBlanking);
}
}
}
CFRelease(properties);
}
else {
// Failed!
if (PsychPrefStateGet_Verbosity()>1) printf("PTB-WARNING: Failed to query STUFF for screen %i --> %p!\n", screenNumber, properties);
}
}
#endif
// Copy out optional real LUT size (number of slots):
PsychCopyOutDoubleArg(3, FALSE, (double) reallutsize);
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 SCREENDrawDots(void)
{
PsychWindowRecordType *windowRecord, *parentWindowRecord;
int m,n,p,mc,nc,idot_type;
int i, nrpoints, nrsize;
psych_bool isArgThere, usecolorvector, isdoublecolors, isuint8colors;
double *xy, *size, *center, *dot_type, *colors;
float *sizef;
unsigned char *bytecolors;
GLfloat pointsizerange[2];
psych_bool lenient = FALSE;
psych_bool usePointSizeArray = FALSE;
static psych_bool nocando = FALSE;
int oldverbosity;
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
// Check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(7)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(4)); //The maximum number of outputs
// Get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(1, kPsychArgRequired, &windowRecord);
// Get dot_type argument, if any, as it is already needed for a pure point size range query below:
isArgThere = PsychIsArgPresent(PsychArgIn, 6);
if(!isArgThere){
idot_type = 0;
} else {
PsychAllocInDoubleMatArg(6, TRUE, &m, &n, &p, &dot_type);
if(p != 1 || n != 1 || m != 1 || (dot_type[0] < 0 || dot_type[0] > 4))
PsychErrorExitMsg(PsychError_user, "dot_type must be 0, 1, 2, 3 or 4");
idot_type = (int) dot_type[0];
}
// Query for supported point size range?
if (PsychGetNumOutputArgs() > 0) {
PsychSetDrawingTarget(windowRecord);
// Always query and return aliased range:
glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
PsychCopyOutDoubleArg(3, FALSE, (double) pointsizerange[0]);
PsychCopyOutDoubleArg(4, FALSE, (double) pointsizerange[1]);
// If driver supports smooth points and usercode doesn't specify a dot type (idot_type 0)
// or does not request shader + point-sprite based drawing then return smooth point
// size range as "smooth point size range" - query and assign it. Otherwise, ie., code
// explicitely wants to use a shader (idot_type >= 3) or has to use one, we will use
// point-sprites and that means the GL_ALIASED_POINT_SIZE_RANGE limits apply also to
// our shader based smooth dots, so return those:
if ((windowRecord->gfxcaps & kPsychGfxCapSmoothPrimitives) && (idot_type < 3))
glGetFloatv(GL_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
// Whatever the final choice for smooth dots is, return its limits:
PsychCopyOutDoubleArg(1, FALSE, (double) pointsizerange[0]);
PsychCopyOutDoubleArg(2, FALSE, (double) pointsizerange[1]);
// If this was only a query then we are done:
if (PsychGetNumInputArgs() < 2)
return(PsychError_none);
}
// Query, allocate and copy in all vectors...
nrpoints = 2;
nrsize = 0;
colors = NULL;
bytecolors = NULL;
PsychPrepareRenderBatch(windowRecord, 2, &nrpoints, &xy, 4, &nc, &mc, &colors, &bytecolors, 3, &nrsize, &size, (GL_FLOAT == PsychGLFloatType(windowRecord)));
isdoublecolors = (colors) ? TRUE:FALSE;
isuint8colors = (bytecolors) ? TRUE:FALSE;
usecolorvector = (nc>1) ? TRUE:FALSE;
// Assign sizef as float-type array of sizes, if float mode active, NULL otherwise:
sizef = (GL_FLOAT == PsychGLFloatType(windowRecord)) ? (float*) size : NULL;
// Get center argument
isArgThere = PsychIsArgPresent(PsychArgIn, 5);
if(!isArgThere){
center = (double *) PsychMallocTemp(2 * sizeof(double));
center[0] = 0;
center[1] = 0;
} else {
PsychAllocInDoubleMatArg(5, TRUE, &m, &n, &p, ¢er);
if(p!=1 || n!=2 || m!=1) PsychErrorExitMsg(PsychError_user, "center must be a 1-by-2 vector");
}
// Turn on antialiasing to draw circles? Or idot_type 4 for shader based square dots?
if (idot_type) {
// Smooth point rendering supported by gfx-driver and hardware? And user does not request our own stuff?
if ((idot_type == 3) || (idot_type == 4) || !(windowRecord->gfxcaps & kPsychGfxCapSmoothPrimitives)) {
// No. Need to roll our own shader + point sprite solution.
if (!windowRecord->smoothPointShader && !nocando) {
parentWindowRecord = PsychGetParentWindow(windowRecord);
if (!parentWindowRecord->smoothPointShader) {
// Build and assign shader to parent window, but allow this to silently fail:
oldverbosity = PsychPrefStateGet_Verbosity();
PsychPrefStateSet_Verbosity(0);
parentWindowRecord->smoothPointShader = PsychCreateGLSLProgram(PointSmoothFragmentShaderSrc, PointSmoothVertexShaderSrc, NULL);
PsychPrefStateSet_Verbosity(oldverbosity);
}
if (parentWindowRecord->smoothPointShader) {
// Got one compiled - assign it for use:
windowRecord->smoothPointShader = parentWindowRecord->smoothPointShader;
}
else {
// Failed. Record this failure so we can avoid retrying at next DrawDots invocation:
nocando = TRUE;
}
}
if (windowRecord->smoothPointShader) {
// Activate point smooth shader, and point sprite operation on texunit 1 for coordinates on set 1:
PsychSetShader(windowRecord, windowRecord->smoothPointShader);
glActiveTexture(GL_TEXTURE1);
glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
glActiveTexture(GL_TEXTURE0);
glEnable(GL_POINT_SPRITE);
// Tell shader from where to get its color information: Unclamped high precision colors from texture coordinate set 0, or regular colors from vertex color attribute?
glUniform1i(glGetUniformLocation(windowRecord->smoothPointShader, "useUnclampedFragColor"), (windowRecord->defaultDrawShader) ? 1 : 0);
// Tell shader if it should shade smooth round dots, or square dots:
glUniform1i(glGetUniformLocation(windowRecord->smoothPointShader, "drawRoundDots"), (idot_type != 4) ? 1 : 0);
// Tell shader about current point size in pointSize uniform:
glEnable(GL_PROGRAM_POINT_SIZE);
usePointSizeArray = TRUE;
}
else if (idot_type != 4) {
// Game over for round dot drawing:
PsychErrorExitMsg(PsychError_user, "Point smoothing unsupported on your system and our shader based implementation failed as well in Screen('DrawDots').");
}
else {
// Type 4 requested but unsupported. Fallback to type 0, which is the same, just slower:
idot_type = 0;
}
// Request square dots, without anti-aliasing: Better compatibility with
// shader + point sprite operation, and needed for idot_type 0 fallback.
glDisable(GL_POINT_SMOOTH);
glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
}
else {
// User wants hw anti-aliased round smooth dots (idot_type = 1 or 2) and
// hardware + driver support this. Request smooth points from hardware:
glEnable(GL_POINT_SMOOTH);
glGetFloatv(GL_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
// A dot type of 2 requests highest quality point smoothing:
glHint(GL_POINT_SMOOTH_HINT, (idot_type > 1) ? GL_NICEST : GL_DONT_CARE);
}
}
else {
glDisable(GL_POINT_SMOOTH);
glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
}
// Does ES-GPU only support a fixed point diameter of 1 pixel?
if ((pointsizerange[1] <= 1) && PsychIsGLES(windowRecord)) {
// Yes. Not much point bailing on this, as it should be easily visible
// during testing of a studies code on a OpenGL-ES device.
lenient = TRUE;
}
// Accept optional 'lenient' flag, if provided:
PsychCopyInFlagArg(7, FALSE, &lenient);
// Set size of a single dot:
if (!lenient && ((sizef && (sizef[0] > pointsizerange[1] || sizef[0] < pointsizerange[0])) ||
(!sizef && (size[0] > pointsizerange[1] || size[0] < pointsizerange[0])))) {
printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n",
(sizef) ? sizef[0] : size[0], pointsizerange[0], pointsizerange[1]);
PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots').");
}
// Setup initial common point size for all points:
if (!usePointSizeArray) glPointSize((sizef) ? sizef[0] : (float) size[0]);
if (usePointSizeArray) glMultiTexCoord1f(GL_TEXTURE2, (sizef) ? sizef[0] : (float) size[0]);
// Setup modelview matrix to perform translation by 'center':
glMatrixMode(GL_MODELVIEW);
// Make a backup copy of the matrix:
glPushMatrix();
// Apply a global translation of (center(x,y)) pixels to all following points:
glTranslatef((float) center[0], (float) center[1], 0);
// Render the array of 2D-Points - Efficient version:
// This command sequence allows fast processing of whole arrays
// of vertices (or points, in this case). It saves the call overhead
// associated with the original implementation below and is potentially
// optimized in specific OpenGL implementations.
// Pass a pointer to the start of the point-coordinate array:
glVertexPointer(2, PSYCHGLFLOAT, 0, &xy[0]);
// Enable fast rendering of arrays:
glEnableClientState(GL_VERTEX_ARRAY);
if (usecolorvector) {
PsychSetupVertexColorArrays(windowRecord, TRUE, mc, colors, bytecolors);
}
// Render all n points, starting at point 0, render them as POINTS:
if ((nrsize == 1) || usePointSizeArray) {
// Only one common size provided, or efficient shader based
// path in use. We can use the fast path of only submitting
// one glDrawArrays call to draw all GL_POINTS. For a single
// common size, no further setup is needed.
if (nrsize > 1) {
// Individual size for each dot provided. Setup texture unit 2
// with a 1D texcoord array that stores per point size info in
// texture coordinate set 2. But first validate point sizes:
for (i = 0; i < nrpoints; i++) {
if (!lenient && ((sizef && (sizef[i] > pointsizerange[1] || sizef[i] < pointsizerange[0])) ||
(!sizef && (size[i] > pointsizerange[1] || size[i] < pointsizerange[0])))) {
printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n",
(sizef) ? sizef[i] : size[i], pointsizerange[0], pointsizerange[1]);
PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots').");
}
}
// Sizes are fine, setup texunit 2:
glClientActiveTexture(GL_TEXTURE2);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(1, (sizef) ? GL_FLOAT : GL_DOUBLE, 0, (sizef) ? (const GLvoid*) sizef : (const GLvoid*) size);
}
// Draw all points:
glDrawArrays(GL_POINTS, 0, nrpoints);
if (nrsize > 1) {
// Individual size for each dot provided. Reset texture unit 2:
glTexCoordPointer(1, (sizef) ? GL_FLOAT : GL_DOUBLE, 0, (const GLvoid*) NULL);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// Back to default texunit 0:
glClientActiveTexture(GL_TEXTURE0);
}
}
else {
// Different size for each dot provided and we can't use our shader based implementation:
// We have to do One GL - call per dot:
for (i=0; i<nrpoints; i++) {
if (!lenient && ((sizef && (sizef[i] > pointsizerange[1] || sizef[i] < pointsizerange[0])) ||
(!sizef && (size[i] > pointsizerange[1] || size[i] < pointsizerange[0])))) {
printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n",
(sizef) ? sizef[i] : size[i], pointsizerange[0], pointsizerange[1]);
PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots').");
}
// Setup point size for this point:
if (!usePointSizeArray) glPointSize((sizef) ? sizef[i] : (float) size[i]);
// Render point:
glDrawArrays(GL_POINTS, i, 1);
}
}
// Disable fast rendering of arrays:
glDisableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, PSYCHGLFLOAT, 0, NULL);
if (usecolorvector) PsychSetupVertexColorArrays(windowRecord, FALSE, 0, NULL, NULL);
// Restore old matrix from backup copy, undoing the global translation:
glPopMatrix();
// turn off antialiasing again
if (idot_type) {
glDisable(GL_POINT_SMOOTH);
if (windowRecord->smoothPointShader) {
// Deactivate point smooth shader and point sprite operation on texunit 1:
PsychSetShader(windowRecord, 0);
glActiveTexture(GL_TEXTURE1);
glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_FALSE);
glActiveTexture(GL_TEXTURE0);
glDisable(GL_POINT_SPRITE);
glDisable(GL_PROGRAM_POINT_SIZE);
}
}
// Reset pointsize to 1.0
glPointSize(1);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
//All psychfunctions require this.
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 SCREENPreference(void)
{
PsychArgFormatType arg1Type;
char *preferenceName, *newFontName;
const char *tableCreator, *oldDefaultFontName;
psych_bool preferenceNameArgumentValid, booleanInput, ignoreCase, tempFlag, textAlphaBlendingFlag, suppressAllWarningsFlag;
int numInputArgs, i, newFontStyleNumber, newFontSize, tempInt, tempInt2, tempInt3, tempInt4;
double returnDoubleValue, inputDoubleValue;
double maxStddev, maxDeviation, maxDuration;
int minSamples;
double *dheads = NULL;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for superfluous or missing arguments
PsychErrorExit(PsychCapNumInputArgs(5));
PsychErrorExit(PsychRequireNumInputArgs(1));
PsychErrorExit(PsychCapNumOutputArgs(4));
numInputArgs=PsychGetNumInputArgs();
arg1Type=PsychGetArgType(1);
preferenceNameArgumentValid=FALSE;
//Cases which require both a window pointer or screen number and preference name. Argument 1 is the wposn and argument 2 is the preference name.
if( numInputArgs >= 2 && (PsychIsScreenNumberArg(1) || PsychIsScreenNumberArg(1)) && PsychGetArgType(2)==PsychArgType_char ){
PsychAllocInCharArg(2, kPsychArgRequired, &preferenceName);
//preferences which require window pointer or screen number argument which we DO NOT support
for(i=0;i<kPsychNumUnsupportedMacVideoPreferences;i++){
if(PsychMatch(preferenceName, unsupportedMacVideoPreferenceNames[i]))
PsychErrorExit(PsychError_unsupportedOS9Preference);
}
//insert here conditionals to act on prefernces which accept a window pointer or screen number argument which we DO support.
PsychErrorExit(PsychError_unrecognizedPreferenceName);
}
//Cases which do not require a wposn. Argument 1 is the preference name. if present Argument 2 is the new value
if(arg1Type==PsychArgType_char){
PsychAllocInCharArg(1, kPsychArgRequired, &preferenceName);
//Preferernces which we do not support and which do not require a wposn
for(i=0;i<kPsychNumUnsupportedMacNonVideoPreferences;i++){
if(PsychMatch(preferenceName, unsupportedMacNonVideoPreferenceNames[i]))
PsychErrorExit(PsychError_unsupportedOS9Preference);
}
//Preferences which we do support
if(PsychMatch(preferenceName, "IgnoreCase")){
ignoreCase=!PsychIsPsychMatchCaseSensitive();
PsychCopyOutFlagArg(1, kPsychArgOptional, ignoreCase);
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &booleanInput);
PsychSetPsychMatchCaseSenstive(!booleanInput);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "Tick0Secs")){
if(PsychCopyInDoubleArg(2, kPsychArgOptional, &inputDoubleValue) && inputDoubleValue==PsychGetNanValue())
PsychEstimateGetSecsValueAtTickCountZero();
returnDoubleValue=PsychGetEstimatedSecsValueAtTickCountZero();
PsychCopyOutDoubleArg(1, kPsychArgOptional, returnDoubleValue);
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "PsychTableVersion")){
if(numInputArgs==2)
PsychErrorExit(PsychError_extraInputArg);
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double)PsychPrefStateGet_PsychTableVersion());
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "PsychTableCreator")){
if(numInputArgs==2)
PsychErrorExit(PsychError_extraInputArg);
tableCreator=PsychPrefStateGet_PsychTableCreator();
PsychCopyOutCharArg(1, kPsychArgOptional, tableCreator);
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "Process")){
if(numInputArgs==2)
PsychErrorExit(PsychError_extraInputArg);
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double) (psych_int64) getpid());
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultFontName")){
PsychPrefStateGet_DefaultFontName(&oldDefaultFontName);
PsychCopyOutCharArg(1, kPsychArgOptional, oldDefaultFontName);
if(numInputArgs==2){
PsychAllocInCharArg(2, kPsychArgRequired, &newFontName);
PsychPrefStateSet_DefaultFontName(newFontName);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "TextEncodingLocale")){
PsychCopyOutCharArg(1, kPsychArgOptional, PsychGetUnicodeTextConversionLocale());
if(numInputArgs==2){
PsychAllocInCharArg(2, kPsychArgRequired, &newFontName);
if (!PsychSetUnicodeTextConversionLocale(newFontName)) PsychErrorExitMsg(PsychError_user, "Setting the 'TextEncodingLocale' failed, most likely because you provided an invalid/unknown locale setting string.");
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultFontStyle")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_DefaultTextStyle());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &newFontStyleNumber);
PsychPrefStateSet_DefaultTextStyle(newFontStyleNumber);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "OverrideMultimediaEngine")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_UseGStreamer());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_UseGStreamer(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultTextYPositionIsBaseline")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_TextYPositionIsBaseline());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_TextYPositionIsBaseline(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "TextAntiAliasing")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_TextAntiAliasing());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_TextAntiAliasing(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "TextRenderer")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_TextRenderer());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_TextRenderer(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultFontSize")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_DefaultTextSize());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &newFontSize);
PsychPrefStateSet_DefaultTextSize(newFontSize);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DebugMakeTexture")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_DebugMakeTexture());
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &tempFlag);
PsychPrefStateSet_DebugMakeTexture(tempFlag);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "SkipSyncTests")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_SkipSyncTests());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_SkipSyncTests(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "VisualDebugLevel")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_VisualDebugLevel());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_VisualDebugLevel(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "VBLTimestampingMode")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_VBLTimestampingMode());
if(numInputArgs>=2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_VBLTimestampingMode(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "SyncTestSettings")){
PsychPrefStateGet_SynctestThresholds(&maxStddev, &minSamples, &maxDeviation, &maxDuration);
PsychCopyOutDoubleArg(1, kPsychArgOptional, maxStddev);
PsychCopyOutDoubleArg(2, kPsychArgOptional, minSamples);
PsychCopyOutDoubleArg(3, kPsychArgOptional, maxDeviation);
PsychCopyOutDoubleArg(4, kPsychArgOptional, maxDuration);
if(numInputArgs>=2){
PsychCopyInDoubleArg( 2, kPsychArgOptional, &maxStddev);
PsychCopyInIntegerArg(3, kPsychArgOptional, &minSamples);
PsychCopyInDoubleArg( 4, kPsychArgOptional, &maxDeviation);
PsychCopyInDoubleArg( 5, kPsychArgOptional, &maxDuration);
PsychPrefStateSet_SynctestThresholds(maxStddev, minSamples, maxDeviation, maxDuration);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "VBLEndlineOverride")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_VBLEndlineOverride());
if(numInputArgs>=2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_VBLEndlineOverride(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultVideocaptureEngine")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_VideoCaptureEngine());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_VideoCaptureEngine(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "WindowShieldingLevel")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_WindowShieldingLevel());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_WindowShieldingLevel(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "ConserveVRAM") || PsychMatch(preferenceName, "Workarounds1")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_ConserveVRAM());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_ConserveVRAM(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "Verbosity")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_Verbosity());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_Verbosity(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "FrameRectCorrection")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_FrameRectCorrection());
if(numInputArgs==2){
PsychCopyInDoubleArg(2, kPsychArgRequired, &inputDoubleValue);
PsychPrefStateSet_FrameRectCorrection(inputDoubleValue);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "EmulateOldPTB")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_EmulateOldPTB());
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &tempFlag);
PsychPrefStateSet_EmulateOldPTB(tempFlag);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "Enable3DGraphics")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_3DGfx());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_3DGfx(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "TextAlphaBlending")){
textAlphaBlendingFlag=PsychPrefStateGet_TextAlphaBlending();
PsychCopyOutFlagArg(1, kPsychArgOptional, textAlphaBlendingFlag);
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &booleanInput);
PsychPrefStateSet_TextAlphaBlending(booleanInput);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "SuppressAllWarnings")){
suppressAllWarningsFlag=PsychPrefStateGet_SuppressAllWarnings();
PsychCopyOutFlagArg(1, kPsychArgOptional, suppressAllWarningsFlag);
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &booleanInput);
PsychPrefStateSet_SuppressAllWarnings(booleanInput);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "SynchronizeDisplays")){
if(numInputArgs >= 2) {
// This is a special call: It currently doesn't set a preference setting,
// but instead triggers an instantaneous synchronization of all available
// display heads, if possible. We may have a more clever and "standard" interface
// interface for this later on, but for first tests this will do.
// Syncmethod is hard-coded to 0 -> Use whatever's available to sync.
// timeout for retries is 5.0 seconds.
// Acceptable residual offset is +/- 2 scanlines.
// Returns the real residual offset after sync.
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
if (!PsychCopyInIntegerArg(3, kPsychArgOptional, &tempInt3)) {
// No screenId specified: Resync default screen or whatever...
tempInt2 = 0;
if (PsychSynchronizeDisplayScreens(&tempInt2, NULL, &tempInt, tempInt, 5.0, 2)!=PsychError_none) PsychErrorExitMsg(PsychError_user, "Sync failed for reasons mentioned above.");
} else {
// Specific screenId provided: Resync crtc's associated with this screenId if possible:
tempInt2 = 1;
if (PsychSynchronizeDisplayScreens(&tempInt2, &tempInt3, &tempInt, tempInt, 5.0, 2)!=PsychError_none) PsychErrorExitMsg(PsychError_user, "Sync failed for reasons mentioned above.");
}
PsychCopyOutDoubleArg(1, kPsychArgOptional, tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "ScreenToHead")){
// screenId is required:
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
if (tempInt < 0 || tempInt >= PsychGetNumDisplays() || tempInt >= kPsychMaxPossibleDisplays) PsychErrorExitMsg(PsychError_user, "Invalid screenId provided. Out of valid range!");
// Return old mappings for this screenId:
for (tempInt2 = 0; (tempInt2 < kPsychMaxPossibleCrtcs) && (PsychPrefStateGet_ScreenToHead(tempInt, tempInt2) >= 0); tempInt2++);
PsychAllocOutDoubleMatArg(1, kPsychArgOptional, 2, tempInt2, 1, &dheads);
tempInt4 = 0;
for (tempInt3 = 0; tempInt3 < tempInt2; tempInt3++) {
dheads[tempInt4++] = (double) PsychPrefStateGet_ScreenToHead(tempInt, tempInt3);
dheads[tempInt4++] = (double) PsychPrefStateGet_ScreenToCrtcId(tempInt, tempInt3);
}
// Optionally retrieve and set new mappings for this screenId:
if(numInputArgs>=3) {
// Set new headId for screenId:
PsychCopyInIntegerArg(3, kPsychArgRequired, &tempInt2);
if (tempInt2 < 0) PsychErrorExitMsg(PsychError_user, "Invalid negative headId provided!");
// Set new crtcId for screenId:
PsychCopyInIntegerArg(4, kPsychArgRequired, &tempInt3);
if (tempInt3 < 0) PsychErrorExitMsg(PsychError_user, "Invalid negative crtcId provided!");
// Assign primary head by default (index 0), but allow optionally others as well:
tempInt4 = 0;
PsychCopyInIntegerArg(5, kPsychArgOptional, &tempInt4);
if (tempInt4 < 0 || tempInt4 >= kPsychMaxPossibleCrtcs) PsychErrorExitMsg(PsychError_user, "Invalid rankId provided! Too many heads for one screen!");
PsychPrefStateSet_ScreenToHead(tempInt, tempInt2, tempInt3, tempInt4);
}
preferenceNameArgumentValid=TRUE;
}else
PsychErrorExit(PsychError_unrecognizedPreferenceName);
}
if(!preferenceNameArgumentValid)
PsychErrorExitMsg(PsychError_user, "Invalid arguments to preferences command");
return(PsychError_none);
}
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);
}
PsychError SCREENMakeTexture(void)
{
size_t ix, iters;
PsychWindowRecordType *textureRecord;
PsychWindowRecordType *windowRecord;
PsychRectType rect;
psych_bool isImageMatrixBytes, isImageMatrixDoubles;
int numMatrixPlanes, xSize, ySize;
unsigned char *byteMatrix;
double *doubleMatrix;
GLuint *texturePointer;
GLubyte *texturePointer_b;
GLfloat *texturePointer_f;
double *rp, *gp, *bp, *ap;
GLubyte *rpb, *gpb, *bpb, *apb;
int usepoweroftwo, usefloatformat, assume_texorientation, textureShader;
double optimized_orientation;
psych_bool bigendian;
psych_bool planar_storage = FALSE;
// Detect endianity (byte-order) of machine:
ix=255;
rpb=(GLubyte*) &ix;
bigendian = ( *rpb == 255 ) ? FALSE : TRUE;
ix = 0; rpb = NULL;
if(PsychPrefStateGet_DebugMakeTexture()) //MARK #1
StoreNowTime();
//all subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//Get the window structure for the onscreen window. It holds the onscreein GL context which we will need in the
//final step when we copy the texture from system RAM onto the screen.
PsychErrorExit(PsychCapNumInputArgs(7));
PsychErrorExit(PsychRequireNumInputArgs(2));
PsychErrorExit(PsychCapNumOutputArgs(1));
//get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
if((windowRecord->windowType!=kPsychDoubleBufferOnscreen) && (windowRecord->windowType!=kPsychSingleBufferOnscreen))
PsychErrorExitMsg(PsychError_user, "MakeTexture called on something else than a onscreen window");
// Get optional texture orientation flag:
assume_texorientation = 0;
PsychCopyInIntegerArg(6, FALSE, &assume_texorientation);
// Get optional texture shader handle:
textureShader = 0;
PsychCopyInIntegerArg(7, FALSE, &textureShader);
//get the argument and sanity check it.
isImageMatrixBytes=PsychAllocInUnsignedByteMatArg(2, kPsychArgAnything, &ySize, &xSize, &numMatrixPlanes, &byteMatrix);
isImageMatrixDoubles=PsychAllocInDoubleMatArg(2, kPsychArgAnything, &ySize, &xSize, &numMatrixPlanes, &doubleMatrix);
if(numMatrixPlanes > 4)
PsychErrorExitMsg(PsychError_inputMatrixIllegalDimensionSize, "Specified image matrix exceeds maximum depth of 4 layers");
if(ySize<1 || xSize <1)
PsychErrorExitMsg(PsychError_inputMatrixIllegalDimensionSize, "Specified image matrix must be at least 1 x 1 pixels in size");
if(! (isImageMatrixBytes || isImageMatrixDoubles))
PsychErrorExitMsg(PsychError_user, "Illegal argument type"); //not likely.
// Is this a special image matrix which is already pre-transposed to fit our optimal format?
if (assume_texorientation == 2) {
// Yes. Swap xSize and ySize to take this into account:
ix = (size_t) xSize;
xSize = ySize;
ySize = (int) ix;
ix = 0;
}
// Build defining rect for this texture:
PsychMakeRect(rect, 0, 0, xSize, ySize);
// Copy in texture preferred draw orientation hint. We default to zero degrees, if
// not provided.
// This parameter is not yet used. It is silently ignorerd for now...
optimized_orientation = 0;
PsychCopyInDoubleArg(3, FALSE, &optimized_orientation);
// Copy in special creation mode flag: It defaults to zero. If set to 1 then we
// always create a power-of-two GL_TEXTURE_2D texture. This is useful if one wants
// to create and use drifting gratings with no effort - texture wrapping is only available
// for GL_TEXTURE_2D, not for non-pot types. It is also useful if the texture is to be
// exported to external OpenGL code to simplify tex coords assignments.
usepoweroftwo=0;
PsychCopyInIntegerArg(4, FALSE, &usepoweroftwo);
// Check if size constraints are fullfilled for power-of-two mode:
if (usepoweroftwo & 1) {
for(ix = 1; ix < (size_t) xSize; ix*=2);
if (ix != (size_t) xSize) {
PsychErrorExitMsg(PsychError_inputMatrixIllegalDimensionSize, "Power-of-two texture requested but width of imageMatrix is not a power of two!");
}
for(ix = 1; ix < (size_t) ySize; ix*=2);
if (ix != (size_t) ySize) {
PsychErrorExitMsg(PsychError_inputMatrixIllegalDimensionSize, "Power-of-two texture requested but height of imageMatrix is not a power of two!");
}
}
// Check if creation of a floating point texture is requested? We default to non-floating point,
// standard 8 bpc textures if this parameter is not provided.
usefloatformat = 0;
PsychCopyInIntegerArg(5, FALSE, &usefloatformat);
if (usefloatformat<0 || usefloatformat>2) PsychErrorExitMsg(PsychError_user, "Invalid value for 'floatprecision' parameter provided! Valid values are 0 for 8bpc int, 1 for 16bpc float or 2 for 32bpc float.");
if (usefloatformat && !isImageMatrixDoubles) {
// Floating point texture requested. We only support this if our input is a double matrix, not
// for uint8 matrices - converting them to float precision would be just a waste of ressources
// without any benefit for precision.
PsychErrorExitMsg(PsychError_user, "Creation of a floating point precision texture requested, but uint8 matrix provided! Only double matrices are acceptable for this mode.");
}
//Create a texture record. Really just a window record adapted for textures.
PsychCreateWindowRecord(&textureRecord); //this also fills the window index field.
textureRecord->windowType=kPsychTexture;
// MK: We need to assign the screen number of the onscreen-window, so PsychCreateTexture()
// can query the size of the screen/onscreen-window...
textureRecord->screenNumber=windowRecord->screenNumber;
textureRecord->depth=32;
PsychCopyRect(textureRecord->rect, rect);
// Is texture storage in planar format explicitely requested by usercode? Do the gpu and its size
// constraints on textures support planar storage for this image?
// Can a proper planar -> interleaved remapping GLSL shader be generated and assigned for this texture?
if ((usepoweroftwo == 4) && (numMatrixPlanes > 1) && (windowRecord->gfxcaps & kPsychGfxCapFBO) && !(PsychPrefStateGet_ConserveVRAM() & kPsychDontCacheTextures) &&
(ySize * numMatrixPlanes <= windowRecord->maxTextureSize) && PsychAssignPlanarTextureShaders(textureRecord, windowRecord, numMatrixPlanes)) {
// Yes: Use the planar texture storage fast-path.
planar_storage = TRUE;
if (PsychPrefStateGet_Verbosity() > 6) printf("PTB-DEBUG: Using planar storage for %i layer texture of size %i x %i texels.\n", numMatrixPlanes, xSize, ySize);
}
else {
planar_storage = FALSE;
if (PsychPrefStateGet_Verbosity() > 7) printf("PTB-DEBUG: Using standard storage for %i layer texture of size %i x %i texels.\n", numMatrixPlanes, xSize, ySize);
}
//Allocate the texture memory and copy the MATLAB matrix into the texture memory.
if (usefloatformat || (planar_storage && !isImageMatrixBytes)) {
// Allocate a double for each color component and pixel:
textureRecord->textureMemorySizeBytes = sizeof(double) * (size_t) numMatrixPlanes * (size_t) xSize * (size_t) ySize;
}
else {
// Allocate one byte per color component and pixel:
textureRecord->textureMemorySizeBytes = (size_t) numMatrixPlanes * (size_t) xSize * (size_t) ySize;
}
// We allocate our own intermediate conversion buffer unless this is
// creation of a single-layer luminance8 integer texture from a single
// layer uint8 input matrix and client storage is disabled. In that case, we can use a zero-copy path:
if ((isImageMatrixBytes && (numMatrixPlanes == 1) && (!usefloatformat) && !(PsychPrefStateGet_ConserveVRAM() & kPsychDontCacheTextures)) ||
(isImageMatrixBytes && planar_storage)) {
// Zero copy path:
texturePointer = NULL;
}
else {
// Allocate memory:
if(PsychPrefStateGet_DebugMakeTexture()) StoreNowTime();
textureRecord->textureMemory = malloc(textureRecord->textureMemorySizeBytes);
if(PsychPrefStateGet_DebugMakeTexture()) StoreNowTime();
texturePointer = textureRecord->textureMemory;
}
// Does script explicitely request usage of a GL_TEXTURE_2D power-of-two texture?
if (usepoweroftwo & 1) {
// Enforce creation as a power-of-two texture:
textureRecord->texturetarget=GL_TEXTURE_2D;
}
// Now the conversion routines that convert Matlab/Octave matrices into memory
// buffers suitable for OpenGL:
if (planar_storage) {
// Planar texture storage, backed by a LUMINANCE texture container:
// Zero-Copy possible? Only for uint8 input -> uint8 output:
if (texturePointer == NULL) {
texturePointer = (GLuint*) byteMatrix;
textureRecord->textureMemory = texturePointer;
// Set size to zero, so PsychCreateTexture() does not free() our
// input buffer:
textureRecord->textureMemorySizeBytes = 0;
// This is always a LUMINANCE8 texture, backing our planar uint8 texture:
textureRecord->depth = 8 * numMatrixPlanes;
textureRecord->textureexternaltype = GL_UNSIGNED_BYTE;
textureRecord->textureexternalformat = GL_LUMINANCE;
textureRecord->textureinternalformat = GL_LUMINANCE8;
}
else {
// Some cast operation needed from double input format.
// We always cast from double to float, potentially with
// normalization and/or checking of value range.
textureRecord->textureexternalformat = GL_LUMINANCE;
if (usefloatformat) {
// Floating point or other high precision format:
textureRecord->depth = ((usefloatformat == 1) ? 16 : 32) * numMatrixPlanes;
textureRecord->textureexternaltype = GL_FLOAT;
textureRecord->textureinternalformat = (usefloatformat == 1) ? GL_LUMINANCE_FLOAT16_APPLE : GL_LUMINANCE_FLOAT32_APPLE;
// Override for missing floating point texture support: Try to use 16 bit fixed point signed normalized textures [-1.0 ; 1.0] resolved at 15 bits:
if ((usefloatformat == 1) && !(windowRecord->gfxcaps & kPsychGfxCapFPTex16)) textureRecord->textureinternalformat = GL_LUMINANCE16_SNORM;
// Perform copy with double -> float cast:
iters = (size_t) xSize * (size_t) ySize * (size_t) numMatrixPlanes;
texturePointer_f = (GLfloat*) texturePointer;
for(ix = 0; ix < iters; ix++) {
*(texturePointer_f++) = (GLfloat) *(doubleMatrix++);
}
iters = (size_t) xSize * (size_t) ySize;
}
else {
// 8 Bit format, but from double input matrix -> cast to uint8:
textureRecord->depth = 8 * numMatrixPlanes;
textureRecord->textureexternaltype = GL_UNSIGNED_BYTE;
textureRecord->textureinternalformat = GL_LUMINANCE8;
iters = (size_t) xSize * (size_t) ySize * (size_t) numMatrixPlanes;
texturePointer_b = (GLubyte*) texturePointer;
for(ix = 0; ix < iters; ix++) {
*(texturePointer_b++) = (GLubyte) *(doubleMatrix++);
}
iters = (size_t) xSize * (size_t) ySize;
}
}
}
else if (usefloatformat) {
// Conversion routines for HDR 16 bpc or 32 bpc textures -- Slow path.
// Our input is always double matrices...
iters = (size_t) xSize * (size_t) ySize;
// Our input buffer is always of GL_FLOAT precision:
textureRecord->textureexternaltype = GL_FLOAT;
texturePointer_f=(GLfloat*) texturePointer;
if(numMatrixPlanes==1) {
for(ix=0;ix<iters;ix++){
*(texturePointer_f++)= (GLfloat) *(doubleMatrix++);
}
textureRecord->depth=(usefloatformat==1) ? 16 : 32;
textureRecord->textureinternalformat = (usefloatformat==1) ? GL_LUMINANCE_FLOAT16_APPLE : GL_LUMINANCE_FLOAT32_APPLE;
textureRecord->textureexternalformat = GL_LUMINANCE;
// Override for missing floating point texture support: Try to use 16 bit fixed point signed normalized textures [-1.0 ; 1.0] resolved at 15 bits:
if ((usefloatformat==1) && !(windowRecord->gfxcaps & kPsychGfxCapFPTex16)) textureRecord->textureinternalformat = GL_LUMINANCE16_SNORM;
}
if(numMatrixPlanes==2) {
rp=(double*) ((size_t) doubleMatrix);
ap=(double*) ((size_t) rp + (size_t) iters * sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_f++)= (GLfloat) *(rp++);
*(texturePointer_f++)= (GLfloat) *(ap++);
}
textureRecord->depth=(usefloatformat==1) ? 32 : 64;
textureRecord->textureinternalformat = (usefloatformat==1) ? GL_LUMINANCE_ALPHA_FLOAT16_APPLE : GL_LUMINANCE_ALPHA_FLOAT32_APPLE;
textureRecord->textureexternalformat = GL_LUMINANCE_ALPHA;
// Override for missing floating point texture support: Try to use 16 bit fixed point signed normalized textures [-1.0 ; 1.0] resolved at 15 bits:
if ((usefloatformat==1) && !(windowRecord->gfxcaps & kPsychGfxCapFPTex16)) textureRecord->textureinternalformat = GL_LUMINANCE16_ALPHA16_SNORM;
}
if(numMatrixPlanes==3) {
rp=(double*) ((size_t) doubleMatrix);
gp=(double*) ((size_t) rp + (size_t) iters * sizeof(double));
bp=(double*) ((size_t) gp + (size_t) iters * sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_f++)= (GLfloat) *(rp++);
*(texturePointer_f++)= (GLfloat) *(gp++);
*(texturePointer_f++)= (GLfloat) *(bp++);
}
textureRecord->depth=(usefloatformat==1) ? 48 : 96;
textureRecord->textureinternalformat = (usefloatformat==1) ? GL_RGB_FLOAT16_APPLE : GL_RGB_FLOAT32_APPLE;
textureRecord->textureexternalformat = GL_RGB;
// Override for missing floating point texture support: Try to use 16 bit fixed point signed normalized textures [-1.0 ; 1.0] resolved at 15 bits:
if ((usefloatformat==1) && !(windowRecord->gfxcaps & kPsychGfxCapFPTex16)) textureRecord->textureinternalformat = GL_RGB16_SNORM;
}
if(numMatrixPlanes==4) {
rp=(double*) ((size_t) doubleMatrix);
gp=(double*) ((size_t) rp + (size_t) iters * sizeof(double));
bp=(double*) ((size_t) gp + (size_t) iters * sizeof(double));
ap=(double*) ((size_t) bp + (size_t) iters * sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_f++)= (GLfloat) *(rp++);
*(texturePointer_f++)= (GLfloat) *(gp++);
*(texturePointer_f++)= (GLfloat) *(bp++);
*(texturePointer_f++)= (GLfloat) *(ap++);
}
textureRecord->depth=(usefloatformat==1) ? 64 : 128;
textureRecord->textureinternalformat = (usefloatformat==1) ? GL_RGBA_FLOAT16_APPLE : GL_RGBA_FLOAT32_APPLE;
textureRecord->textureexternalformat = GL_RGBA;
// Override for missing floating point texture support: Try to use 16 bit fixed point signed normalized textures [-1.0 ; 1.0] resolved at 15 bits:
if ((usefloatformat==1) && !(windowRecord->gfxcaps & kPsychGfxCapFPTex16)) textureRecord->textureinternalformat = GL_RGBA16_SNORM;
}
// End of HDR conversion code...
}
else {
// Standard LDR texture 8 bpc conversion routines -- Fast path.
iters = (size_t) xSize * (size_t) ySize;
// Improved implementation: Takes 13 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==1){
texturePointer_b=(GLubyte*) texturePointer;
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(doubleMatrix++);
}
textureRecord->depth=8;
}
// Improved version: Takes 3 ms on a 800x800 texture...
// NB: Implementing memcpy manually by a for-loop takes 10 ms! This is a huge difference.
// -> That's because memcpy on MacOS-X is implemented with hand-coded, highly tuned Assembler code for PowerPC.
// -> It's always wise to use system-routines if available, instead of coding it by yourself!
if(isImageMatrixBytes && numMatrixPlanes==1) {
if (texturePointer) {
// Need to do a copy. Use optimized memcpy():
memcpy((void*) texturePointer, (void*) byteMatrix, iters);
//texturePointer_b=(GLubyte*) texturePointer;
//for(ix=0;ix<iters;ix++){
// *(texturePointer_b++) = *(byteMatrix++);
//}
}
else {
// Zero-Copy path. Just pass a pointer to our input matrix:
texturePointer = (GLuint*) byteMatrix;
textureRecord->textureMemory = texturePointer;
// Set size to zero, so PsychCreateTexture() does not free() our
// input buffer:
textureRecord->textureMemorySizeBytes = 0;
}
textureRecord->depth=8;
}
// New version: Takes 33 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==2){
texturePointer_b=(GLubyte*) texturePointer;
rp=(double*) ((size_t) doubleMatrix);
ap=(double*) ((size_t) rp + (size_t) iters * sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(ap++);
}
textureRecord->depth=16;
}
// New version: Takes 20 ms on a 800x800 texture...
if(isImageMatrixBytes && numMatrixPlanes==2){
texturePointer_b=(GLubyte*) texturePointer;
rpb=(GLubyte*) ((size_t) byteMatrix);
apb=(GLubyte*) ((size_t) rpb + (size_t) iters);
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(rpb++);
*(texturePointer_b++)= *(apb++);
}
textureRecord->depth=16;
}
// Improved version: Takes 43 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==3){
texturePointer_b=(GLubyte*) texturePointer;
rp=(double*) ((size_t) doubleMatrix);
gp=(double*) ((size_t) rp + (size_t) iters * sizeof(double));
bp=(double*) ((size_t) gp + (size_t) iters * sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(gp++);
*(texturePointer_b++)= (GLubyte) *(bp++);
}
textureRecord->depth=24;
}
// Improved version: Takes 25 ms on a 800x800 texture...
if(isImageMatrixBytes && numMatrixPlanes==3){
texturePointer_b=(GLubyte*) texturePointer;
rpb=(GLubyte*) ((size_t) byteMatrix);
gpb=(GLubyte*) ((size_t) rpb + (size_t) iters);
bpb=(GLubyte*) ((size_t) gpb + (size_t) iters);
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(rpb++);
*(texturePointer_b++)= *(gpb++);
*(texturePointer_b++)= *(bpb++);
}
textureRecord->depth=24;
}
// Improved version: Takes 55 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==4){
texturePointer_b=(GLubyte*) texturePointer;
rp=(double*) ((size_t) doubleMatrix);
gp=(double*) ((size_t) rp + (size_t) iters * sizeof(double));
bp=(double*) ((size_t) gp + (size_t) iters * sizeof(double));
ap=(double*) ((size_t) bp + (size_t) iters * sizeof(double));
if (bigendian) {
// Code for big-endian machines like PowerPC:
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(ap++);
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(gp++);
*(texturePointer_b++)= (GLubyte) *(bp++);
}
}
else {
// Code for little-endian machines like Intel Pentium:
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(bp++);
*(texturePointer_b++)= (GLubyte) *(gp++);
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(ap++);
}
}
textureRecord->depth=32;
}
// Improved version: Takes 33 ms on a 800x800 texture...
if(isImageMatrixBytes && numMatrixPlanes==4){
texturePointer_b=(GLubyte*) texturePointer;
rpb=(GLubyte*) ((size_t) byteMatrix);
gpb=(GLubyte*) ((size_t) rpb + (size_t) iters);
bpb=(GLubyte*) ((size_t) gpb + (size_t) iters);
apb=(GLubyte*) ((size_t) bpb + (size_t) iters);
if (bigendian) {
// Code for big-endian machines like PowerPC:
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(apb++);
*(texturePointer_b++)= *(rpb++);
*(texturePointer_b++)= *(gpb++);
*(texturePointer_b++)= *(bpb++);
}
}
else {
// Code for little-endian machines like Intel Pentium:
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(bpb++);
*(texturePointer_b++)= *(gpb++);
*(texturePointer_b++)= *(rpb++);
*(texturePointer_b++)= *(apb++);
}
}
textureRecord->depth=32;
}
} // End of 8 bpc texture conversion code (fast-path for LDR textures)
// Override for missing floating point texture support?
if ((usefloatformat==1) && !(windowRecord->gfxcaps & kPsychGfxCapFPTex16)) {
// Override enabled. Instead of a 16bpc float texture with 11 bit linear precision in the
// range [-1.0 ; 1.0], we use a 16 bit signed normalized texture with a normalized value
// range of [-1.0; 1.0], encoded with 1 bit sign and 15 bit magnitude. These textures have
// an effective linear precision of 15 bits - better than 16 bpc float - but they are restricted
// to a value range of [-1.0 ; 1.0], as opposed to 16 bpc float textures. Tell user about this
// replacement at high verbosity levels:
if (PsychPrefStateGet_Verbosity() > 4)
printf("PTB-INFO:MakeTexture: Code requested 16 bpc float texture, but this is unsupported. Trying to use 16 bit snorm texture instead.\n");
// Signed normalized textures supported? Otherwise we bail...
if (!(windowRecord->gfxcaps & kPsychGfxCapSNTex16)) {
printf("PTB-ERROR:MakeTexture: Code requested 16 bpc floating point texture, but this is unsupported by this graphics card.\n");
printf("PTB-ERROR:MakeTexture: Tried to use 16 bit snorm texture instead, but failed as this is unsupported as well.\n");
PsychErrorExitMsg(PsychError_user, "Creation of 15 bit linear precision signed normalized texture failed. Not supported by your graphics hardware!");
}
// Check value range of pixels. This will not work for out of [-1; 1] range values.
texturePointer_f=(GLfloat*) texturePointer;
iters = iters * (size_t) numMatrixPlanes;
for (ix=0; ix<iters; ix++, texturePointer_f++) {
if(fabs((double) *texturePointer_f) > 1.0) {
// Game over!
printf("PTB-ERROR:MakeTexture: Code requested 16 bpc floating point texture, but this is unsupported by this graphics card.\n");
printf("PTB-ERROR:MakeTexture: Tried to use 16 bit snorm texture instead, but failed because some pixels are outside the\n");
printf("PTB-ERROR:MakeTexture: representable range -1.0 to 1.0 for this texture type. Change your code or update your graphics hardware.\n");
PsychErrorExitMsg(PsychError_user, "Creation of 15 bit linear precision signed normalized texture failed due to out of [-1 ; +1] range pixel values!");
}
}
}
// This is a special workaround for bugs in FLOAT16 texture creation on Mac OS/X 10.4.x and 10.5.x.
// The OpenGL fails to properly flush very small values (< 1e-9) to zero when creating a FLOAT16
// type texture. Instead it seems to initialize with trash data, corrupting the texture.
// Therefore, if FLOAT16 texture creation is requested, we loop over the whole input buffer and
// set all values with magnitude smaller than 1e-9 to zero. Better safe than sorry...
if ((usefloatformat==1) && (windowRecord->gfxcaps & kPsychGfxCapFPTex16)) {
texturePointer_f=(GLfloat*) texturePointer;
iters = iters * (size_t) numMatrixPlanes;
for(ix=0; ix<iters; ix++, texturePointer_f++) if(fabs((double) *texturePointer_f) < 1e-9) { *texturePointer_f = 0.0; }
}
// The memory buffer now contains our texture data in a format ready to submit to OpenGL.
// Assign parent window and copy its inheritable properties:
PsychAssignParentWindow(textureRecord, windowRecord);
// Texture orientation is zero aka transposed aka non-renderswapped.
textureRecord->textureOrientation = ((assume_texorientation != 2) && (assume_texorientation != 3)) ? 0 : 2;
// This is our best guess about the number of image channels:
textureRecord->nrchannels = numMatrixPlanes;
if (planar_storage) {
// Setup special rect to fake PsychCreateTexture() into creating a luminance
// texture numMatrixPlanes times the height (in rows) of the texture, to store the
// numMatrixPlanes layers concatenated to each other.
if (textureRecord->textureOrientation == 0) {
// Normal case: Transposed storage.
PsychMakeRect(&(textureRecord->rect[0]), 0, 0, xSize * numMatrixPlanes, ySize);
}
else {
// Special case: Non-transposed or isotropic storage:
PsychMakeRect(&(textureRecord->rect[0]), 0, 0, xSize, ySize * numMatrixPlanes);
}
// Create planar texture:
PsychCreateTexture(textureRecord);
// Restore rect and clientrect of texture to effective size:
PsychMakeRect(&(textureRecord->rect[0]), 0, 0, xSize, ySize);
PsychCopyRect(textureRecord->clientrect, textureRecord->rect);
textureRecord->specialflags = kPsychPlanarTexture;
}
else {
// Let's create and bind a new texture object and fill it with our new texture data.
PsychCreateTexture(textureRecord);
// Assign GLSL filter-/lookup-shaders if needed:
PsychAssignHighPrecisionTextureShaders(textureRecord, windowRecord, usefloatformat, (usepoweroftwo & 2) ? 1 : 0);
}
// User specified override shader for this texture provided? This is useful for
// basic image processing and procedural texture shading:
if (textureShader!=0) {
// Assign provided shader as filtershader to this texture: We negate it so
// that the texture blitter routines know this is a custom shader, not our
// built in filter shader:
textureRecord->textureFilterShader = -1 * textureShader;
}
// Texture ready. Mark it valid and return handle to userspace:
PsychSetWindowRecordValid(textureRecord);
PsychCopyOutDoubleArg(1, FALSE, textureRecord->windowIndex);
// Swapping the texture to upright orientation requested?
if (assume_texorientation == 1) {
// Transform sourceRecord source texture into a normalized, upright texture if it isn't already in
// that format. We require this standard orientation for simplified shader design.
PsychSetShader(windowRecord, 0);
PsychNormalizeTextureOrientation(textureRecord);
}
// Shall the texture be finally declared "normally oriented"?
// This is either due to explicit renderswapping if assume_textureorientation == 1,
// or because it was already pretransposed in Matlab/Octave if assume_textureorientation == 2,
// or because user space tells us the texture is isotropic if assume_textureorientation == 3.
if (assume_texorientation > 0) {
// Yes. Label it as such:
textureRecord->textureOrientation = 2;
}
if(PsychPrefStateGet_DebugMakeTexture()) //MARK #4
StoreNowTime();
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);
}
PsychError SCREENOpenWindow(void)
{
int screenNumber, numWindowBuffers, stereomode, multiSample, imagingmode;
PsychRectType rect;
PsychColorType color;
PsychColorModeType mode;
boolean isArgThere, settingsMade, didWindowOpen;
PsychScreenSettingsType screenSettings;
PsychWindowRecordType *windowRecord;
double dVals[4];
PsychDepthType specifiedDepth, possibleDepths, currentDepth, useDepth;
int dummy1;
double dummy2, dummy3, dummy4;
Boolean EmulateOldPTB = PsychPrefStateGet_EmulateOldPTB();
//just for debugging
//if (PSYCH_DEBUG == PSYCH_ON) printf("Entering SCREENOpen\n");
//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(8)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(2)); //The maximum number of outputs
//get the screen number from the windowPtrOrScreenNumber. This also checks to make sure that the specified screen exists.
PsychCopyInScreenNumberArg(kPsychUseDefaultArgPosition, TRUE, &screenNumber);
if(screenNumber==-1)
PsychErrorExitMsg(PsychError_user, "The specified offscreen window has no ancestral screen.");
/*
The depth checking is ugly because of this stupid depth structure stuff.
Instead get a descriptor of the current video settings, change the depth field,
and pass it to a validate function wich searches a list of valid video modes for the display.
There seems to be no point in checking the depths alone because the legality of a particular
depth depends on the other settings specified below. Its probably best to wait until we have
digested all settings and then test the full mode, declarin an invalid
mode and not an invalid pixel size. We could notice when the depth alone is specified
and in that case issue an invalid depth value.
*/
//find the PixelSize first because the color specifier depends on the screen depth.
PsychInitDepthStruct(¤tDepth); //get the current depth
PsychGetScreenDepth(screenNumber, ¤tDepth);
PsychInitDepthStruct(&possibleDepths); //get the possible depths
PsychGetScreenDepths(screenNumber, &possibleDepths);
#if PSYCH_SYSTEM == PSYCH_OSX || PSYCH_SYSTEM == PSYCH_WINDOWS
// MK Experimental Hack: Add the special depth values 30, 64 and 128 to the depth struct. This allows for
// 10 bpc color buffers and 16 bpc, 32 bpc floating point color buffers on the latest ATI
// and NVidia hardware. Unfortunately at this point of the init sequence, we are not able
// to check if these formats are supported by the hardware. Ugly ugly ugly...
PsychAddValueToDepthStruct(30, &possibleDepths);
PsychAddValueToDepthStruct(64, &possibleDepths);
PsychAddValueToDepthStruct(128, &possibleDepths);
#endif
PsychInitDepthStruct(&specifiedDepth); //get the requested depth and validate it.
isArgThere = PsychCopyInSingleDepthArg(4, FALSE, &specifiedDepth);
PsychInitDepthStruct(&useDepth);
if(isArgThere){ //if the argument is there check that the screen supports it...
if(!PsychIsMemberDepthStruct(&specifiedDepth, &possibleDepths))
PsychErrorExit(PsychError_invalidDepthArg);
else
PsychCopyDepthStruct(&useDepth, &specifiedDepth);
}else //otherwise use the default
PsychCopyDepthStruct(&useDepth, ¤tDepth);
//find the rect.
PsychGetScreenRect(screenNumber, rect); //get the rect describing the screen bounds. This is the default Rect.
// Override it with a user supplied rect, if one was supplied:
isArgThere=PsychCopyInRectArg(kPsychUseDefaultArgPosition, FALSE, rect );
if (IsPsychRectEmpty(rect)) PsychErrorExitMsg(PsychError_user, "OpenWindow called with invalid (empty) rect argument.");
//find the number of specified buffers.
//OS X: The number of backbuffers is not a property of the display mode but an attribute of the pixel format.
// Therefore the value is held by a window record and not a screen record.
numWindowBuffers=2;
PsychCopyInIntegerArg(5,FALSE,&numWindowBuffers);
if(numWindowBuffers < 1 || numWindowBuffers > kPsychMaxNumberWindowBuffers) PsychErrorExit(PsychError_invalidNumberBuffersArg);
// MK: Check for optional spec of stereoscopic display: 0 (the default) = monoscopic viewing.
// 1 == Stereo output via OpenGL built-in stereo facilities: This will drive any kind of
// stereo display hardware that is directly supported by MacOS-X.
// 2/3 == Stereo output via compressed frame output: Only one backbuffer is used for both
// views: The left view image is put into the top-half of the screen, the right view image
// is put into the bottom half of the screen. External hardware demangles this combi-image
// again into two separate images. CrystalEyes seems to be able to do this. One looses half
// of the vertical resolution, but potentially gains refresh rate...
// Future PTB version may include different stereo algorithms with an id > 1, e.g.,
// anaglyph stereo, interlaced stereo, ...
stereomode=0;
PsychCopyInIntegerArg(6,FALSE,&stereomode);
if(stereomode < 0 || stereomode > 9) PsychErrorExitMsg(PsychError_user, "Invalid stereomode provided (Valid between 0 and 9).");
if (stereomode!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, stereo display functions are not supported in OS-9 PTB emulation mode.");
multiSample=0;
PsychCopyInIntegerArg(7,FALSE,&multiSample);
if(multiSample < 0) PsychErrorExitMsg(PsychError_user, "Invalid multisample value provided (Valid are positive numbers >= 0).");
if (multiSample!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, anti-aliasing functions are not supported in OS-9 PTB emulation mode.");
imagingmode=0;
PsychCopyInIntegerArg(8,FALSE,&imagingmode);
if(imagingmode < 0) PsychErrorExitMsg(PsychError_user, "Invalid imaging mode provided (See 'help PsychImagingMode' for usage info).");
if (imagingmode!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, imaging pipeline functions are not supported in OS-9 PTB emulation mode.");
//set the video mode to change the pixel size. TO DO: Set the rect and the default color
PsychGetScreenSettings(screenNumber, &screenSettings);
PsychInitDepthStruct(&(screenSettings.depth));
PsychCopyDepthStruct(&(screenSettings.depth), &useDepth);
// Here is where all the work goes on:
// If the screen is not already captured then to that:
if(~PsychIsScreenCaptured(screenNumber)) {
PsychCaptureScreen(screenNumber);
settingsMade=PsychSetScreenSettings(screenNumber, &screenSettings);
//Capturing the screen and setting its settings always occur in conjunction
//There should be a check above to see if the display is captured and openWindow is attempting to chang
//the bit depth
}
#if PSYCH_SYSTEM == PSYCH_WINDOWS
// On M$-Windows we currently only support - and therefore require >= 30 bpp color depth.
if (PsychGetScreenDepthValue(screenNumber) < 30) {
// Display running at less than 30 bpp. OpenWindow will fail on M$-Windows anyway, so let's abort
// now.
// Release the captured screen:
PsychReleaseScreen(screenNumber);
// Output warning text:
printf("PTB-ERROR: Your display screen %i is not running at the required color depth of at least 30 bit.\n", screenNumber);
printf("PTB-ERROR: The current setting is %i bit color depth..\n", PsychGetScreenDepthValue(screenNumber));
printf("PTB-ERROR: This will not work on Microsoft Windows operating systems.\n");
printf("PTB-ERROR: Please use the 'Display settings' control panel of Windows to change the color depth to\n");
printf("PTB-ERROR: 32 bits per pixel ('True color' or 'Highest' setting) and then retry. It may be neccessary\n");
printf("PTB-ERROR: to restart Matlab after applying the change...\n");
fflush(NULL);
// Abort with Matlab error:
PsychErrorExitMsg(PsychError_user, "Insufficient color depth setting for display device (smaller than 30 bpp).");
}
#endif
//if (PSYCH_DEBUG == PSYCH_ON) printf("Entering PsychOpenOnscreenWindow\n");
PsychCopyDepthStruct(&(screenSettings.depth), &useDepth);
didWindowOpen=PsychOpenOnscreenWindow(&screenSettings, &windowRecord, numWindowBuffers, stereomode, rect, multiSample);
if (!didWindowOpen) {
PsychReleaseScreen(screenNumber);
// We use this dirty hack to exit with an error, but without printing
// an error message. The specific error message has been printed in
// PsychOpenOnscreenWindow() already..
PsychErrMsgTxt("");
}
// Sufficient display depth for full alpha-blending and such?
if (PsychGetScreenDepthValue(screenNumber) < 24) {
// Nope. Output a little warning.
printf("PTB-WARNING: Your display screen %i is not running at 24 bit color depth or higher.\n", screenNumber);
printf("PTB-WARNING: The current setting is %i bit color depth..\n", PsychGetScreenDepthValue(screenNumber));
printf("PTB-WARNING: This could cause failure to work correctly or visual artifacts in stimuli\n");
printf("PTB-WARNING: that involve Alpha-Blending. It can also cause drastically reduced color resolution\n");
printf("PTB-WARNING: for your stimuli! Please try to switch your display to 'True Color' (Windows)\n");
printf("PTB-WARNING: our 'Millions of Colors' (MacOS-X) to get rid of this warning and the visual artifacts.\n");
fflush(NULL);
}
// Define clear color: This depends on the color range of our onscreen window...
isArgThere=PsychCopyInColorArg(kPsychUseDefaultArgPosition, FALSE, &color); //get from user
if(!isArgThere) PsychLoadColorStruct(&color, kPsychIndexColor, PsychGetWhiteValueFromWindow(windowRecord)); //or use the default
PsychCoerceColorMode(&color);
// Initialize internal image processing pipeline if requested:
PsychInitializeImagingPipeline(windowRecord, imagingmode);
// On OS-X, if we are int quad-buffered frame sequential stereo mode, we automatically generate
// blue-line-sync style sync lines for use with stereo shutter glasses. We don't do this
// by default on Windows or Linux: These systems either don't have stereo capable hardware,
// or they have some and its drivers already take care of sync signal generation.
if ((PSYCH_SYSTEM == PSYCH_OSX) && (windowRecord->stereomode==kPsychOpenGLStereo)) {
if (PsychPrefStateGet_Verbosity()>3) printf("PTB-INFO: Enabling internal blue line sync renderer for quad-buffered stereo...\n");
PsychPipelineAddBuiltinFunctionToHook(windowRecord, "LeftFinalizerBlitChain", "Builtin:RenderStereoSyncLine", TRUE, "");
PsychPipelineEnableHook(windowRecord, "LeftFinalizerBlitChain");
PsychPipelineAddBuiltinFunctionToHook(windowRecord, "RightFinalizerBlitChain", "Builtin:RenderStereoSyncLine", TRUE, "");
PsychPipelineEnableHook(windowRecord, "RightFinalizerBlitChain");
}
// Activate new onscreen window for userspace drawing: If imaging pipeline is active, this
// will bind the correct rendertargets for the first time:
PsychSetGLContext(windowRecord);
PsychSetDrawingTarget(windowRecord);
// Set the clear color and perform a backbuffer-clear:
PsychConvertColorToDoubleVector(&color, windowRecord, dVals);
glClearColor(dVals[0], dVals[1], dVals[2], dVals[3]);
glClear(GL_COLOR_BUFFER_BIT);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
// Make sure no OpenGL errors happened up to this point:
PsychTestForGLErrors();
// If we are in logo-startup mode (former blue-screen mode) and double-buffering
// is enabled, then do an initial bufferswap & clear, so the display starts in
// the user selected background color instead of staying at the blue screen or
// logo display until the Matlab script first calls 'Flip'.
if ((PsychPrefStateGet_VisualDebugLevel()>=4) && numWindowBuffers>=2) {
// Do immediate bufferswap by an internal call to Screen('Flip'). This will also
// take care of clearing the backbuffer in preparation of first userspace drawing
// commands and such...
PsychFlipWindowBuffers(windowRecord, 0, 0, 0, 0, &dummy1, &dummy2, &dummy3, &dummy4);
// Display now shows background color, so user knows that PTB's 'OpenWindow'
// procedure is successfully finished.
}
PsychTestForGLErrors();
//Return the window index and the rect argument.
PsychCopyOutDoubleArg(1, FALSE, windowRecord->windowIndex);
// rect argument needs special treatment in stereo mode:
if (windowRecord->stereomode==kPsychFreeFusionStereo || windowRecord->stereomode==kPsychFreeCrossFusionStereo) {
// Special case for stereo: Only half the real window width:
PsychMakeRect(&rect, windowRecord->rect[kPsychLeft],windowRecord->rect[kPsychTop],
windowRecord->rect[kPsychLeft] + PsychGetWidthFromRect(windowRecord->rect)/2,windowRecord->rect[kPsychBottom]);
}
else {
// Normal case:
PsychMakeRect(&rect, windowRecord->rect[kPsychLeft],windowRecord->rect[kPsychTop],windowRecord->rect[kPsychRight],windowRecord->rect[kPsychBottom]);
}
PsychCopyOutRectArg(2, FALSE, rect);
return(PsychError_none);
}
PsychError SCREENPreference(void)
{
PsychArgFormatType arg1Type;
char *preferenceName, *newFontName;
const char *tableCreator, *oldDefaultFontName;
Boolean preferenceNameArgumentValid, booleanInput, ignoreCase, tempFlag, textAlphaBlendingFlag, suppressAllWarningsFlag;
int numInputArgs, i, newFontStyleNumber, newFontSize, tempInt, tempInt2, tempInt3;
double returnDoubleValue, inputDoubleValue;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for superfluous or missing arguments
PsychErrorExit(PsychCapNumInputArgs(3));
PsychErrorExit(PsychRequireNumInputArgs(1));
PsychErrorExit(PsychCapNumOutputArgs(1));
numInputArgs=PsychGetNumInputArgs();
arg1Type=PsychGetArgType(1);
preferenceNameArgumentValid=FALSE;
//Cases which require both a window pointer or screen number and preference name. Argument 1 is the wposn and argument 2 is the preference name.
if( numInputArgs >= 2 && (PsychIsScreenNumberArg(1) || PsychIsScreenNumberArg(1)) && PsychGetArgType(2)==PsychArgType_char ){
PsychAllocInCharArg(2, kPsychArgRequired, &preferenceName);
//preferences which require window pointer or screen number argument which we DO NOT support
for(i=0;i<kPsychNumUnsupportedMacVideoPreferences;i++){
if(PsychMatch(preferenceName, unsupportedMacVideoPreferenceNames[i]))
PsychErrorExit(PsychError_unsupportedOS9Preference);
}
//insert here conditionals to act on prefernces which accept a window pointer or screen number argument which we DO support.
PsychErrorExit(PsychError_unrecognizedPreferenceName);
}
//Cases which do not require a wposn. Argument 1 is the preference name. if present Argument 2 is the new value
if(arg1Type==PsychArgType_char){
PsychAllocInCharArg(1, kPsychArgRequired, &preferenceName);
//Preferernces which we do not support and which do not require a wposn
for(i=0;i<kPsychNumUnsupportedMacNonVideoPreferences;i++){
if(PsychMatch(preferenceName, unsupportedMacNonVideoPreferenceNames[i]))
PsychErrorExit(PsychError_unsupportedOS9Preference);
}
//Preferences which we do support
if(PsychMatch(preferenceName, "IgnoreCase")){
ignoreCase=!PsychIsPsychMatchCaseSensitive();
PsychCopyOutFlagArg(1, kPsychArgOptional, ignoreCase);
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &booleanInput);
PsychSetPsychMatchCaseSenstive(!booleanInput);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "Tick0Secs")){
if(PsychCopyInDoubleArg(2, kPsychArgOptional, &inputDoubleValue) && inputDoubleValue==PsychGetNanValue())
PsychEstimateGetSecsValueAtTickCountZero();
returnDoubleValue=PsychGetEstimatedSecsValueAtTickCountZero();
PsychCopyOutDoubleArg(1, kPsychArgOptional, returnDoubleValue);
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "PsychTableVersion")){
if(numInputArgs==2)
PsychErrorExit(PsychError_extraInputArg);
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double)PsychPrefStateGet_PsychTableVersion());
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "PsychTableCreator")){
if(numInputArgs==2)
PsychErrorExit(PsychError_extraInputArg);
tableCreator=PsychPrefStateGet_PsychTableCreator();
PsychCopyOutCharArg(1, kPsychArgOptional, tableCreator);
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "Process")){
if(numInputArgs==2)
PsychErrorExit(PsychError_extraInputArg);
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double)getpid());
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultFontName")){
PsychPrefStateGet_DefaultFontName(&oldDefaultFontName);
PsychCopyOutCharArg(1, kPsychArgOptional, oldDefaultFontName);
if(numInputArgs==2){
PsychAllocInCharArg(2, kPsychArgRequired, &newFontName);
PsychPrefStateSet_DefaultFontName(newFontName);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultFontStyle")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_DefaultTextStyle());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &newFontStyleNumber);
PsychPrefStateSet_DefaultTextStyle(newFontStyleNumber);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultTextYPositionIsBaseline")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_TextYPositionIsBaseline());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_TextYPositionIsBaseline(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "TextAntiAliasing")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_TextAntiAliasing());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_TextAntiAliasing(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "TextRenderer")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_TextRenderer());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_TextRenderer(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultFontSize")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_DefaultTextSize());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &newFontSize);
PsychPrefStateSet_DefaultTextSize(newFontSize);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DebugMakeTexture")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_DebugMakeTexture());
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &tempFlag);
PsychPrefStateSet_DebugMakeTexture(tempFlag);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "SkipSyncTests")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_SkipSyncTests());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_SkipSyncTests(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "VisualDebugLevel")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_VisualDebugLevel());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_VisualDebugLevel(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "VBLTimestampingMode")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_VBLTimestampingMode());
if(numInputArgs>=2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_VBLTimestampingMode(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "VBLEndlineOverride")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_VBLEndlineOverride());
if(numInputArgs>=2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_VBLEndlineOverride(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultVideocaptureEngine")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_VideoCaptureEngine());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_VideoCaptureEngine(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "ConserveVRAM") || PsychMatch(preferenceName, "Workarounds1")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_ConserveVRAM());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_ConserveVRAM(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "Verbosity")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_Verbosity());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_Verbosity(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "EmulateOldPTB")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_EmulateOldPTB());
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &tempFlag);
PsychPrefStateSet_EmulateOldPTB(tempFlag);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "Enable3DGraphics")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_3DGfx());
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &tempFlag);
PsychPrefStateSet_3DGfx(tempFlag);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "TextAlphaBlending")){
textAlphaBlendingFlag=PsychPrefStateGet_TextAlphaBlending();
PsychCopyOutFlagArg(1, kPsychArgOptional, textAlphaBlendingFlag);
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &booleanInput);
PsychPrefStateSet_TextAlphaBlending(booleanInput);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "SuppressAllWarnings")){
suppressAllWarningsFlag=PsychPrefStateGet_SuppressAllWarnings();
PsychCopyOutFlagArg(1, kPsychArgOptional, suppressAllWarningsFlag);
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &booleanInput);
PsychPrefStateSet_SuppressAllWarnings(booleanInput);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "SynchronizeDisplays")){
if(numInputArgs==2){
// This is a special call: It currently doesn't set a preference setting,
// but instead triggers an instantaneous synchronization of all available
// display heads, if possible. We may have a more clever and "standard" interface
// interface for this later on, but for first tests this will do.
// Syncmethod is hard-coded to 0 -> Use whatever's available to sync.
// timeout for retries is 5.0 seconds.
// Acceptable residual offset is +/- 2 scanlines.
// Returns the real residual offset after sync.
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
tempInt2 = 0;
if (PsychSynchronizeDisplayScreens(&tempInt2, NULL, &tempInt, tempInt, 5.0, 2)!=PsychError_none) PsychErrorExitMsg(PsychError_user, "Sync failed for reasons mentioned above.");
PsychCopyOutDoubleArg(1, kPsychArgOptional, tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
PsychErrorExit(PsychError_unrecognizedPreferenceName);
}
if(!preferenceNameArgumentValid)
PsychErrorExitMsg(PsychError_user, "Invalid arguments to preferences command");
return(PsychError_none);
}
/* Receive messages from the playback pipeline message bus and handle them: */
static gboolean PsychMovieBusCallback(GstBus *bus, GstMessage *msg, gpointer dataptr)
{
PsychMovieRecordType* movie = (PsychMovieRecordType*) dataptr;
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_EOS:
//printf("PTB-DEBUG: Message EOS received.\n");
break;
case GST_MESSAGE_WARNING: {
gchar *debug;
GError *error;
gst_message_parse_warning(msg, &error, &debug);
if (PsychPrefStateGet_Verbosity() > 3) {
printf("PTB-WARNING: GStreamer movie playback engine reports this warning:\n"
" Warning from element %s: %s\n", GST_OBJECT_NAME(msg->src), error->message);
printf(" Additional debug info: %s.\n", (debug) ? debug : "None");
}
g_free(debug);
g_error_free(error);
break;
}
case GST_MESSAGE_ERROR: {
gchar *debug;
GError *error;
gst_message_parse_error(msg, &error, &debug);
if (PsychPrefStateGet_Verbosity() > 0) {
// Most common case, "File not found" error? If so, we provide a pretty-printed error message:
if ((error->domain == GST_RESOURCE_ERROR) && (error->code == GST_RESOURCE_ERROR_NOT_FOUND)) {
printf("PTB-ERROR: Could not open movie file [%s] for playback! No such moviefile with the given path and filename.\n",
movie->movieName);
printf("PTB-ERROR: The specific file URI of the missing movie was: %s.\n", movie->movieLocation);
}
else {
// Nope, something more special. Provide detailed GStreamer error output:
printf("PTB-ERROR: GStreamer movie playback engine reports this error:\n"
" Error from element %s: %s\n", GST_OBJECT_NAME(msg->src), error->message);
printf(" Additional debug info: %s.\n\n", (debug) ? debug : "None");
// And some interpretation for our technically challenged users ;-):
if ((error->domain == GST_RESOURCE_ERROR) && (error->code != GST_RESOURCE_ERROR_NOT_FOUND)) {
printf(" This means that there was some problem with reading the movie file (permissions etc.).\n\n");
}
}
}
g_free(debug);
g_error_free(error);
break;
}
default:
break;
}
return TRUE;
}
PsychError SCREENOpenWindow(void)
{
int screenNumber, numWindowBuffers, stereomode, multiSample, imagingmode;
PsychRectType rect, screenrect;
PsychColorType color;
PsychColorModeType mode;
boolean isArgThere, settingsMade, didWindowOpen, useAGL;
PsychScreenSettingsType screenSettings;
PsychWindowRecordType *windowRecord;
double dVals[4];
PsychDepthType specifiedDepth, possibleDepths, currentDepth, useDepth;
int dummy1;
double dummy2, dummy3, dummy4;
Boolean EmulateOldPTB = PsychPrefStateGet_EmulateOldPTB();
//just for debugging
//if (PSYCH_DEBUG == PSYCH_ON) printf("Entering SCREENOpen\n");
//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(8)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(2)); //The maximum number of outputs
//get the screen number from the windowPtrOrScreenNumber. This also checks to make sure that the specified screen exists.
PsychCopyInScreenNumberArg(kPsychUseDefaultArgPosition, TRUE, &screenNumber);
if(screenNumber==-1)
PsychErrorExitMsg(PsychError_user, "The specified onscreen window has no ancestral screen.");
/*
The depth checking is ugly because of this stupid depth structure stuff.
Instead get a descriptor of the current video settings, change the depth field,
and pass it to a validate function wich searches a list of valid video modes for the display.
There seems to be no point in checking the depths alone because the legality of a particular
depth depends on the other settings specified below. Its probably best to wait until we have
digested all settings and then test the full mode, declarin an invalid
mode and not an invalid pixel size. We could notice when the depth alone is specified
and in that case issue an invalid depth value.
*/
//find the PixelSize first because the color specifier depends on the screen depth.
PsychInitDepthStruct(¤tDepth); //get the current depth
PsychGetScreenDepth(screenNumber, ¤tDepth);
PsychInitDepthStruct(&possibleDepths); //get the possible depths
PsychGetScreenDepths(screenNumber, &possibleDepths);
#if PSYCH_SYSTEM == PSYCH_OSX || PSYCH_SYSTEM == PSYCH_WINDOWS
// MK Experimental Hack: Add the special depth values 64 and 128 to the depth struct. This should
// allows for 16 bpc, 32 bpc floating point color buffers on the latest ATI and NVidia hardware.
// "Should" means: It doesn't really work with any current driver, but we leave the testcode in
// in the hope for future OS and driver releases ;-)
// Unfortunately at this point of the init sequence, we are not able
// to check if these formats are supported by the hardware. Ugly ugly ugly...
PsychAddValueToDepthStruct(64, &possibleDepths);
PsychAddValueToDepthStruct(128, &possibleDepths);
#endif
// #if PSYCH_SYSTEM == PSYCH_OSX || PSYCH_SYSTEM == PSYCH_LINUX
// On MacOS/X and Linux with ATI Radeon X1000/HD2000/HD3000 hardware and the special
// kernel support driver installed, we should be able to configure the hardwares
// framebuffers into ABGR2101010 mode, ie. 2 bits alpha, 10 bpc for red, green, blue.
// This needs support from the imaging pipeline, or manually converted stimuli, as
// the GPU doesn't format pixel data properly, only the CRTC scans out in that format.
// Anyway, allow this setting on OS/X and Linux:
// Update: Some FireGL cards (2008 and later) claim to support this on MS-Windows. Enable
// this option on Windows as well, so it is at least testable:
PsychAddValueToDepthStruct(30, &possibleDepths);
// #endif
PsychInitDepthStruct(&specifiedDepth); //get the requested depth and validate it.
isArgThere = PsychCopyInSingleDepthArg(4, FALSE, &specifiedDepth);
PsychInitDepthStruct(&useDepth);
if(isArgThere){ //if the argument is there check that the screen supports it...
if(!PsychIsMemberDepthStruct(&specifiedDepth, &possibleDepths))
PsychErrorExit(PsychError_invalidDepthArg);
else
PsychCopyDepthStruct(&useDepth, &specifiedDepth);
}else //otherwise use the default
PsychCopyDepthStruct(&useDepth, ¤tDepth);
// Initialize the rect argument to the screen rectangle:
PsychGetScreenRect(screenNumber, rect); //get the rect describing the screen bounds. This is the default Rect.
// Override it with a user supplied rect, if one was supplied:
isArgThere=PsychCopyInRectArg(kPsychUseDefaultArgPosition, FALSE, rect );
if (IsPsychRectEmpty(rect)) PsychErrorExitMsg(PsychError_user, "OpenWindow called with invalid (empty) rect argument.");
if (PSYCH_SYSTEM == PSYCH_OSX) {
// OS/X system: Need to decide if we use a Carbon window + AGL
// or a fullscreen context with CGL:
// Default to AGL, switch to CGL if below constraints are met:
useAGL = TRUE;
// Window rect provided which has a different size than screen?
// We do not use windowed mode if the provided window rectangle either
// matches the target screens rectangle (and therefore its exact size)
// or its screens global rectangle.
PsychGetScreenRect(screenNumber, screenrect);
if (PsychMatchRect(screenrect, rect)) useAGL=FALSE;
PsychGetGlobalScreenRect(screenNumber, screenrect);
if (PsychMatchRect(screenrect, rect)) useAGL=FALSE;
// Override for use on f$%#$Fd OS/X 10.5.3 - 10.5.6 with NVidia GF 8800 GPU's:
if (PsychPrefStateGet_ConserveVRAM() & kPsychUseAGLCompositorForFullscreenWindows) useAGL = TRUE;
}
else {
// Non OS/X system: Do not use AGL ;-)
useAGL = FALSE;
}
//find the number of specified buffers.
//OS X: The number of backbuffers is not a property of the display mode but an attribute of the pixel format.
// Therefore the value is held by a window record and not a screen record.
numWindowBuffers=2;
PsychCopyInIntegerArg(5,FALSE,&numWindowBuffers);
if(numWindowBuffers < 1 || numWindowBuffers > kPsychMaxNumberWindowBuffers) PsychErrorExit(PsychError_invalidNumberBuffersArg);
// MK: Check for optional spec of stereoscopic display: 0 (the default) = monoscopic viewing.
// 1 == Stereo output via OpenGL built-in stereo facilities: This will drive any kind of
// stereo display hardware that is directly supported by MacOS-X.
// 2/3 == Stereo output via compressed frame output: Only one backbuffer is used for both
// views: The left view image is put into the top-half of the screen, the right view image
// is put into the bottom half of the screen. External hardware demangles this combi-image
// again into two separate images. CrystalEyes seems to be able to do this. One looses half
// of the vertical resolution, but potentially gains refresh rate...
// Future PTB version may include different stereo algorithms with an id > 1, e.g.,
// anaglyph stereo, interlaced stereo, ...
stereomode=0;
PsychCopyInIntegerArg(6,FALSE,&stereomode);
if(stereomode < 0 || stereomode > 10) PsychErrorExitMsg(PsychError_user, "Invalid stereomode provided (Valid between 0 and 10).");
if (stereomode!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, stereo display functions are not supported in OS-9 PTB emulation mode.");
multiSample=0;
PsychCopyInIntegerArg(7,FALSE,&multiSample);
if(multiSample < 0) PsychErrorExitMsg(PsychError_user, "Invalid multisample value provided (Valid are positive numbers >= 0).");
if (multiSample!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, anti-aliasing functions are not supported in OS-9 PTB emulation mode.");
imagingmode=0;
PsychCopyInIntegerArg(8,FALSE,&imagingmode);
if(imagingmode < 0) PsychErrorExitMsg(PsychError_user, "Invalid imaging mode provided (See 'help PsychImagingMode' for usage info).");
if (imagingmode!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, imaging pipeline functions are not supported in OS-9 PTB emulation mode.");
// We require use of the imaging pipeline if stereomode for dualwindow display is requested.
// This makes heavy use of FBO's and blit operations, so imaging pipeline is needed.
if (stereomode==kPsychDualWindowStereo) {
// Dual window stereo requested, but imaging pipeline not enabled. Enable it:
imagingmode|= kPsychNeedFastBackingStore;
if (PsychPrefStateGet_Verbosity()>3) printf("PTB-INFO: Trying to enable imaging pipeline for dual-window stereo display mode...\n");
}
//set the video mode to change the pixel size. TO DO: Set the rect and the default color
PsychGetScreenSettings(screenNumber, &screenSettings);
PsychInitDepthStruct(&(screenSettings.depth));
PsychCopyDepthStruct(&(screenSettings.depth), &useDepth);
// Here is where all the work goes on:
// If the screen is not already captured then to that:
if(!PsychIsScreenCaptured(screenNumber) && !useAGL) {
PsychCaptureScreen(screenNumber);
// We disable the call to PsychSetScreenSettings here: Its not useful, as it
// could only change color depth - which is something we don't want to do anyway here.
// If people want to change displays settings, they should use Screen('Resolution') instead,
// which is a more clever interface to PsychSetScreenSettings().
// settingsMade=PsychSetScreenSettings(screenNumber, &screenSettings);
//Capturing the screen and setting its settings always occur in conjunction
//There should be a check above to see if the display is captured and openWindow is attempting to chang
//the bit depth
}
#if PSYCH_SYSTEM == PSYCH_WINDOWS
// On M$-Windows we currently only support - and therefore require >= 30 bpp color depth.
if (PsychGetScreenDepthValue(screenNumber) < 30) {
// Display running at less than 30 bpp. OpenWindow will fail on M$-Windows anyway, so let's abort
// now.
// Output warning text:
printf("PTB-ERROR: Your display screen %i is not running at the required color depth of at least 30 bit.\n", screenNumber);
printf("PTB-ERROR: The current setting is %i bit color depth..\n", PsychGetScreenDepthValue(screenNumber));
printf("PTB-ERROR: This will not work on Microsoft Windows operating systems.\n");
printf("PTB-ERROR: Please use the 'Display settings' control panel of Windows to change the color depth to\n");
printf("PTB-ERROR: 32 bits per pixel ('True color' or 'Highest' setting) and then retry. It may be neccessary\n");
printf("PTB-ERROR: to restart Matlab after applying the change...\n");
fflush(NULL);
// Release the captured screen:
PsychRestoreScreenSettings(screenNumber);
PsychReleaseScreen(screenNumber);
// Reset master assignment to prepare possible further dual-window config operations:
sharedContextWindow = NULL;
// Abort with Matlab error:
PsychErrorExitMsg(PsychError_user, "Insufficient color depth setting for display device (smaller than 30 bpp).");
}
#endif
//if (PSYCH_DEBUG == PSYCH_ON) printf("Entering PsychOpenOnscreenWindow\n");
PsychCopyDepthStruct(&(screenSettings.depth), &useDepth);
// Create the onscreen window and perform initialization of everything except
// imaging pipeline and a few other special quirks. If sharedContextWindow is non-NULL,
// the new window will share its OpenGL context ressources with sharedContextWindow.
// This is typically used for dual-window stereo mode. Btw. If imaging pipeline is really
// active, we force multiSample to zero: This way the system backbuffer / pixelformat
// is enabled without multisampling support, as we do all the multisampling stuff ourselves
// within the imaging pipeline with multisampled drawbuffer FBO's...
didWindowOpen=PsychOpenOnscreenWindow(&screenSettings, &windowRecord, numWindowBuffers, stereomode, rect, ((imagingmode==0 || imagingmode==kPsychNeedFastOffscreenWindows) ? multiSample : 0), sharedContextWindow);
if (!didWindowOpen) {
if (!useAGL) {
PsychRestoreScreenSettings(screenNumber);
PsychReleaseScreen(screenNumber);
}
// Reset master assignment to prepare possible further dual-window config operations:
sharedContextWindow = NULL;
// We use this dirty hack to exit with an error, but without printing
// an error message. The specific error message has been printed in
// PsychOpenOnscreenWindow() already..
PsychErrMsgTxt("");
}
// Sufficient display depth for full alpha-blending and such?
if (PsychGetScreenDepthValue(screenNumber) < 24) {
// Nope. Output a little warning.
printf("PTB-WARNING: Your display screen %i is not running at 24 bit color depth or higher.\n", screenNumber);
printf("PTB-WARNING: The current setting is %i bit color depth..\n", PsychGetScreenDepthValue(screenNumber));
printf("PTB-WARNING: This could cause failure to work correctly or visual artifacts in stimuli\n");
printf("PTB-WARNING: that involve Alpha-Blending. It can also cause drastically reduced color resolution\n");
printf("PTB-WARNING: for your stimuli! Please try to switch your display to 'True Color' (Windows)\n");
printf("PTB-WARNING: our 'Millions of Colors' (MacOS-X) to get rid of this warning and the visual artifacts.\n");
fflush(NULL);
}
// Define clear color: This depends on the color range of our onscreen window...
isArgThere=PsychCopyInColorArg(kPsychUseDefaultArgPosition, FALSE, &color); //get from user
if(!isArgThere) PsychLoadColorStruct(&color, kPsychIndexColor, PsychGetWhiteValueFromWindow(windowRecord)); //or use the default
PsychCoerceColorMode(&color);
// Special setup code for dual window stereomode:
if (stereomode == kPsychDualWindowStereo) {
if (sharedContextWindow) {
// This is creation & setup of the slave onscreen window, ie. the one
// representing the right-eye view. This window doesn't do much. It
// is not used or referenced in the users experiment script. It receives
// its final image content during Screen('Flip') operation of the master
// onscreen window, then gets flipped in sync with the master window.
// Ok, we already have the slave window open and it shares its OpenGL context
// with the master window. Reset its internal reference to the master:
windowRecord->slaveWindow = NULL;
// Reset imagingmode for this window prior to imaging pipeline setup. This
// window is totally passive so it doesn't need the imaging pipeline.
imagingmode = 0;
// Assign this window to the master window as a slave:
sharedContextWindow->slaveWindow = windowRecord;
// Reset master assignment to prepare possible further dual-window config operations:
sharedContextWindow = NULL;
// Activate the IdentitiyBlitChain for the slave window and add a single identity blit
// operation to it: This is needed in PsychPreFlipOperations() for final copy of stimulus
// image into this slave window:
PsychPipelineAddBuiltinFunctionToHook(windowRecord, "IdentityBlitChain", "Builtin:IdentityBlit", INT_MAX, "");
PsychPipelineEnableHook(windowRecord, "IdentityBlitChain");
if (PsychPrefStateGet_Verbosity()>3) printf("PTB-INFO: Created master-slave window relationship for dual-window stereo display mode...\n");
// Special config finished. The master-slave combo should work from now on...
}
else {
// This is initial setup & creation of the master onscreen window, ie. the one
// representing the left-eye view and doing all the heavy work, acting as a
// proxy for both windows.
// Not much to do here. Just store its windowRecord as a reference for creation
// of the slave window. We'll need it for that purpose...
sharedContextWindow = windowRecord;
}
}
// Set special half-width flag for window if we are either in a dual-display/dual-view stereo mode or if
// if is requested as part of the imagingMode flag. This will cause PTB 2D drawing routines and window size
// query routines etc. to return an effective window width or window rect only half the real width.
if (windowRecord->stereomode==kPsychFreeFusionStereo || windowRecord->stereomode==kPsychFreeCrossFusionStereo || (imagingmode & kPsychHalfWidthWindow)) {
windowRecord->specialflags = windowRecord->specialflags | kPsychHalfWidthWindow;
imagingmode = imagingmode & (~kPsychHalfWidthWindow);
}
// Similar handling for windows of half the real height, except that none of our built-in stereo modes requires these,
// so this is only done on request from external code via the imagingmode flag kPsychHalfHeightWindow.
// One use of this is when using interleaved line stereo mode (PsychImaging(...'InterleavedLineStereo')) where windows
// only have a useable net height of half their physical height:
if (imagingmode & kPsychHalfHeightWindow) {
windowRecord->specialflags = windowRecord->specialflags | kPsychHalfHeightWindow;
imagingmode = imagingmode & (~kPsychHalfHeightWindow);
}
// Initialize internal image processing pipeline if requested:
PsychInitializeImagingPipeline(windowRecord, imagingmode, multiSample);
// On OS-X, if we are in quad-buffered frame sequential stereo mode, we automatically generate
// blue-line-sync style sync lines for use with stereo shutter glasses. We don't do this
// by default on Windows or Linux: These systems either don't have stereo capable hardware,
// or they have some and its drivers already take care of sync signal generation.
if ((PSYCH_SYSTEM == PSYCH_OSX) && (windowRecord->stereomode==kPsychOpenGLStereo)) {
if (PsychPrefStateGet_Verbosity()>3) printf("PTB-INFO: Enabling internal blue line sync renderer for quad-buffered stereo...\n");
PsychPipelineAddBuiltinFunctionToHook(windowRecord, "LeftFinalizerBlitChain", "Builtin:RenderStereoSyncLine", INT_MAX, "");
PsychPipelineEnableHook(windowRecord, "LeftFinalizerBlitChain");
PsychPipelineAddBuiltinFunctionToHook(windowRecord, "RightFinalizerBlitChain", "Builtin:RenderStereoSyncLine", INT_MAX, "");
PsychPipelineEnableHook(windowRecord, "RightFinalizerBlitChain");
}
// Activate new onscreen window for userspace drawing: If imaging pipeline is active, this
// will bind the correct rendertargets for the first time:
PsychSetDrawingTarget(windowRecord);
// Set the clear color and perform a backbuffer-clear:
PsychConvertColorToDoubleVector(&color, windowRecord, windowRecord->clearColor);
PsychGLClear(windowRecord);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
// Make sure no OpenGL errors happened up to this point:
PsychTestForGLErrors();
// If we are in logo-startup mode (former blue-screen mode) and double-buffering
// is enabled, then do an initial bufferswap & clear, so the display starts in
// the user selected background color instead of staying at the blue screen or
// logo display until the Matlab script first calls 'Flip'.
if ((PsychPrefStateGet_VisualDebugLevel()>=4) && numWindowBuffers>=2) {
// Do immediate bufferswap by an internal call to Screen('Flip'). This will also
// take care of clearing the backbuffer in preparation of first userspace drawing
// commands and such...
PsychFlipWindowBuffers(windowRecord, 0, 0, 0, 0, &dummy1, &dummy2, &dummy3, &dummy4);
// Display now shows background color, so user knows that PTB's 'OpenWindow'
// procedure is successfully finished.
}
PsychTestForGLErrors();
//Return the window index and the rect argument.
PsychCopyOutDoubleArg(1, FALSE, windowRecord->windowIndex);
// rect argument needs special treatment in stereo mode:
PsychMakeRect(&rect, windowRecord->rect[kPsychLeft], windowRecord->rect[kPsychTop],
windowRecord->rect[kPsychLeft] + PsychGetWidthFromRect(windowRecord->rect)/((windowRecord->specialflags & kPsychHalfWidthWindow) ? 2 : 1),
windowRecord->rect[kPsychTop] + PsychGetHeightFromRect(windowRecord->rect)/((windowRecord->specialflags & kPsychHalfHeightWindow) ? 2 : 1));
PsychCopyOutRectArg(2, FALSE, rect);
return(PsychError_none);
}
PsychError SCREENBlendFunction(void)
{
PsychWindowRecordType *windowRecord;
GLenum oldSource, oldDestination, newSource, newDestination;
char *oldSoureStr, *oldDestinationStr, *newSourceStr, *newDestinationStr;
int oldSourceStrSize, oldDestinationStrSize, isSourceStringValid, isDestinationStringValid;
psych_bool isSourceSupplied, isDestinationSupplied, isSourceChoiceValid, isDestinationChoiceValid;
double *oldColorMask, *newColorMask;
int m, n, p;
//all subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(4)); //The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(1)); //The required number of inputs
PsychErrorExit(PsychCapNumOutputArgs(3)); //The maximum number of outputs
//Get the window record or exit with an error if the windex was bogus.
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
//Retreive the old source and destination factors and return them from the Screen call as strings
PsychGetAlphaBlendingFactorsFromWindow(windowRecord, &oldSource, &oldDestination);
oldSourceStrSize=PsychGetAlphaBlendingFactorStringFromConstant(oldSource, NULL);
oldDestinationStrSize=PsychGetAlphaBlendingFactorStringFromConstant(oldDestination, NULL);
oldSoureStr=(char *)malloc(sizeof(char) * oldSourceStrSize);
oldDestinationStr=(char *)malloc(sizeof(char) * oldDestinationStrSize);
PsychGetAlphaBlendingFactorStringFromConstant(oldSource, oldSoureStr);
PsychGetAlphaBlendingFactorStringFromConstant(oldDestination, oldDestinationStr);
PsychCopyOutCharArg(1, kPsychArgOptional, oldSoureStr);
PsychCopyOutCharArg(2, kPsychArgOptional, oldDestinationStr);
free((void *)oldSoureStr);
free((void *)oldDestinationStr);
//Get the new settings if they are present and set them.
newSource=oldSource;
newDestination=oldDestination;
isSourceSupplied= PsychAllocInCharArg(2, kPsychArgOptional, &newSourceStr);
isDestinationSupplied= PsychAllocInCharArg(3, kPsychArgOptional, &newDestinationStr);
if(isSourceSupplied){
isSourceStringValid=PsychGetAlphaBlendingFactorConstantFromString(newSourceStr, &newSource);
if(!isSourceStringValid) PsychErrorExitMsg(PsychError_user, "Supplied string argument 'sourceFactorNew' is invalid");
isSourceChoiceValid=PsychValidateBlendingConstantForSource(newSource);
if(!isSourceChoiceValid) PsychErrorExitMsg(PsychError_user, "The blending factor supplied for the source is only valid only for the destination");
}
if(isDestinationSupplied){
isDestinationStringValid=PsychGetAlphaBlendingFactorConstantFromString(newDestinationStr, &newDestination);
if(!isDestinationStringValid) PsychErrorExitMsg(PsychError_user, "Supplied string argument 'destinationFactorNew' is invalid");
isDestinationChoiceValid=PsychValidateBlendingConstantForDestination(newDestination);
if(!isDestinationChoiceValid) PsychErrorExitMsg(PsychError_user, "The blending factor supplied for the destination is only valid only for the source");
}
PsychStoreAlphaBlendingFactorsForWindow(windowRecord, newSource, newDestination);
// Check if alpha blending is possible for this windowRecord:
if ((newSource != GL_ONE || newDestination != GL_ZERO) && !((windowRecord->bpc < 16) || (windowRecord->bpc == 16 && (windowRecord->gfxcaps & kPsychGfxCapFPBlend16)) || (windowRecord->bpc == 32 && (windowRecord->gfxcaps & kPsychGfxCapFPBlend32)))) {
// Nope. Alpha blending requested but not possible for this windowRecord with this gfx-hardware.
if (PsychPrefStateGet_Verbosity() > 1) {
printf("PTB-WARNING: Screen('Blendfunction') called to enable alpha-blending on a window (handle=%i) which doesn't support\n", windowRecord->windowIndex);
printf("PTB-WARNING: alpha-blending at its current color resolution of %i bits per color component on your hardware.\n", windowRecord->bpc);
printf("PTB-WARNING: Won't enable blending. Either lower the color resolution of the window (see help PsychImaging) or\n");
printf("PTB-WARNING: upgrade your graphics hardware.\n\n");
}
}
// Create return array with encoded old colormask:
PsychAllocOutDoubleMatArg(3, kPsychArgOptional, 1, 4, 1, &oldColorMask);
oldColorMask[0] = (windowRecord->colorMask[0]) ? 1 : 0;
oldColorMask[1] = (windowRecord->colorMask[1]) ? 1 : 0;
oldColorMask[2] = (windowRecord->colorMask[2]) ? 1 : 0;
oldColorMask[3] = (windowRecord->colorMask[3]) ? 1 : 0;
// Any new colormask provided?
if (PsychAllocInDoubleMatArg(4, kPsychArgOptional, &m, &n, &p, &newColorMask)) {
// Yes. Assign it:
if (p!=1 || m*n != 4) PsychErrorExitMsg(PsychError_user, "The colorMaskNew argument must be a 4 element row- or column vector!");
windowRecord->colorMask[0] = (newColorMask[0] > 0) ? GL_TRUE : GL_FALSE;
windowRecord->colorMask[1] = (newColorMask[1] > 0) ? GL_TRUE : GL_FALSE;
windowRecord->colorMask[2] = (newColorMask[2] > 0) ? GL_TRUE : GL_FALSE;
windowRecord->colorMask[3] = (newColorMask[3] > 0) ? GL_TRUE : GL_FALSE;
}
return(PsychError_none);
}
PsychError SCREENPreference(void)
{
PsychArgFormatType arg1Type;
char *preferenceName, *newFontName;
const char *tableCreator, *oldDefaultFontName;
Boolean preferenceNameArgumentValid, booleanInput, ignoreCase, tempFlag, textAlphaBlendingFlag, suppressAllWarningsFlag;
int numInputArgs, i, newFontStyleNumber, newFontSize, tempInt;
double returnDoubleValue, inputDoubleValue;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for superfluous or missing arguments
PsychErrorExit(PsychCapNumInputArgs(3));
PsychErrorExit(PsychRequireNumInputArgs(1));
PsychErrorExit(PsychCapNumOutputArgs(1));
numInputArgs=PsychGetNumInputArgs();
arg1Type=PsychGetArgType(1);
preferenceNameArgumentValid=FALSE;
//Cases which require both a window pointer or screen number and preference name. Argument 1 is the wposn and argument 2 is the preference name.
if( numInputArgs >= 2 && (PsychIsScreenNumberArg(1) || PsychIsScreenNumberArg(1)) && PsychGetArgType(2)==PsychArgType_char ){
PsychAllocInCharArg(2, kPsychArgRequired, &preferenceName);
//preferences which require window pointer or screen number argument which we DO NOT support
for(i=0;i<kPsychNumUnsupportedMacVideoPreferences;i++){
if(PsychMatch(preferenceName, unsupportedMacVideoPreferenceNames[i]))
PsychErrorExit(PsychError_unsupportedOS9Preference);
}
//insert here conditionals to act on prefernces which accept a window pointer or screen number argument which we DO support.
PsychErrorExit(PsychError_unrecognizedPreferenceName);
}
//Cases which do not require a wposn. Argument 1 is the preference name. if present Argument 2 is the new value
if(arg1Type==PsychArgType_char){
PsychAllocInCharArg(1, kPsychArgRequired, &preferenceName);
//Preferernces which we do not support and which do not require a wposn
for(i=0;i<kPsychNumUnsupportedMacNonVideoPreferences;i++){
if(PsychMatch(preferenceName, unsupportedMacNonVideoPreferenceNames[i]))
PsychErrorExit(PsychError_unsupportedOS9Preference);
}
//Preferences which we do support
if(PsychMatch(preferenceName, "IgnoreCase")){
ignoreCase=!PsychIsPsychMatchCaseSensitive();
PsychCopyOutFlagArg(1, kPsychArgOptional, ignoreCase);
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &booleanInput);
PsychSetPsychMatchCaseSenstive(!booleanInput);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "Tick0Secs")){
if(PsychCopyInDoubleArg(2, kPsychArgOptional, &inputDoubleValue) && inputDoubleValue==PsychGetNanValue())
PsychEstimateGetSecsValueAtTickCountZero();
returnDoubleValue=PsychGetEstimatedSecsValueAtTickCountZero();
PsychCopyOutDoubleArg(1, kPsychArgOptional, returnDoubleValue);
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "PsychTableVersion")){
if(numInputArgs==2)
PsychErrorExit(PsychError_extraInputArg);
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double)PsychPrefStateGet_PsychTableVersion());
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "PsychTableCreator")){
if(numInputArgs==2)
PsychErrorExit(PsychError_extraInputArg);
tableCreator=PsychPrefStateGet_PsychTableCreator();
PsychCopyOutCharArg(1, kPsychArgOptional, tableCreator);
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "Process")){
if(numInputArgs==2)
PsychErrorExit(PsychError_extraInputArg);
PsychCopyOutDoubleArg(1, kPsychArgOptional, (double)getpid());
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultFontName")){
PsychPrefStateGet_DefaultFontName(&oldDefaultFontName);
PsychCopyOutCharArg(1, kPsychArgOptional, oldDefaultFontName);
if(numInputArgs==2){
PsychAllocInCharArg(2, kPsychArgRequired, &newFontName);
PsychPrefStateSet_DefaultFontName(newFontName);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultFontStyle")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_DefaultTextStyle());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &newFontStyleNumber);
PsychPrefStateSet_DefaultTextStyle(newFontStyleNumber);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultTextYPositionIsBaseline")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_TextYPositionIsBaseline());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_TextYPositionIsBaseline(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DefaultFontSize")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_DefaultTextSize());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &newFontSize);
PsychPrefStateSet_DefaultTextSize(newFontSize);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "DebugMakeTexture")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_DebugMakeTexture());
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &tempFlag);
PsychPrefStateSet_DebugMakeTexture(tempFlag);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "SkipSyncTests")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_SkipSyncTests());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_SkipSyncTests(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "VisualDebugLevel")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_VisualDebugLevel());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_VisualDebugLevel(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "VBLTimestampingMode")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_VBLTimestampingMode());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_VBLTimestampingMode(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "ConserveVRAM")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_ConserveVRAM());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_ConserveVRAM(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "Verbosity")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_Verbosity());
if(numInputArgs==2){
PsychCopyInIntegerArg(2, kPsychArgRequired, &tempInt);
PsychPrefStateSet_Verbosity(tempInt);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "EmulateOldPTB")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_EmulateOldPTB());
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &tempFlag);
PsychPrefStateSet_EmulateOldPTB(tempFlag);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "Enable3DGraphics")){
PsychCopyOutDoubleArg(1, kPsychArgOptional, PsychPrefStateGet_3DGfx());
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &tempFlag);
PsychPrefStateSet_3DGfx(tempFlag);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "TextAlphaBlending")){
textAlphaBlendingFlag=PsychPrefStateGet_TextAlphaBlending();
PsychCopyOutFlagArg(1, kPsychArgOptional, textAlphaBlendingFlag);
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &booleanInput);
PsychPrefStateSet_TextAlphaBlending(booleanInput);
}
preferenceNameArgumentValid=TRUE;
}else
if(PsychMatch(preferenceName, "SuppressAllWarnings")){
suppressAllWarningsFlag=PsychPrefStateGet_SuppressAllWarnings();
PsychCopyOutFlagArg(1, kPsychArgOptional, suppressAllWarningsFlag);
if(numInputArgs==2){
PsychCopyInFlagArg(2, kPsychArgRequired, &booleanInput);
PsychPrefStateSet_SuppressAllWarnings(booleanInput);
}
preferenceNameArgumentValid=TRUE;
}else
PsychErrorExit(PsychError_unrecognizedPreferenceName);
}
if(!preferenceNameArgumentValid)
PsychErrorExitMsg(PsychError_user, "Invalid arguments to preferences command");
return(PsychError_none);
}
/*
PsychInitFontList()
Build a list of records describing installed fonts.
*/
void PsychInitFontList(void)
{
ATSFontRef tempATSFontRef;
CTFontRef tempCTFontRef;
//for font structures
PsychFontStructPtrType fontListHead, fontRecord, previousFontRecord;
//for ATI font iteration
ATSFontIterator fontIterator;
OSStatus halt;
//for font field names
CFStringRef cfFontName;
int i, j;
psych_bool resultOK;
//for font file
OSStatus osStatus;
FSSpec fontFileSpec;
FSRef fontFileRef;
//for the font metrics
ATSFontMetrics horizontalMetrics;
ATSFontMetrics verticalMetrics;
//for info from Font Manager
FMFontStyle fmStyle;
OSStatus fmStatus;
Str255 fmFontFamilyNamePString;
//whatever
Str255 fontFamilyQuickDrawNamePString;
TextEncoding textEncoding;
OSStatus scriptInfoOK;
ScriptCode scriptCode;
LangCode languageCode;
OSStatus localOK;
LocaleRef locale;
psych_bool trouble = FALSE;
psych_bool reportTrouble = TRUE;
fontListHead=PsychFontListHeadKeeper(FALSE, NULL); //get the font list head.
if(fontListHead) PsychErrorExitMsg(PsychError_internal, "Attempt to set new font list head when one is already set.");
fontRecord = NULL;
fontIterator = NULL;
halt = ATSFontIteratorCreate(PSYCH_ATS_ITERATOR_CONTEXT, NULL, NULL, PSYCH_ATS_ITERATOR_SCOPE, &fontIterator);
i = 0;
while (halt==noErr) {
// Give repair hints early. Experience shows we might crash during enumeration of a
// corrupt OSX font database, so make sure we get out the helpful message as early as possible. Doing
// this (just) at the end of enumeration might be too late - we might never get there...
// However, allow user to suppress the hint, as this happens quite regularly on 32-Bit OSX:
if (reportTrouble && trouble && PsychPrefStateGet_Verbosity() > 2) {
reportTrouble = FALSE; // Only show this hint once, not for every invalid font.
printf("\nPTB-HINT: =============================================================================================================================\n");
printf("PTB-HINT: At least one font on this system has issues and can not be accessed by Psychtoolbox. If you want to know which font(s) make\n");
printf("PTB-HINT: trouble, do a 'clear all' and rerun your script with Screen()'s verbosity level set to at least 4 for more diagnostic output.\n");
printf("PTB-HINT: The following tips may help you to resolve font issues:\n");
printf("PTB-HINT: Go to the Application folder and open the 'Font Book' application. It allows you to check and repair your font database.\n");
printf("PTB-HINT: Run its 'Validate' function on all installed fonts. Another thing you could try is downloading and running the free\n");
printf("PTB-HINT: FontNuke application (Google will find it for you) to regenerate corrupt OSX font caches. Good luck!\n");
printf("PTB-HINT: You can suppress this hint by choosing a verbosity level for Screen() of 2 or lower.\n");
printf("PTB-HINT: =============================================================================================================================\n\n");
}
halt=ATSFontIteratorNext(fontIterator, &tempATSFontRef);
if(halt==noErr){
//create a new font font structure. Set the next field to NULL as soon as we allocate the font so that if
//we break with an error then we can find the end when we walk down the linked list.
fontRecord=(PsychFontStructPtrType) calloc(1, sizeof(PsychFontStructType));
fontRecord->next=NULL;
//Get FM and ATS font and font family references from the ATS font reference, which we get from iteration.
fontRecord->fontATSRef=tempATSFontRef;
fontRecord->fontFMRef=FMGetFontFromATSFontRef(fontRecord->fontATSRef);
// Create CTFont from given ATSFontRef. Available since OSX 10.5
tempCTFontRef = CTFontCreateWithPlatformFont(fontRecord->fontATSRef, 0.0, NULL, NULL);
if (tempCTFontRef) {
// Get font family name from CTFont:
CFStringRef cfFamilyName = CTFontCopyFamilyName(tempCTFontRef);
// Retrieve symbolic traits of font -- the closest equivalent of the fmStyle from the
// good'ol fontManager:
CTFontSymbolicTraits ctTraits = CTFontGetSymbolicTraits(tempCTFontRef);
// Remap new trait constants to old constants for later Screen('TextStyle') matching.
fmStyle = 0;
if (ctTraits & kCTFontBoldTrait) fmStyle |= 1;
if (ctTraits & kCTFontItalicTrait) fmStyle |= 2;
if (ctTraits & kCTFontCondensedTrait) fmStyle |= 32;
if (ctTraits & kCTFontExpandedTrait) fmStyle |= 64;
// CTFont no longer needed:
CFRelease(tempCTFontRef);
// Convert to C-String and assign:
resultOK = cfFamilyName && CFStringGetCString(cfFamilyName, (char*) fontRecord->fontFMFamilyName, 255, kCFStringEncodingASCII);
if(!resultOK){
if (cfFamilyName) CFRelease(cfFamilyName);
if (PsychPrefStateGet_Verbosity() > 3) printf("PTB-WARNING: In font initialization: Failed to retrieve font family name for font... Defective font?!? Skipped this entry...\n");
trouble = TRUE;
continue;
}
// Get ATSRef for font family:
fontRecord->fontFamilyATSRef = ATSFontFamilyFindFromName(cfFamilyName, kATSOptionFlagsDefault);
CFRelease(cfFamilyName);
}
else {
if (PsychPrefStateGet_Verbosity() > 3) printf("PTB-WARNING: In font initialization: Failed to retrieve CTFontRef for font... Defective font?!? Skipped this entry...\n");
trouble = TRUE;
continue;
}
//get the font name and set the the corresponding field of the struct
if (ATSFontGetName(fontRecord->fontATSRef, kATSOptionFlagsDefault, &cfFontName)!=noErr) {
if (PsychPrefStateGet_Verbosity() > 3) printf("PTB-WARNING: In font initialization: Failed to query font name in ATSFontGetName! OS-X font handling screwed up?!? Skipped this entry...\n");
trouble = TRUE;
continue;
}
resultOK = cfFontName && CFStringGetCString(cfFontName, (char*) fontRecord->fontFMName, 255, kCFStringEncodingASCII);
if(!resultOK){
if (cfFontName) CFRelease(cfFontName);
if (PsychPrefStateGet_Verbosity() > 3) printf("PTB-WARNING: In font initialization: Failed to convert fontFMName CF string to char string. Defective font?!? Skipped this entry...\n");
trouble = TRUE;
continue;
}
CFRelease(cfFontName);
//get the font postscript name and set the corresponding field of the struct
if (ATSFontGetPostScriptName(fontRecord->fontATSRef, kATSOptionFlagsDefault, &cfFontName)!=noErr) {
if (PsychPrefStateGet_Verbosity() > 3) printf("PTB-WARNING: In font initialization: The following font makes trouble: %s. Please REMOVE the offending font file from your font folders and restart Matlab. Skipped entry for now...\n", fontRecord->fontFMName);
trouble = TRUE;
continue;
}
resultOK = cfFontName && CFStringGetCString(cfFontName, (char*) fontRecord->fontPostScriptName, 255, kCFStringEncodingASCII); //kCFStringEncodingASCII matches MATLAB for 0-127
if(!resultOK){
if (cfFontName) CFRelease(cfFontName);
if (PsychPrefStateGet_Verbosity() > 3) printf("PTB-WARNING: In font initialization: Failed to convert fontPostScriptName CF string to char string for font %s. Defective font?!? Skipped this entry...\n", fontRecord->fontFMName);
trouble = TRUE;
continue;
}
CFRelease(cfFontName);
// Get the QuickDraw name of the font:
fontRecord->fontFamilyQuickDrawName[0] = 0;
fontFamilyQuickDrawNamePString[0] = 0;
ATSFontFamilyGetQuickDrawName(fontRecord->fontFamilyATSRef, fontFamilyQuickDrawNamePString);
for (j = 0; j < fontFamilyQuickDrawNamePString[0]; j++) fontRecord->fontFamilyQuickDrawName[j] = fontFamilyQuickDrawNamePString[j+1];
fontRecord->fontFamilyQuickDrawName[j] = 0;
osStatus = ATSFontGetFileReference(fontRecord->fontATSRef, &fontFileRef);
if(osStatus != noErr) {
if (PsychPrefStateGet_Verbosity() > 3) printf("PTB-WARNING: In font initialization: Failed to get the font file specifier for font %s. Defective font?!? Skipped this entry...\n", fontRecord->fontFMName);
trouble = TRUE;
continue;
}
osStatus= FSRefMakePath(&fontFileRef, (UInt8*) fontRecord->fontFile, (UInt32)(kPsychMaxFontFileNameChars - 1));
if(osStatus!=noErr){
if (PsychPrefStateGet_Verbosity() > 3) printf("PTB-WARNING: In font initialization: Failed to get the font file path for font %s. Defective font?!? Skipped this entry...\n", fontRecord->fontFMName);
trouble = TRUE;
continue;
}
//get the font metrics of this font.
//Explicit copy between fields to make it clear what is going one, will likely have to mix & match between native and Psych structures for different
//platforms.
ATSFontGetHorizontalMetrics(fontRecord->fontATSRef, kATSOptionFlagsDefault, &horizontalMetrics);
ATSFontGetVerticalMetrics(fontRecord->fontATSRef, kATSOptionFlagsDefault, &verticalMetrics);
//horizontal
fontRecord->horizontalMetrics.ascent= horizontalMetrics.ascent;
fontRecord->horizontalMetrics.descent= horizontalMetrics.descent;
fontRecord->horizontalMetrics.leading= horizontalMetrics.leading;
fontRecord->horizontalMetrics.avgAdvanceWidth= horizontalMetrics.avgAdvanceWidth;
fontRecord->horizontalMetrics.minLeftSideBearing= horizontalMetrics.minLeftSideBearing;
fontRecord->horizontalMetrics.minRightSideBearing= horizontalMetrics.minRightSideBearing;
fontRecord->horizontalMetrics.stemWidth= horizontalMetrics.stemWidth;
fontRecord->horizontalMetrics.stemHeight= horizontalMetrics.stemHeight;
fontRecord->horizontalMetrics.capHeight= horizontalMetrics.capHeight;
fontRecord->horizontalMetrics.xHeight= horizontalMetrics.xHeight;
fontRecord->horizontalMetrics.italicAngle= horizontalMetrics.italicAngle;
fontRecord->horizontalMetrics.underlinePosition= horizontalMetrics.underlinePosition;
fontRecord->horizontalMetrics.underlineThickness= horizontalMetrics.underlineThickness;
fontRecord->horizontalMetrics.underlineThickness= horizontalMetrics.underlineThickness;
//vertical
fontRecord->verticalMetrics.ascent= verticalMetrics.ascent;
fontRecord->verticalMetrics.descent= verticalMetrics.descent;
fontRecord->verticalMetrics.leading= verticalMetrics.leading;
fontRecord->verticalMetrics.avgAdvanceWidth= verticalMetrics.avgAdvanceWidth;
fontRecord->verticalMetrics.minLeftSideBearing= verticalMetrics.minLeftSideBearing;
fontRecord->verticalMetrics.minRightSideBearing= verticalMetrics.minRightSideBearing;
fontRecord->verticalMetrics.stemWidth= verticalMetrics.stemWidth;
fontRecord->verticalMetrics.stemHeight= verticalMetrics.stemHeight;
fontRecord->verticalMetrics.capHeight= verticalMetrics.capHeight;
fontRecord->verticalMetrics.xHeight= verticalMetrics.xHeight;
fontRecord->verticalMetrics.italicAngle= verticalMetrics.italicAngle;
fontRecord->verticalMetrics.underlinePosition= verticalMetrics.underlinePosition;
fontRecord->verticalMetrics.underlineThickness= verticalMetrics.underlineThickness;
fontRecord->verticalMetrics.underlineThickness= verticalMetrics.underlineThickness;
fontRecord->fontFMStyle=fmStyle;
fontRecord->fontFMNumStyles=PsychFindNumFMFontStylesFromStyle(fmStyle);
fontRecord->fontFMNumStyles= fontRecord->fontFMNumStyles ? fontRecord->fontFMNumStyles : 1; //because the name is "normal" even if there are no styles.
// Get the locale info which is a property of the font family:
// No error checking is done here, because many (most?) fonts miss the information,
// so we would error-out all the time and this is non-critical for us:
textEncoding=ATSFontFamilyGetEncoding(fontRecord->fontFamilyATSRef);
scriptInfoOK=RevertTextEncodingToScriptInfo(textEncoding, &scriptCode, &languageCode, NULL);
localOK=LocaleRefFromLangOrRegionCode(languageCode, kTextRegionDontCare, &locale);
localOK |= LocaleRefGetPartString(locale, kLocaleLanguageMask, 255, (char*) fontRecord->locale.language); fontRecord->locale.language[255]='\0';
localOK |= LocaleRefGetPartString(locale, kLocaleLanguageVariantMask, 255, (char*) fontRecord->locale.languageVariant); fontRecord->locale.languageVariant[255]='\0';
localOK |= LocaleRefGetPartString(locale, kLocaleRegionMask, 255, (char*) fontRecord->locale.region); fontRecord->locale.region[255]='\0';
localOK |= LocaleRefGetPartString(locale, kLocaleRegionVariantMask, 255, (char*) fontRecord->locale.regionVariant); fontRecord->locale.regionVariant[255]='\0';
localOK |= LocaleRefGetPartString(locale, kLocaleAllPartsMask, 255, (char*) fontRecord->locale.fullName); fontRecord->locale.fullName[255]='\0';
// Init for fontRecord (nearly) finished.
// Set this fontRecord as head of font-list, or enqueue it in existing list:
if(i==0) {
PsychFontListHeadKeeper(TRUE, fontRecord);
}
else {
previousFontRecord->next=fontRecord;
}
// Set the font number field of the struct
fontRecord->fontNumber=i+1;
// Increment the font index and update the next font pointer
++i;
previousFontRecord=fontRecord;
}else if(halt == kATSIterationScopeModified){
//exit because the font database changed during this loop.
PsychFreeFontList();
if (fontIterator) ATSFontIteratorRelease(&fontIterator);
PsychErrorExitMsg(PsychError_system, "The system font database was modified during font list setup. Please 'clear all' and restart your script.");
}
// Next parse iteration in system font database...
}
if (fontIterator) ATSFontIteratorRelease(&fontIterator);
if (halt != kATSIterationCompleted) {
PsychFreeFontList();
trouble = TRUE;
if (PsychPrefStateGet_Verbosity() > 0) printf("PTB-ERROR: Font iteration during enumeration terminated prematurely. OS-X Font database corrupted?!?");
}
// Did we get a hand on at least one font?
if (i==0) {
PsychFreeFontList();
trouble = TRUE;
if (PsychPrefStateGet_Verbosity() > 0) {
printf("PTB-ERROR: In font initialization: Could not even retrieve one valid font from the system! The OS-X font database must be corrupt.\n");
printf("PTB-ERROR: Will try to continue but will likely abort if your code tries to call any of the font handling or text drawing functions.\n");
}
}
// If there was some trouble and it wasn't reported yet, then report it now at the end if either
// verbosity level is at least 3 (our default level), or if the error was especially serious and
// lead to a premature abortion of font iteration or complete failure to find even a single valid
// font. In the latter cases, we must report the trouble, regardless of verbosity level. In the
// former case, probably only a few fonts had trouble, so we allow the user to suppress such messages
// by lowering the verbosity to warning level or lower:
if (reportTrouble && trouble && ((PsychPrefStateGet_Verbosity() > 2) || (halt != kATSIterationCompleted) || (i == 0))) {
printf("PTB-HINT: =============================================================================================================================\n");
printf("PTB-HINT: At least one font on this system has issues and can not be accessed by Psychtoolbox. If you want to know which font(s) make\n");
printf("PTB-HINT: trouble, do a 'clear all' and rerun your script with Screen()'s verbosity level set to at least 4 for more diagnostic output.\n");
printf("PTB-HINT: The following tips may help you to resolve font issues:\n");
printf("PTB-HINT: Go to the Application folder and open the 'Font Book' application. It allows you to check and repair your font database.\n");
printf("PTB-HINT: Run its 'Validate' function on all installed fonts. Another thing you could try is downloading and running the free\n");
printf("PTB-HINT: FontNuke application (Google will find it for you) to regenerate corrupt OSX font caches. Good luck!\n");
printf("PTB-HINT: In case of non-fatal errors, you can suppress this hint by choosing a verbosity level for Screen() of 2 or lower.\n");
printf("PTB-HINT: =============================================================================================================================\n");
}
// Font database ready for use.
return;
}
