glfw/src/x11_monitor.c

482 lines
14 KiB
C
Raw Normal View History

//========================================================================
// GLFW 3.1 X11 - www.glfw.org
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would
// be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not
// be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
// distribution.
//
//========================================================================
#include "internal.h"
2012-09-12 19:04:24 +00:00
#include <limits.h>
#include <stdlib.h>
#include <string.h>
2014-02-13 13:25:26 +00:00
// Check whether the display mode should be included in enumeration
//
static GLboolean modeIsGood(const XRRModeInfo* mi)
{
return (mi->modeFlags & RR_Interlace) == 0;
}
// Calculates the refresh rate, in Hz, from the specified RandR mode info
//
2013-05-30 13:52:42 +00:00
static int calculateRefreshRate(const XRRModeInfo* mi)
{
2014-02-13 13:25:26 +00:00
if (mi->hTotal && mi->vTotal)
return (int) ((double) mi->dotClock / ((double) mi->hTotal * (double) mi->vTotal));
else
2013-05-30 13:52:42 +00:00
return 0;
}
2014-02-13 13:25:26 +00:00
// Returns the mode info for a RandR mode XID
//
2013-05-30 13:52:42 +00:00
static const XRRModeInfo* getModeInfo(const XRRScreenResources* sr, RRMode id)
{
int i;
for (i = 0; i < sr->nmode; i++)
{
if (sr->modes[i].id == id)
return sr->modes + i;
}
return NULL;
}
2014-02-13 13:25:26 +00:00
// Convert RandR mode info to GLFW video mode
//
static GLFWvidmode vidmodeFromModeInfo(const XRRModeInfo* mi,
const XRRCrtcInfo* ci)
2014-02-13 13:25:26 +00:00
{
GLFWvidmode mode;
if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
{
mode.width = mi->height;
mode.height = mi->width;
}
else
{
mode.width = mi->width;
mode.height = mi->height;
}
2014-02-13 13:25:26 +00:00
mode.refreshRate = calculateRefreshRate(mi);
_glfwSplitBPP(DefaultDepth(_glfw.x11.display, _glfw.x11.screen),
&mode.redBits, &mode.greenBits, &mode.blueBits);
return mode;
}
2013-05-30 13:52:42 +00:00
2012-09-12 19:04:24 +00:00
//////////////////////////////////////////////////////////////////////////
////// GLFW internal API //////
//////////////////////////////////////////////////////////////////////////
// Set the current video mode for the specified monitor
2013-02-04 12:22:10 +00:00
//
2014-03-10 11:34:15 +00:00
GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
2012-09-12 19:04:24 +00:00
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
2012-09-12 19:04:24 +00:00
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
2013-05-30 18:42:50 +00:00
XRROutputInfo* oi;
2014-02-13 13:25:26 +00:00
GLFWvidmode current;
const GLFWvidmode* best;
RRMode native = None;
int i;
best = _glfwChooseVideoMode(monitor, desired);
_glfwPlatformGetVideoMode(monitor, &current);
if (_glfwCompareVideoModes(&current, best) == 0)
2014-03-10 11:34:15 +00:00
return GL_TRUE;
2012-09-12 19:04:24 +00:00
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
2013-05-30 18:42:50 +00:00
oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);
2012-09-12 19:04:24 +00:00
2014-02-13 13:25:26 +00:00
for (i = 0; i < oi->nmode; i++)
2012-09-12 19:04:24 +00:00
{
2014-02-13 13:25:26 +00:00
const XRRModeInfo* mi = getModeInfo(sr, oi->modes[i]);
if (!modeIsGood(mi))
2013-05-30 18:42:50 +00:00
continue;
const GLFWvidmode mode = vidmodeFromModeInfo(mi, ci);
2014-02-13 13:25:26 +00:00
if (_glfwCompareVideoModes(best, &mode) == 0)
{
2014-02-13 13:25:26 +00:00
native = mi->id;
break;
}
2012-09-12 19:04:24 +00:00
}
2014-02-13 13:25:26 +00:00
if (native)
{
if (monitor->x11.oldMode == None)
monitor->x11.oldMode = ci->mode;
XRRSetCrtcConfig(_glfw.x11.display,
sr, monitor->x11.crtc,
CurrentTime,
ci->x, ci->y,
native,
ci->rotation,
ci->outputs,
ci->noutput);
}
2012-09-12 19:04:24 +00:00
2013-05-30 18:42:50 +00:00
XRRFreeOutputInfo(oi);
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
2014-03-10 11:34:15 +00:00
if (!native)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Monitor mode list changed");
return GL_FALSE;
}
}
2014-03-10 11:34:15 +00:00
return GL_TRUE;
2012-09-12 19:04:24 +00:00
}
// Restore the saved (original) video mode for the specified monitor
2013-02-04 12:22:10 +00:00
//
void _glfwRestoreVideoMode(_GLFWmonitor* monitor)
2012-09-12 19:04:24 +00:00
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
2012-09-12 19:04:24 +00:00
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
2012-09-12 19:04:24 +00:00
if (monitor->x11.oldMode == None)
return;
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
2012-09-12 19:04:24 +00:00
XRRSetCrtcConfig(_glfw.x11.display,
sr, monitor->x11.crtc,
CurrentTime,
ci->x, ci->y,
monitor->x11.oldMode,
ci->rotation,
ci->outputs,
ci->noutput);
2012-09-12 19:04:24 +00:00
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
monitor->x11.oldMode = None;
2012-09-12 19:04:24 +00:00
}
}
2012-08-16 17:11:31 +00:00
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
2013-06-09 11:07:23 +00:00
_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
{
int i, found = 0;
2012-09-12 17:35:52 +00:00
_GLFWmonitor** monitors = NULL;
2011-10-03 16:48:59 +00:00
2013-06-09 11:07:23 +00:00
*count = 0;
2013-01-12 17:10:18 +00:00
if (_glfw.x11.randr.available)
{
2012-12-22 22:35:45 +00:00
RROutput primary;
2012-09-12 17:35:52 +00:00
XRRScreenResources* sr;
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
primary = XRRGetOutputPrimary(_glfw.x11.display, _glfw.x11.root);
2012-12-22 22:35:45 +00:00
monitors = calloc(sr->ncrtc, sizeof(_GLFWmonitor*));
for (i = 0; i < sr->ncrtc; i++)
{
int j;
2012-09-12 17:35:52 +00:00
XRROutputInfo* oi;
XRRCrtcInfo* ci;
RROutput output;
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, sr->crtcs[i]);
2013-06-12 17:40:55 +00:00
if (ci->noutput == 0)
{
XRRFreeCrtcInfo(ci);
continue;
}
2013-02-17 12:57:25 +00:00
output = ci->outputs[0];
for (j = 0; j < ci->noutput; j++)
{
2013-02-17 12:57:25 +00:00
if (ci->outputs[j] == primary)
{
output = primary;
break;
}
}
oi = XRRGetOutputInfo(_glfw.x11.display, sr, output);
2012-09-12 17:35:52 +00:00
if (oi->connection != RR_Connected)
{
XRRFreeOutputInfo(oi);
XRRFreeCrtcInfo(ci);
2012-09-12 17:35:52 +00:00
continue;
}
monitors[found] = _glfwAllocMonitor(oi->name,
oi->mm_width, oi->mm_height);
2012-09-12 17:35:52 +00:00
2013-06-09 11:07:23 +00:00
monitors[found]->x11.output = output;
monitors[found]->x11.crtc = oi->crtc;
2012-09-12 17:35:52 +00:00
XRRFreeOutputInfo(oi);
XRRFreeCrtcInfo(ci);
2012-09-12 17:35:52 +00:00
2013-06-09 11:07:23 +00:00
found++;
}
XRRFreeScreenResources(sr);
2013-06-09 11:07:23 +00:00
for (i = 0; i < found; i++)
{
if (monitors[i]->x11.output == primary)
{
_GLFWmonitor* temp = monitors[0];
monitors[0] = monitors[i];
monitors[i] = temp;
break;
}
}
2013-06-09 11:07:23 +00:00
if (found == 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: RandR monitor support seems broken");
_glfw.x11.randr.monitorBroken = GL_TRUE;
2013-06-09 11:07:23 +00:00
free(monitors);
monitors = NULL;
}
}
if (!monitors)
2013-01-12 17:10:18 +00:00
{
monitors = calloc(1, sizeof(_GLFWmonitor*));
monitors[0] = _glfwAllocMonitor("Display",
DisplayWidthMM(_glfw.x11.display,
_glfw.x11.screen),
DisplayHeightMM(_glfw.x11.display,
_glfw.x11.screen));
found = 1;
2013-01-12 17:10:18 +00:00
}
*count = found;
2012-09-12 17:35:52 +00:00
return monitors;
}
2013-04-22 12:43:13 +00:00
GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
{
return first->x11.crtc == second->x11.crtc;
}
2013-02-20 15:00:53 +00:00
void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
2013-02-20 15:00:53 +00:00
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
2013-02-20 15:00:53 +00:00
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
if (xpos)
*xpos = ci->x;
if (ypos)
*ypos = ci->y;
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
}
}
2012-09-12 19:04:24 +00:00
GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
{
GLFWvidmode* result;
2012-12-27 20:13:04 +00:00
*found = 0;
2012-09-12 19:04:24 +00:00
2012-12-27 20:13:04 +00:00
// Build array of available resolutions
2012-09-12 19:04:24 +00:00
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
2012-12-27 20:13:04 +00:00
{
int i, j;
2012-12-27 20:13:04 +00:00
XRRScreenResources* sr;
XRRCrtcInfo* ci;
XRROutputInfo* oi;
2012-09-12 19:04:24 +00:00
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);
2012-09-12 19:04:24 +00:00
result = calloc(oi->nmode, sizeof(GLFWvidmode));
2012-09-12 19:04:24 +00:00
for (i = 0; i < oi->nmode; i++)
2012-09-12 19:04:24 +00:00
{
2013-05-30 13:52:42 +00:00
const XRRModeInfo* mi = getModeInfo(sr, oi->modes[i]);
2014-02-13 13:25:26 +00:00
if (!modeIsGood(mi))
continue;
2012-09-12 19:04:24 +00:00
const GLFWvidmode mode = vidmodeFromModeInfo(mi, ci);
2012-09-12 19:04:24 +00:00
2012-12-27 20:13:04 +00:00
for (j = 0; j < *found; j++)
{
if (result[j].width == mode.width &&
2013-05-30 13:52:42 +00:00
result[j].height == mode.height &&
result[j].refreshRate == mode.refreshRate)
2012-12-27 20:13:04 +00:00
{
break;
}
}
2012-09-12 19:04:24 +00:00
2012-12-27 20:13:04 +00:00
if (j < *found)
{
// This is a duplicate, so skip it
continue;
}
2012-09-12 19:04:24 +00:00
2012-12-27 20:13:04 +00:00
result[*found] = mode;
2012-09-12 19:04:24 +00:00
(*found)++;
}
2012-12-27 20:13:04 +00:00
XRRFreeOutputInfo(oi);
XRRFreeCrtcInfo(ci);
2012-12-27 20:13:04 +00:00
XRRFreeScreenResources(sr);
2012-09-12 19:04:24 +00:00
}
2013-01-12 17:10:18 +00:00
else
2012-12-27 20:13:04 +00:00
{
*found = 1;
result = calloc(1, sizeof(GLFWvidmode));
2014-02-13 13:25:26 +00:00
_glfwPlatformGetVideoMode(monitor, result);
2012-12-27 20:13:04 +00:00
}
2012-09-12 19:04:24 +00:00
return result;
}
void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
*mode = vidmodeFromModeInfo(getModeInfo(sr, ci->mode), ci);
2013-05-30 13:52:42 +00:00
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
}
else
{
mode->width = DisplayWidth(_glfw.x11.display, _glfw.x11.screen);
mode->height = DisplayHeight(_glfw.x11.display, _glfw.x11.screen);
2013-05-30 13:52:42 +00:00
mode->refreshRate = 0;
2014-02-13 13:25:26 +00:00
_glfwSplitBPP(DefaultDepth(_glfw.x11.display, _glfw.x11.screen),
&mode->redBits, &mode->greenBits, &mode->blueBits);
}
2012-09-12 19:04:24 +00:00
}
2014-08-18 10:31:48 +00:00
void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
{
const size_t size = XRRGetCrtcGammaSize(_glfw.x11.display,
monitor->x11.crtc);
XRRCrtcGamma* gamma = XRRGetCrtcGamma(_glfw.x11.display,
monitor->x11.crtc);
_glfwAllocGammaArrays(ramp, size);
memcpy(ramp->red, gamma->red, size * sizeof(unsigned short));
memcpy(ramp->green, gamma->green, size * sizeof(unsigned short));
memcpy(ramp->blue, gamma->blue, size * sizeof(unsigned short));
XRRFreeGamma(gamma);
}
else if (_glfw.x11.vidmode.available)
{
int size;
XF86VidModeGetGammaRampSize(_glfw.x11.display, _glfw.x11.screen, &size);
_glfwAllocGammaArrays(ramp, size);
XF86VidModeGetGammaRamp(_glfw.x11.display,
_glfw.x11.screen,
ramp->size, ramp->red, ramp->green, ramp->blue);
}
}
void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
{
XRRCrtcGamma* gamma = XRRAllocGamma(ramp->size);
memcpy(gamma->red, ramp->red, ramp->size * sizeof(unsigned short));
memcpy(gamma->green, ramp->green, ramp->size * sizeof(unsigned short));
memcpy(gamma->blue, ramp->blue, ramp->size * sizeof(unsigned short));
XRRSetCrtcGamma(_glfw.x11.display, monitor->x11.crtc, gamma);
XRRFreeGamma(gamma);
}
else if (_glfw.x11.vidmode.available)
{
XF86VidModeSetGammaRamp(_glfw.x11.display,
_glfw.x11.screen,
ramp->size,
(unsigned short*) ramp->red,
(unsigned short*) ramp->green,
(unsigned short*) ramp->blue);
}
}
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
GLFWAPI RRCrtc glfwGetX11Monitor(GLFWmonitor* handle)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(None);
return monitor->x11.crtc;
}