void iupgtkPushVisualAndColormap(void* visual, void* colormap)
{
GdkColormap* gdk_colormap;
GdkVisual *gdk_visual = gdkx_visual_get(XVisualIDFromVisual((Visual*)visual));
if (colormap)
gdk_colormap = gdk_x11_colormap_foreign_new(gdk_visual, (Colormap)colormap);
else
gdk_colormap = gdk_colormap_new(gdk_visual, FALSE);
gtk_widget_push_colormap(gdk_colormap);
/* gtk_widget_push_visual is now deprecated */
}
static void
na_tray_manager_set_visual_property (NaTrayManager *manager)
{
#ifdef GDK_WINDOWING_X11
GdkDisplay *display;
Visual *xvisual;
Atom visual_atom;
gulong data[1];
if (!manager->invisible || !manager->invisible->window)
return;
/* The visual property is a hint to the tray icons as to what visual they
* should use for their windows. If the X server has RGBA colormaps, then
* we tell the tray icons to use a RGBA colormap and we'll composite the
* icon onto its parents with real transparency. Otherwise, we just tell
* the icon to use our colormap, and we'll do some hacks with parent
* relative backgrounds to simulate transparency.
*/
display = gtk_widget_get_display (manager->invisible);
visual_atom = gdk_x11_get_xatom_by_name_for_display (display,
"_NET_SYSTEM_TRAY_VISUAL");
if (gdk_screen_get_rgba_visual (manager->screen) != NULL &&
gdk_display_supports_composite (display))
{
xvisual = GDK_VISUAL_XVISUAL (gdk_screen_get_rgba_visual (manager->screen));
}
else
{
/* We actually want the visual of the tray where the icons will
* be embedded. In almost all cases, this will be the same as the visual
* of the screen.
*/
GdkColormap *colormap;
colormap = gdk_screen_get_default_colormap (manager->screen);
xvisual = GDK_VISUAL_XVISUAL (gdk_colormap_get_visual (colormap));
}
data[0] = XVisualIDFromVisual (xvisual);
XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
GDK_WINDOW_XWINDOW (manager->invisible->window),
visual_atom,
XA_VISUALID, 32,
PropModeReplace,
(guchar *) &data, 1);
#endif
}
int visual_depth (Screen *screen, Visual *visual)
{
Display *dpy = DisplayOfScreen (screen);
XVisualInfo vi_in, *vi_out;
int out_count, depth;
vi_in.screen = screen_number (screen);
vi_in.visualid = XVisualIDFromVisual (visual);
vi_out = XGetVisualInfo (dpy, VisualScreenMask|VisualIDMask,
&vi_in, &out_count);
if (! vi_out) abort ();
depth = vi_out[0].depth;
XFree ((char *) vi_out);
return depth;
}
void iupgtkPushVisualAndColormap(void* visual, void* colormap)
{
#if GTK_CHECK_VERSION(3, 0, 0)
(void)visual;
(void)colormap;
#else
GdkColormap* gdk_colormap;
#if GTK_CHECK_VERSION(2, 24, 0)
GdkScreen* screen = gdk_screen_get_default();
GdkVisual* gdk_visual = gdk_x11_screen_lookup_visual(screen, XVisualIDFromVisual((Visual*)visual));
#else
GdkVisual* gdk_visual = gdkx_visual_get(XVisualIDFromVisual((Visual*)visual));
#endif
if (colormap)
gdk_colormap = gdk_x11_colormap_foreign_new(gdk_visual, (Colormap)colormap);
else
gdk_colormap = gdk_colormap_new(gdk_visual, FALSE);
gtk_widget_push_colormap(gdk_colormap);
/* gtk_widget_push_visual is now deprecated */
#endif
}
void dump_vinfo(XVisualInfo *vi)
{
//Visual *visual;
//VisualID visualid;
printf("visual ID macro: %i ",(int)XVisualIDFromVisual(vi->visual));
printf("visualid: %i\n",(int)vi->visualid);
printf("screen: %i ",vi->screen);
printf("depth: %i ",vi->depth);
printf("class: %i ",vi->class);
printf("bits per rgb: %i\n",vi->bits_per_rgb);
printf("red mask: %lu ",vi->red_mask);
printf("green mask: %lu ",vi->green_mask);
printf("blue mask: %lu ",vi->blue_mask);
printf("colormap size: %i\n",vi->colormap_size);
}
virtual void Paint2(Draw& w) {
Size sz = GetSize();
w.DrawRect(GetSize(), White());
static GdkColormap* cm = gdk_x11_colormap_foreign_new(
gdkx_visual_get(XVisualIDFromVisual(Xvisual)), Xcolormap);
GdkWindow *gw = gdk_window_foreign_new(w.GetDrawable());
GtkStyle *style = gtk_widget_get_style((GtkWidget *)gtk__parent());
GdkRectangle r;
r.x = r.y = 0;
r.width = r.height = 64;
gtk_paint_box(style, gw,
(GtkStateType)0, (GtkShadowType)0, &r,
(GtkWidget*)GTK().gtk_button_new(), "button",
0, 0, 64, 64);
}
Window::Window (Display& display, int width, int height, ::Visual* visual)
: m_display (display)
, m_colormap (None)
, m_window (None)
, m_visible (false)
{
XSetWindowAttributes swa;
::Display* dpy = m_display.getXDisplay();
::Window root = DefaultRootWindow(dpy);
unsigned long mask = CWBorderPixel | CWEventMask;
if (visual == DE_NULL)
visual = CopyFromParent;
else
{
XVisualInfo info = XVisualInfo();
bool succ = display.getVisualInfo(XVisualIDFromVisual(visual), info);
TCU_CHECK_INTERNAL(succ);
root = RootWindow(dpy, info.screen);
m_colormap = XCreateColormap(dpy, root, visual, AllocNone);
swa.colormap = m_colormap;
mask |= CWColormap;
}
swa.border_pixel = 0;
swa.event_mask = ExposureMask|KeyPressMask|KeyReleaseMask|StructureNotifyMask;
mask |= CWOverrideRedirect;
swa.override_redirect = true;
if (width == glu::RenderConfig::DONT_CARE)
width = DEFAULT_WINDOW_WIDTH;
if (height == glu::RenderConfig::DONT_CARE)
height = DEFAULT_WINDOW_HEIGHT;
m_window = XCreateWindow(dpy, root, 0, 0, width, height, 0,
CopyFromParent, InputOutput, visual, mask, &swa);
TCU_CHECK(m_window);
Atom deleteAtom = m_display.getDeleteAtom();
XSetWMProtocols(dpy, m_window, &deleteAtom, 1);
}
GLXFBConfig GLXGLSupport::getFBConfigFromDrawable(GLXDrawable drawable, unsigned int *width, unsigned int *height)
{
GLXFBConfig fbConfig = 0;
if (GLXEW_VERSION_1_3)
{
int fbConfigAttrib[] = {
GLX_FBCONFIG_ID, 0,
None
};
GLXFBConfig *fbConfigs;
int nElements = 0;
glXQueryDrawable (mGLDisplay, drawable, GLX_FBCONFIG_ID, (unsigned int*)&fbConfigAttrib[1]);
fbConfigs = glXChooseFBConfig(mGLDisplay, DefaultScreen(mGLDisplay), fbConfigAttrib, &nElements);
if (nElements)
{
fbConfig = fbConfigs[0];
XFree (fbConfigs);
glXQueryDrawable(mGLDisplay, drawable, GLX_WIDTH, width);
glXQueryDrawable(mGLDisplay, drawable, GLX_HEIGHT, height);
}
}
if (! fbConfig && GLXEW_SGIX_fbconfig)
{
XWindowAttributes windowAttrib;
if (XGetWindowAttributes(mGLDisplay, drawable, &windowAttrib))
{
VisualID visualid = XVisualIDFromVisual(windowAttrib.visual);
fbConfig = getFBConfigFromVisualID(visualid);
*width = windowAttrib.width;
*height = windowAttrib.height;
}
}
return fbConfig;
}
std::unique_ptr<GLContextGLX> GLContextGLX::createWindowContext(XID window, PlatformDisplay& platformDisplay, GLXContext sharingContext)
{
Display* display = downcast<PlatformDisplayX11>(platformDisplay).native();
XWindowAttributes attributes;
if (!XGetWindowAttributes(display, window, &attributes))
return nullptr;
XVisualInfo visualInfo;
visualInfo.visualid = XVisualIDFromVisual(attributes.visual);
int numReturned = 0;
XUniquePtr<XVisualInfo> visualInfoList(XGetVisualInfo(display, VisualIDMask, &visualInfo, &numReturned));
XUniqueGLXContext context(glXCreateContext(display, visualInfoList.get(), sharingContext, True));
if (!context)
return nullptr;
return std::unique_ptr<GLContextGLX>(new GLContextGLX(platformDisplay, WTFMove(context), window));
}
EGLXTransportSurfaceClient::EGLXTransportSurfaceClient(const PlatformBufferHandle handle, const IntSize& size, bool hasAlpha)
: GLTransportSurfaceClient()
, m_image(0)
, m_size(size)
, m_totalBytes(0)
{
if (!handle)
return;
m_handle = handle;
XWindowAttributes attr;
if (!XGetWindowAttributes(NativeWrapper::nativeDisplay(), m_handle, &attr))
return;
createTexture();
GLPlatformSurface::SurfaceAttributes sharedSurfaceAttributes = GLPlatformSurface::Default;
if (hasAlpha)
sharedSurfaceAttributes = GLPlatformSurface::SupportAlpha;
EGLConfigSelector configSelector(sharedSurfaceAttributes);
EGLConfig config = configSelector.surfaceClientConfig(XVisualIDFromVisual(attr.visual));
m_eglImage = adoptPtr(new EGLTextureFromPixmap(m_handle, hasAlpha, config));
if (!m_eglImage->isValid() || eglGetError() != EGL_SUCCESS)
destroy();
if (m_eglImage)
return;
m_totalBytes = m_size.width() * m_size.height() * 4;
#if USE(OPENGL_ES_2)
m_format = GraphicsContext3D::RGBA;
static bool bgraSupported = GLPlatformContext::supportsGLExtension("GL_EXT_texture_format_BGRA8888");
if (bgraSupported)
m_format = GraphicsContext3D::BGRA;
#endif
createTexture();
prepareTexture();
}
void XWindow::classicInit(void)
{
XVisualInfo *vi, visInfo;
XWindowAttributes winAttr;
XGetWindowAttributes(getDisplay(), getWindow(), &winAttr);
// get the existing glWidget's visual-id
memset(&visInfo, 0, sizeof(XVisualInfo));
visInfo.visualid = XVisualIDFromVisual(winAttr.visual);
// get new display-variable
if(getDisplay() == NULL)
{
setDisplay(XOpenDisplay(DisplayString(getDisplay())));
}
// get a visual for the glx context
int nvis;
vi = XGetVisualInfo(getDisplay(), VisualIDMask, &visInfo, &nvis);
// is the visual GL-capable ?
int useGL;
glXGetConfig( getDisplay(),
vi,
GLX_USE_GL,
&useGL );
if (!useGL)
{
SFATAL << "Visual is not OpenGL-capable!" << std::endl;
exit(0);
}
// create the new context
this->setContext(glXCreateContext(getDisplay(), vi, None, GL_TRUE));
XFree(vi);
}
int main(void) {
Display *dpy = XOpenDisplay(NULL);
int scr = DefaultScreen(dpy), n;
Window win = DefaultRootWindow(dpy);
Visual *vis = DefaultVisual(dpy, scr);
XVisualInfo tmpl, *vinfo;
GLXContext glrc;
tmpl.visualid = XVisualIDFromVisual(vis);
vinfo = XGetVisualInfo(dpy, VisualIDMask, &tmpl, &n);
if (vinfo) {
glrc = glXCreateContext(dpy, vinfo, None, GL_TRUE);
} else glrc = NULL;
if (glrc) {
glXMakeCurrent(dpy, win, glrc);
glXMakeCurrent(dpy, None, NULL);
glXDestroyContext(dpy, glrc);
}
XCloseDisplay(dpy);
return 0;
}
static void
gtku_gl_drawing_area_init (GtkuGLDrawingArea * self)
{
GtkuGLDrawingAreaPrivate * priv = GTKU_GL_DRAWING_AREA_GET_PRIVATE (self);
gtk_widget_set_double_buffered (GTK_WIDGET (self), FALSE);
priv->dpy = NULL;
priv->visual = NULL;
priv->context = NULL;
#ifdef USE_VBLANK
priv->vblank_watch = 0;
priv->pipe[0] = -1;
priv->thread = 0;
priv->quit_thread = 0;
priv->swap_requested = 0;
#endif
XVisualInfo * vinfo = glXChooseVisual (GDK_DISPLAY (),
GDK_SCREEN_XNUMBER (gdk_screen_get_default ()),
attr_list);
if (!vinfo) {
fprintf (stderr, "Preferred visual not found, using default...\n");
return;
}
VisualID desired_id = vinfo->visualid;
XFree (vinfo);
GList * visuals = gdk_list_visuals ();
GList * vis;
for (vis = visuals; vis; vis = vis->next) {
Visual * xv = GDK_VISUAL_XVISUAL (vis->data);
if (XVisualIDFromVisual (xv) == desired_id) {
GdkColormap * colormap = gdk_colormap_new (vis->data, FALSE);
gtk_widget_set_colormap (GTK_WIDGET (self), colormap);
g_object_unref (G_OBJECT (colormap));
break;
}
}
g_list_free (visuals);
}
XVisualInfo *X11EGLSupport::getVisualFromFBConfig(::EGLConfig glConfig)
{
XVisualInfo *vi, tmp;
int vid, n;
::EGLDisplay glDisplay;
glDisplay = getGLDisplay();
mNativeDisplay = getNativeDisplay();
if (eglGetConfigAttrib(glDisplay, glConfig, EGL_NATIVE_VISUAL_ID, &vid) == EGL_FALSE)
{
OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
"Fail to get VISUAL_ID from glConfig",
__FUNCTION__);
return 0;
}
EGL_CHECK_ERROR
if (vid == 0)
{
const int screen_number = DefaultScreen(mNativeDisplay);
Visual *v = DefaultVisual((Display*)mNativeDisplay, screen_number);
vid = XVisualIDFromVisual(v);
}
tmp.visualid = vid;
vi = 0;
vi = XGetVisualInfo((Display*)mNativeDisplay,
VisualIDMask,
&tmp, &n);
if (vi == 0)
{
OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
"Fail to get X11 VISUAL",
__FUNCTION__);
return 0;
}
return vi;
}
int
main (int argc, char *argv[])
{
#ifdef ENABLE_NLS
bindtextdomain (PACKAGE, PACKAGE_LOCALE_DIR);
textdomain (PACKAGE);
#endif
gtk_set_locale ();
gtk_init (&argc, &argv);
add_pixmap_directory (PACKAGE_DATA_DIR "/pixmaps");
add_pixmap_directory (PACKAGE_SOURCE_DIR "/pixmaps");
e = evas_new();
evas_set_output_method(e, RENDER_METHOD_ALPHA_SOFTWARE);
{
Visual *vis;
Colormap cmap;
vis = evas_get_optimal_visual(e, GDK_WINDOW_XDISPLAY(GDK_ROOT_PARENT()));
gdk_vis = gdkx_visual_get(XVisualIDFromVisual(vis));
cmap = evas_get_optimal_colormap(e, GDK_WINDOW_XDISPLAY(GDK_ROOT_PARENT()));
gdk_cmap = gdkx_colormap_get(cmap);
/* workaround for bug in gdk - well oversight in api */
((GdkColormapPrivate *)gdk_cmap)->visual = gdk_vis;
}
/*
* The following code was added by Glade to create one of each component
* (except popup menus), just so that you see something after building
* the project. Delete any components that you don't want shown initially.
*/
mainwin = create_mainwin ();
gtk_widget_show (mainwin);
gtk_main ();
return 0;
}
bool CStdWindow::FindInfo() {
#ifdef USE_GL
// get an appropriate visual
// attributes for a single buffered visual in RGBA format with at least 4 bits
// per color
static int attrListSgl[] = {GLX_RGBA, GLX_RED_SIZE, 4, GLX_GREEN_SIZE,
4, GLX_BLUE_SIZE, 4, None};
// attributes for a double buffered visual in RGBA format with at least 4 bits
// per color
static int attrListDbl[] = {
GLX_RGBA, GLX_DOUBLEBUFFER, GLX_RED_SIZE, 4,
GLX_GREEN_SIZE, 4, GLX_BLUE_SIZE, 4,
GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR, None};
// doublebuffered is the best
Info = glXChooseVisual(dpy, DefaultScreen(dpy), attrListDbl);
if (!Info) {
Log(" gl: no doublebuffered visual.");
// a singlebuffered is probably better than the default
Info = glXChooseVisual(dpy, DefaultScreen(dpy), attrListSgl);
}
#endif // USE_GL
if (!Info) {
Log(" gl: no singlebuffered visual, either.");
// just try to get the default
XVisualInfo vitmpl;
int blub;
vitmpl.visual = DefaultVisual(dpy, DefaultScreen(dpy));
vitmpl.visualid = XVisualIDFromVisual(vitmpl.visual);
Info = XGetVisualInfo(dpy, VisualIDMask, &vitmpl, &blub);
}
if (!Info) {
Log(" gl: no visual at all.");
return false;
}
return true;
}
void GlxContext::updateSettingsFromWindow()
{
// Retrieve the attributes of the target window
XWindowAttributes windowAttributes;
if (XGetWindowAttributes(m_display, m_window, &windowAttributes) == 0)
{
err() << "Failed to get the window attributes" << std::endl;
return;
}
// Get its visuals
XVisualInfo tpl;
tpl.screen = DefaultScreen(m_display);
tpl.visualid = XVisualIDFromVisual(windowAttributes.visual);
int nbVisuals = 0;
XVisualInfo* visualInfo = XGetVisualInfo(m_display, VisualIDMask | VisualScreenMask, &tpl, &nbVisuals);
if (!visualInfo)
return;
updateSettingsFromVisualInfo(visualInfo);
XFree(visualInfo);
}
JNIEXPORT jint JNICALL
Java_jogamp_nativewindow_x11_X11Lib_GetVisualIDFromWindow(JNIEnv *env, jclass _unused, jlong display, jlong window) {
Display * dpy = (Display *)(intptr_t)display;
Window w = (Window) window;
XWindowAttributes xwa;
jlong r = 0; // undefinded
if(NULL==dpy) {
NativewindowCommon_throwNewRuntimeException(env, "invalid display connection..");
return;
}
NativewindowCommon_x11ErrorHandlerEnable(env, dpy, 0, 1, errorHandlerQuiet, 1);
memset(&xwa, 0, sizeof(XWindowAttributes));
XGetWindowAttributes(dpy, w, &xwa);
if(NULL != xwa.visual) {
r = (jint) XVisualIDFromVisual( xwa.visual );
} else {
r = 0;
}
// NativewindowCommon_x11ErrorHandlerEnable(env, dpy, 0, 0, errorHandlerQuiet, 1);
return r;
}
uint QGLContext::colorIndex( const QColor& c ) const
{
int screen = ((XVisualInfo *)vi)->screen;
if ( isValid() ) {
if ( format().plane()
&& c.pixel( screen ) == overlayTransparentColor().pixel( screen ) )
return c.pixel( screen ); // Special; don't look-up
if ( ((XVisualInfo*)vi)->visualid ==
XVisualIDFromVisual( (Visual*)QPaintDevice::x11AppVisual( screen ) ) )
return c.pixel( screen ); // We're using QColor's cmap
XVisualInfo *info = (XVisualInfo *) vi;
CMapEntry *x = cmap_dict->find( (long) info->visualid + ( info->screen * 256 ) );
if ( x && !x->alloc) { // It's a standard colormap
int rf = (int)(((float)c.red() * (x->scmap.red_max+1))/256.0);
int gf = (int)(((float)c.green() * (x->scmap.green_max+1))/256.0);
int bf = (int)(((float)c.blue() * (x->scmap.blue_max+1))/256.0);
uint p = x->scmap.base_pixel
+ ( rf * x->scmap.red_mult )
+ ( gf * x->scmap.green_mult )
+ ( bf * x->scmap.blue_mult );
return p;
} else {
if (!qglcmap_dict) {
qglcmap_dict = new QIntDict< QMap<int, QRgb> >;
}
QMap<int, QRgb> *cmap;
if ((cmap = qglcmap_dict->find((long) info->visualid)) == 0) {
cmap = new QMap<int, QRgb>;
qglcmap_dict->insert((long) info->visualid, cmap);
}
// already in the map?
QRgb target = c.rgb();
QMap<int, QRgb>::Iterator it = cmap->begin();
for (; it != cmap->end(); ++it) {
if ((*it) == target)
return it.key();
}
// need to alloc color
unsigned long plane_mask[2];
unsigned long color_map_entry;
if (!XAllocColorCells (QPaintDevice::x11AppDisplay(), x->cmap, TRUE, plane_mask, 0,
&color_map_entry, 1))
return c.pixel(screen);
XColor col;
col.flags = DoRed | DoGreen | DoBlue;
col.pixel = color_map_entry;
col.red = (ushort)((qRed(c.rgb()) / 255.0) * 65535.0 + 0.5);
col.green = (ushort)((qGreen(c.rgb()) / 255.0) * 65535.0 + 0.5);
col.blue = (ushort)((qBlue(c.rgb()) / 255.0) * 65535.0 + 0.5);
XStoreColor(QPaintDevice::x11AppDisplay(), x->cmap, &col);
cmap->insert(color_map_entry, target);
return color_map_entry;
}
}
return 0;
}
QColor findOverlayTransparentColor()
{
QColor invalidColor;
#if defined(Q_WS_X11)
Display* appDisplay;
Visual* appVisual;
// The static methods are called 'App' in Qt 2.x
#if QT_VERSION < 200
appDisplay = QPaintDevice::x__Display();
appVisual = (Visual*)QPaintDevice::x11Visual();
#else
appDisplay = QPaintDevice::x11AppDisplay();
appVisual = (Visual*)QPaintDevice::x11AppVisual();
#endif
qDebug( "Default Visual ID: 0x%x", (int)XVisualIDFromVisual(appVisual) );
typedef struct OverlayProp {
long visual;
long type;
long value;
long layer;
} OverlayProp;
QWidget* rootWin = QApplication::desktop();
if ( !rootWin )
return invalidColor; // Should not happen
Atom overlayVisualsAtom = XInternAtom( appDisplay,
"SERVER_OVERLAY_VISUALS", True );
if ( overlayVisualsAtom == None ) {
warning( "Server has no overlay visuals" );
return invalidColor;
}
Atom actualType;
int actualFormat;
ulong nItems;
ulong bytesAfter;
OverlayProp* overlayProp;
int res = XGetWindowProperty( appDisplay, QApplication::desktop()->winId(),
overlayVisualsAtom, 0, 10000, False,
overlayVisualsAtom, &actualType,
&actualFormat, &nItems, &bytesAfter,
(uchar**)&overlayProp );
if ( res != Success || actualType != overlayVisualsAtom
|| actualFormat != 32 || nItems < 4 ) {
warning( "Failed to get overlay visual property from server" );
return invalidColor;
}
for ( uint i = 0; i < nItems/4; i++ ) {
if ( (VisualID)overlayProp[i].visual == XVisualIDFromVisual(appVisual)
&& overlayProp[i].type == 1 )
return QColor( qRgb( 1, 2, 3 ), overlayProp[i].value );
}
qWarning( "Default visual is not in overlay plane" );
return invalidColor;
#else // defined(Q_WS_X11)
qWarning( "Wrong window system - Only X11 has overlay support." );
return invalidColor;
#endif
}
// NOTE: The X11 version of createSurface will re-create the native drawable if it's visual doesn't
// match the one for the passed in EGLConfig
EGLSurface QEgl::createSurface(QPaintDevice *device, EGLConfig config, const QEglProperties *unusedProperties)
{
Q_UNUSED(unusedProperties);
int devType = device->devType();
if (devType == QInternal::Pbuffer) {
// TODO
return EGL_NO_SURFACE;
}
QX11PixmapData *x11PixmapData = 0;
if (devType == QInternal::Pixmap) {
QPixmapData *pmd = static_cast<QPixmap*>(device)->data_ptr().data();
if (pmd->classId() == QPixmapData::X11Class)
x11PixmapData = static_cast<QX11PixmapData*>(pmd);
else {
// TODO: Replace the pixmap's data with a new QX11PixmapData
qWarning("WARNING: Creating an EGL surface on a QPixmap is only supported for QX11PixmapData");
return EGL_NO_SURFACE;
}
} else if ((devType != QInternal::Widget) && (devType != QInternal::Pbuffer)) {
qWarning("WARNING: Creating an EGLSurface for device type %d isn't supported", devType);
return EGL_NO_SURFACE;
}
VisualID visualId = QEgl::getCompatibleVisualId(config);
EGLint alphaSize;
eglGetConfigAttrib(QEgl::display(), config, EGL_ALPHA_SIZE, &alphaSize);
if (devType == QInternal::Widget) {
QWidget *widget = static_cast<QWidget*>(device);
VisualID currentVisualId = 0;
if (widget->testAttribute(Qt::WA_WState_Created))
currentVisualId = XVisualIDFromVisual((Visual*)widget->x11Info().visual());
if (currentVisualId != visualId) {
// The window is either not created or has the wrong visual. Either way, we need
// to create a window with the correct visual and call create() on the widget:
bool visible = widget->isVisible();
if (visible)
widget->hide();
XVisualInfo visualInfo;
visualInfo.visualid = visualId;
{
XVisualInfo *visualInfoPtr;
int matchingCount = 0;
visualInfoPtr = XGetVisualInfo(widget->x11Info().display(), VisualIDMask,
&visualInfo, &matchingCount);
Q_ASSERT(visualInfoPtr); // visualId really should be valid!
visualInfo = *visualInfoPtr;
XFree(visualInfoPtr);
}
Window parentWindow = RootWindow(widget->x11Info().display(), widget->x11Info().screen());
if (widget->parentWidget())
parentWindow = widget->parentWidget()->winId();
XSetWindowAttributes windowAttribs;
QColormap colmap = QColormap::instance(widget->x11Info().screen());
windowAttribs.background_pixel = colmap.pixel(widget->palette().color(widget->backgroundRole()));
windowAttribs.border_pixel = colmap.pixel(Qt::black);
unsigned int valueMask = CWBackPixel|CWBorderPixel;
if (alphaSize > 0) {
windowAttribs.colormap = XCreateColormap(widget->x11Info().display(), parentWindow,
visualInfo.visual, AllocNone);
valueMask |= CWColormap;
}
Window window = XCreateWindow(widget->x11Info().display(), parentWindow,
widget->x(), widget->y(), widget->width(), widget->height(),
0, visualInfo.depth, InputOutput, visualInfo.visual,
valueMask, &windowAttribs);
// This is a nasty hack to get round the fact that we can't be a friend of QWidget:
qt_set_winid_on_widget(widget, window);
if (visible)
widget->show();
}
// At this point, the widget's window should be created and have the correct visual. Now we
// just need to create the EGL surface for it:
EGLSurface surf = eglCreateWindowSurface(QEgl::display(), config, (EGLNativeWindowType)widget->winId(), 0);
if (surf == EGL_NO_SURFACE)
qWarning("QEglContext::createSurface(): Unable to create EGL surface, error = 0x%x", eglGetError());
return surf;
}
if (x11PixmapData) {
// X11 Pixmaps are only created with a depth, so that's all we need to check
EGLint configDepth;
eglGetConfigAttrib(QEgl::display(), config, EGL_BUFFER_SIZE , &configDepth);
if (x11PixmapData->depth() != configDepth) {
// The bit depths are wrong which means the EGLConfig isn't compatable with
// this pixmap. So we need to replace the pixmap's existing data with a new
// one which is created with the correct depth:
#ifndef QT_NO_XRENDER
if (configDepth == 32) {
qWarning("Warning: EGLConfig's depth (32) != pixmap's depth (%d), converting to ARGB32",
x11PixmapData->depth());
x11PixmapData->convertToARGB32(true);
} else
#endif
{
qWarning("Warning: EGLConfig's depth (%d) != pixmap's depth (%d)",
configDepth, x11PixmapData->depth());
}
}
QEglProperties surfaceAttribs;
// If the pixmap can't be bound to a texture, it's pretty useless
surfaceAttribs.setValue(EGL_TEXTURE_TARGET, EGL_TEXTURE_2D);
if (alphaSize > 0)
surfaceAttribs.setValue(EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA);
else
surfaceAttribs.setValue(EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGB);
EGLSurface surf = eglCreatePixmapSurface(QEgl::display(), config,
(EGLNativePixmapType) x11PixmapData->handle(),
surfaceAttribs.properties());
x11PixmapData->gl_surface = (void*)surf;
QImagePixmapCleanupHooks::enableCleanupHooks(x11PixmapData);
return surf;
}
return EGL_NO_SURFACE;
}
GLXContext *
init_GL(ModeInfo * mi)
{
Display *dpy = mi->dpy;
Window window = mi->window;
Screen *screen = mi->xgwa.screen;
Visual *visual = mi->xgwa.visual;
GLXContext glx_context = 0;
XVisualInfo vi_in, *vi_out;
int out_count;
vi_in.screen = screen_number (screen);
vi_in.visualid = XVisualIDFromVisual (visual);
vi_out = XGetVisualInfo (dpy, VisualScreenMask|VisualIDMask,
&vi_in, &out_count);
if (! vi_out) abort ();
{
XSync (dpy, False);
orig_ehandler = XSetErrorHandler (BadValue_ehandler);
glx_context = glXCreateContext (dpy, vi_out, 0, GL_TRUE);
XSync (dpy, False);
XSetErrorHandler (orig_ehandler);
if (got_error)
glx_context = 0;
}
XFree((char *) vi_out);
if (!glx_context)
{
fprintf(stderr, "%s: couldn't create GL context for visual 0x%x.\n",
progname, (unsigned int) XVisualIDFromVisual (visual));
exit(1);
}
glXMakeCurrent (dpy, window, glx_context);
{
GLboolean rgba_mode = 0;
glGetBooleanv(GL_RGBA_MODE, &rgba_mode);
if (!rgba_mode)
{
glIndexi (WhitePixelOfScreen (screen));
glClearIndex (BlackPixelOfScreen (screen));
}
}
/* jwz: the doc for glDrawBuffer says "The initial value is GL_FRONT
for single-buffered contexts, and GL_BACK for double-buffered
contexts." However, I find that this is not always the case,
at least with Mesa 3.4.2 -- sometimes the default seems to be
GL_FRONT even when glGet(GL_DOUBLEBUFFER) is true. So, let's
make sure.
Oh, hmm -- maybe this only happens when we are re-using the
xscreensaver window, and the previous GL hack happened to die with
the other buffer selected? I'm not sure. Anyway, this fixes it.
*/
{
GLboolean d = False;
glGetBooleanv (GL_DOUBLEBUFFER, &d);
if (d)
glDrawBuffer (GL_BACK);
else
glDrawBuffer (GL_FRONT);
}
/* GLXContext is already a pointer type.
Why this function returns a pointer to a pointer, I have no idea...
*/
{
GLXContext *ptr = (GLXContext *) malloc(sizeof(GLXContext));
*ptr = glx_context;
return ptr;
}
}
static int config(uint32_t width, uint32_t height, uint32_t d_width,
uint32_t d_height, uint32_t flags, char *title,
uint32_t format)
{
// int screen;
// int interval, prefer_blank, allow_exp, nothing;
Colormap theCmap;
const struct fmt2Xfmtentry_s *fmte = fmt2Xfmt;
#ifdef CONFIG_XF86VM
int vm = flags & VOFLAG_MODESWITCHING;
#endif
Flip_Flag = flags & VOFLAG_FLIPPING;
zoomFlag = flags & VOFLAG_SWSCALE;
old_vo_dwidth = -1;
old_vo_dheight = -1;
int_pause = 0;
if (!title)
title = "MPlayer X11 (XImage/Shm) render";
in_format = format;
srcW = width;
srcH = height;
XGetWindowAttributes(mDisplay, mRootWin, &attribs);
depth = attribs.depth;
if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
{
Visual *visual;
depth = vo_find_depth_from_visuals(mDisplay, mScreen, &visual);
}
if (!XMatchVisualInfo(mDisplay, mScreen, depth, DirectColor, &vinfo) ||
(WinID > 0
&& vinfo.visualid != XVisualIDFromVisual(attribs.visual)))
XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &vinfo);
/* set image size (which is indeed neither the input nor output size),
if zoom is on it will be changed during draw_slice anyway so we don't duplicate the aspect code here
*/
image_width = (width + 7) & (~7);
image_height = height;
{
#ifdef CONFIG_XF86VM
if (vm)
{
vo_vm_switch();
}
#endif
theCmap = vo_x11_create_colormap(&vinfo);
vo_x11_create_vo_window(&vinfo, vo_dx, vo_dy, vo_dwidth, vo_dheight,
flags, theCmap, "x11", title);
if (WinID > 0)
depth = vo_x11_update_geometry();
#ifdef CONFIG_XF86VM
if (vm)
{
/* Grab the mouse pointer in our window */
if (vo_grabpointer)
XGrabPointer(mDisplay, vo_window, True, 0,
GrabModeAsync, GrabModeAsync,
vo_window, None, CurrentTime);
XSetInputFocus(mDisplay, vo_window, RevertToNone, CurrentTime);
}
#endif
}
if (myximage)
{
freeMyXImage();
sws_freeContext(swsContext);
}
getMyXImage();
while (fmte->mpfmt) {
int depth = IMGFMT_RGB_DEPTH(fmte->mpfmt);
/* bits_per_pixel in X seems to be set to 16 for 15 bit formats
=> force depth to 16 so that only the color masks are used for the format check */
if (depth == 15)
depth = 16;
if (depth == myximage->bits_per_pixel &&
fmte->byte_order == myximage->byte_order &&
fmte->red_mask == myximage->red_mask &&
fmte->green_mask == myximage->green_mask &&
fmte->blue_mask == myximage->blue_mask)
break;
fmte++;
}
if (!fmte->mpfmt) {
mp_msg(MSGT_VO, MSGL_ERR,
"X server image format not supported, please contact the developers\n");
return -1;
}
out_format = fmte->mpfmt;
switch ((bpp = myximage->bits_per_pixel))
{
case 24:
draw_alpha_fnc = draw_alpha_24;
break;
case 32:
draw_alpha_fnc = draw_alpha_32;
break;
case 15:
case 16:
if (depth == 15)
draw_alpha_fnc = draw_alpha_15;
else
draw_alpha_fnc = draw_alpha_16;
break;
default:
draw_alpha_fnc = draw_alpha_null;
}
out_offset = 0;
// for these formats conversion is currently not support and
// we can easily "emulate" them.
if (out_format & 64 && (IMGFMT_IS_RGB(out_format) || IMGFMT_IS_BGR(out_format))) {
out_format &= ~64;
#if HAVE_BIGENDIAN
out_offset = 1;
#else
out_offset = -1;
#endif
}
/* always allocate swsContext as size could change between frames */
swsContext =
sws_getContextFromCmdLine(width, height, in_format, width, height,
out_format);
if (!swsContext)
return -1;
dst_width = width;
//printf( "X11 bpp: %d color mask: R:%lX G:%lX B:%lX\n",bpp,myximage->red_mask,myximage->green_mask,myximage->blue_mask );
return 0;
}
static int config(struct vo *vo, uint32_t width, uint32_t height,
uint32_t d_width, uint32_t d_height, uint32_t flags,
uint32_t format)
{
struct priv *p = vo->priv;
Colormap theCmap;
const struct fmt2Xfmtentry_s *fmte = fmt2Xfmt;
#ifdef CONFIG_XF86VM
int vm = flags & VOFLAG_MODESWITCHING;
#endif
p->Flip_Flag = flags & VOFLAG_FLIPPING;
p->zoomFlag = 1;
p->old_vo_dwidth = -1;
p->old_vo_dheight = -1;
p->in_format = format;
p->srcW = width;
p->srcH = height;
XGetWindowAttributes(vo->x11->display, vo->x11->rootwin, &p->attribs);
p->depth = p->attribs.depth;
if (p->depth != 15 && p->depth != 16 && p->depth != 24 && p->depth != 32) {
Visual *visual;
p->depth = vo_find_depth_from_visuals(vo->x11->display, vo->x11->screen,
&visual);
}
if (!XMatchVisualInfo(vo->x11->display, vo->x11->screen, p->depth,
DirectColor, &p->vinfo)
|| (WinID > 0
&& p->vinfo.visualid != XVisualIDFromVisual(p->attribs.visual)))
{
XMatchVisualInfo(vo->x11->display, vo->x11->screen, p->depth, TrueColor,
&p->vinfo);
}
/* set image size (which is indeed neither the input nor output size),
if zoom is on it will be changed during draw_slice anyway so we don't
duplicate the aspect code here
*/
p->image_width = (width + 7) & (~7);
p->image_height = height;
{
#ifdef CONFIG_XF86VM
if (vm)
vo_vm_switch(vo);
#endif
theCmap = vo_x11_create_colormap(vo, &p->vinfo);
vo_x11_create_vo_window(vo, &p->vinfo, vo->dx, vo->dy, vo->dwidth,
vo->dheight, flags, theCmap, "x11");
if (WinID > 0)
p->depth = vo_x11_update_geometry(vo, true);
#ifdef CONFIG_XF86VM
if (vm) {
/* Grab the mouse pointer in our window */
if (vo_grabpointer)
XGrabPointer(vo->x11->display, vo->x11->window, True, 0,
GrabModeAsync, GrabModeAsync,
vo->x11->window, None, CurrentTime);
XSetInputFocus(vo->x11->display, vo->x11->window, RevertToNone,
CurrentTime);
}
#endif
}
if (p->myximage) {
freeMyXImage(p);
sws_freeContext(p->swsContext);
}
getMyXImage(p);
while (fmte->mpfmt) {
int depth = IMGFMT_RGB_DEPTH(fmte->mpfmt);
/* bits_per_pixel in X seems to be set to 16 for 15 bit formats
=> force depth to 16 so that only the color masks are used for the format check */
if (depth == 15)
depth = 16;
if (depth == p->myximage->bits_per_pixel &&
fmte->byte_order == p->myximage->byte_order &&
fmte->red_mask == p->myximage->red_mask &&
fmte->green_mask == p->myximage->green_mask &&
fmte->blue_mask == p->myximage->blue_mask)
break;
fmte++;
}
if (!fmte->mpfmt) {
mp_msg(
MSGT_VO, MSGL_ERR,
"X server image format not supported, please contact the developers\n");
return -1;
}
p->out_format = fmte->mpfmt;
p->bpp = p->myximage->bits_per_pixel;
p->out_offset = 0;
// We can easily "emulate" non-native RGB32 and BGR32
if (p->out_format == (IMGFMT_BGR32 | 128)
|| p->out_format == (IMGFMT_RGB32 | 128))
{
p->out_format &= ~128;
#if BYTE_ORDER == BIG_ENDIAN
p->out_offset = 1;
#else
p->out_offset = -1;
#endif
}
/* always allocate swsContext as size could change between frames */
p->swsContext = sws_getContextFromCmdLine(width, height, p->in_format,
width, height, p->out_format);
if (!p->swsContext)
return -1;
p->dst_width = width;
return 0;
}
bool CGLContextEGL::Refresh(bool force, int screen, Window glWindow, bool &newContext)
{
// refresh context
if (m_eglContext && !force)
{
if (m_eglSurface == EGL_NO_SURFACE)
{
m_eglSurface = eglCreateWindowSurface(m_eglDisplay, m_eglConfig, glWindow, NULL);
if (m_eglSurface == EGL_NO_SURFACE)
{
CLog::Log(LOGERROR, "failed to create EGL window surface %d\n", eglGetError());
return false;
}
}
CLog::Log(LOGDEBUG, "CWinSystemX11::RefreshEGLContext: refreshing context");
eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext);
return true;
}
// create context
bool retVal = false;
if (m_eglDisplay == EGL_NO_DISPLAY)
{
m_eglDisplay = eglGetDisplay((EGLNativeDisplayType)m_dpy);
if (m_eglDisplay == EGL_NO_DISPLAY)
{
CLog::Log(LOGERROR, "failed to get egl display\n");
return false;
}
if (!eglInitialize(m_eglDisplay, NULL, NULL))
{
CLog::Log(LOGERROR, "failed to initialize egl display\n");
return false;
}
}
XVisualInfo vMask;
XVisualInfo *visuals;
XVisualInfo *vInfo = NULL;
int availableVisuals = 0;
vMask.screen = screen;
XWindowAttributes winAttr;
/* Assume a depth of 24 in case the below calls to XGetWindowAttributes()
or XGetVisualInfo() fail. That shouldn't happen unless something is
fatally wrong, but lets prepare for everything. */
vMask.depth = 24;
if (XGetWindowAttributes(m_dpy, glWindow, &winAttr))
{
vMask.visualid = XVisualIDFromVisual(winAttr.visual);
vInfo = XGetVisualInfo(m_dpy, VisualScreenMask | VisualIDMask, &vMask, &availableVisuals);
if (!vInfo)
CLog::Log(LOGWARNING, "Failed to get VisualInfo of visual 0x%x", (unsigned) vMask.visualid);
else if(!IsSuitableVisual(vInfo))
{
CLog::Log(LOGWARNING, "Visual 0x%x of the window is not suitable, looking for another one...",
(unsigned) vInfo->visualid);
vMask.depth = vInfo->depth;
XFree(vInfo);
vInfo = NULL;
}
}
else
CLog::Log(LOGWARNING, "Failed to get window attributes");
/* As per glXMakeCurrent documentation, we have to use the same visual as
m_glWindow. Since that was not suitable for use, we try to use another
one with the same depth and hope that the used implementation is less
strict than the documentation. */
if (!vInfo)
{
visuals = XGetVisualInfo(m_dpy, VisualScreenMask | VisualDepthMask, &vMask, &availableVisuals);
for (int i = 0; i < availableVisuals; i++)
{
if (IsSuitableVisual(&visuals[i]))
{
vMask.visualid = visuals[i].visualid;
vInfo = XGetVisualInfo(m_dpy, VisualScreenMask | VisualIDMask, &vMask, &availableVisuals);
break;
}
}
XFree(visuals);
}
if (vInfo)
{
CLog::Log(LOGNOTICE, "Using visual 0x%x", (unsigned) vInfo->visualid);
if (m_eglContext)
{
eglMakeCurrent(m_eglContext, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroyContext(m_eglDisplay, m_eglContext);
m_eglContext = EGL_NO_CONTEXT;
if (m_eglSurface)
{
eglDestroySurface(m_eglDisplay, m_eglSurface);
m_eglSurface = EGL_NO_SURFACE;
}
eglTerminate(m_eglDisplay);
m_eglDisplay = EGL_NO_DISPLAY;
XSync(m_dpy, FALSE);
newContext = true;
}
m_eglDisplay = eglGetDisplay((EGLNativeDisplayType)m_dpy);
if (m_eglDisplay == EGL_NO_DISPLAY)
{
CLog::Log(LOGERROR, "failed to get egl display");
return false;
}
if (!eglInitialize(m_eglDisplay, NULL, NULL))
{
CLog::Log(LOGERROR, "failed to initialize egl\n");
return false;
}
#if defined (HAS_GL)
if (!eglBindAPI(EGL_OPENGL_API))
{
CLog::Log(LOGERROR, "failed to initialize egl");
XFree(vInfo);
return false;
}
#endif
if(m_eglConfig == EGL_NO_CONFIG)
{
m_eglConfig = getEGLConfig(m_eglDisplay, vInfo);
}
if (m_eglConfig == EGL_NO_CONFIG)
{
CLog::Log(LOGERROR, "failed to get eglconfig for visual id");
XFree(vInfo);
return false;
}
if (m_eglSurface == EGL_NO_SURFACE)
{
m_eglSurface = eglCreateWindowSurface(m_eglDisplay, m_eglConfig, glWindow, NULL);
if (m_eglSurface == EGL_NO_SURFACE)
{
CLog::Log(LOGERROR, "failed to create EGL window surface %d", eglGetError());
XFree(vInfo);
return false;
}
}
EGLint contextAttributes[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, contextAttributes);
if (m_eglContext == EGL_NO_CONTEXT)
{
CLog::Log(LOGERROR, "failed to create EGL context\n");
return false;
}
if (!eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext))
{
CLog::Log(LOGERROR, "Failed to make context current %p %p %p\n", m_eglDisplay, m_eglSurface, m_eglContext);
return false;
}
XFree(vInfo);
retVal = true;
}
else
{
CLog::Log(LOGERROR, "EGL Error: vInfo is NULL!");
}
return retVal;
}
GLboolean glewCreateContext (struct createParams *params)
{
int attrib[] = { GLX_RGBA, GLX_DOUBLEBUFFER, None };
int erb, evb;
XSetWindowAttributes swa;
/* open display */
dpy = XOpenDisplay(params->display);
if (NULL == dpy) return GL_TRUE;
/* query for glx */
if (!glXQueryExtension(dpy, &erb, &evb)) return GL_TRUE;
/* choose visual */
if (params->visual == -1)
{
vi = glXChooseVisual(dpy, DefaultScreen(dpy), attrib);
if (NULL == vi) return GL_TRUE;
params->visual = (int)XVisualIDFromVisual(vi->visual);
}
else
{
int n_vis, i;
vis = XGetVisualInfo(dpy, 0, NULL, &n_vis);
for (i=0; i<n_vis; i++)
{
if ((int)XVisualIDFromVisual(vis[i].visual) == params->visual)
vi = &vis[i];
}
if (vi == NULL) return GL_TRUE;
}
/* create context */
ctx = glXCreateContext(dpy, vi, None, True);
if (NULL == ctx) return GL_TRUE;
/* create window */
/*wnd = XCreateSimpleWindow(dpy, RootWindow(dpy, vi->screen), 0, 0, 1, 1, 1, 0, 0);*/
cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen), vi->visual, AllocNone);
swa.border_pixel = 0;
swa.colormap = cmap;
wnd = XCreateWindow(dpy, RootWindow(dpy, vi->screen),
0, 0, 1, 1, 0, vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap, &swa);
/* make context current */
if (!glXMakeCurrent(dpy, wnd, ctx)) return GL_TRUE;
if (params->major || params->profile || params->flags)
{
GLXContext oldCtx = ctx;
GLXFBConfig *FBConfigs;
int FBConfigAttrs[] = { GLX_FBCONFIG_ID, 0, None };
int contextAttrs[20];
int nelems, i;
glxewInit();
if (!glxewGetExtension("GLX_ARB_create_context"))
return GL_TRUE;
if (glXQueryContext(dpy, oldCtx, GLX_FBCONFIG_ID, &FBConfigAttrs[1]))
return GL_TRUE;
FBConfigs = glXChooseFBConfig(dpy, vi->screen, FBConfigAttrs, &nelems);
if (nelems < 1)
return GL_TRUE;
i = 0;
if (params->major)
{
contextAttrs[i++] = GLX_CONTEXT_MAJOR_VERSION_ARB;
contextAttrs[i++] = params->major;
contextAttrs[i++] = GLX_CONTEXT_MINOR_VERSION_ARB;
contextAttrs[i++] = params->minor;
}
if (params->profile)
{
contextAttrs[i++] = GLX_CONTEXT_PROFILE_MASK_ARB;
contextAttrs[i++] = params->profile;
}
if (params->flags)
{
contextAttrs[i++] = GLX_CONTEXT_FLAGS_ARB;
contextAttrs[i++] = params->flags;
}
contextAttrs[i++] = None;
ctx = glXCreateContextAttribsARB(dpy, *FBConfigs, NULL, True, contextAttrs);
if (NULL == ctx) return GL_TRUE;
if (!glXMakeCurrent(dpy, wnd, ctx)) return GL_TRUE;
glXDestroyContext(dpy, oldCtx);
XFree(FBConfigs);
}
return GL_FALSE;
}
static int Open (vlc_object_t *obj)
{
vlc_gl_t *gl = (vlc_gl_t *)obj;
if (gl->surface->type != VOUT_WINDOW_TYPE_XID || !vlc_xlib_init (obj))
return VLC_EGENERIC;
/* Initialize GLX display */
Display *dpy = XOpenDisplay (gl->surface->display.x11);
if (dpy == NULL)
return VLC_EGENERIC;
vlc_gl_sys_t *sys = malloc (sizeof (*sys));
if (unlikely(sys == NULL))
{
XCloseDisplay (dpy);
return VLC_ENOMEM;
}
gl->sys = sys;
sys->display = dpy;
if (!CheckGLX (obj, dpy))
goto error;
/* Determine our pixel format */
XWindowAttributes wa;
if (!XGetWindowAttributes (dpy, gl->surface->handle.xid, &wa))
goto error;
const int snum = XScreenNumberOfScreen (wa.screen);
const VisualID visual = XVisualIDFromVisual (wa.visual);
static const int attr[] = {
GLX_RED_SIZE, 5,
GLX_GREEN_SIZE, 5,
GLX_BLUE_SIZE, 5,
GLX_DOUBLEBUFFER, True,
GLX_X_RENDERABLE, True,
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
None
};
int nelem;
GLXFBConfig *confs = glXChooseFBConfig (dpy, snum, attr, &nelem);
if (confs == NULL)
{
msg_Err (obj, "cannot choose GLX frame buffer configurations");
goto error;
}
GLXFBConfig conf;
bool found = false;
for (int i = 0; i < nelem && !found; i++)
{
conf = confs[i];
XVisualInfo *vi = glXGetVisualFromFBConfig (dpy, conf);
if (vi == NULL)
continue;
if (vi->visualid == visual)
found = true;
XFree (vi);
}
XFree (confs);
if (!found)
{
msg_Err (obj, "cannot match GLX frame buffer configuration");
goto error;
}
/* Create a drawing surface */
sys->win = glXCreateWindow (dpy, conf, gl->surface->handle.xid, NULL);
if (sys->win == None)
{
msg_Err (obj, "cannot create GLX window");
goto error;
}
/* Create an OpenGL context */
sys->ctx = glXCreateNewContext (dpy, conf, GLX_RGBA_TYPE, NULL, True);
if (sys->ctx == NULL)
{
glXDestroyWindow (dpy, sys->win);
msg_Err (obj, "cannot create GLX context");
goto error;
}
/* Initialize OpenGL callbacks */
gl->sys = sys;
gl->makeCurrent = MakeCurrent;
gl->releaseCurrent = ReleaseCurrent;
gl->resize = NULL;
gl->swap = SwapBuffers;
gl->getProcAddress = GetSymbol;
#ifdef GLX_ARB_get_proc_address
bool is_swap_interval_set = false;
MakeCurrent (gl);
# ifdef GLX_SGI_swap_control
if (!is_swap_interval_set
&& CheckGLXext (dpy, snum, "GLX_SGI_swap_control"))
{
PFNGLXSWAPINTERVALSGIPROC SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)
glXGetProcAddressARB ((const GLubyte *)"glXSwapIntervalSGI");
assert (SwapIntervalSGI != NULL);
is_swap_interval_set = !SwapIntervalSGI (1);
}
# endif
# ifdef GLX_EXT_swap_control
if (!is_swap_interval_set
&& CheckGLXext (dpy, snum, "GLX_EXT_swap_control"))
{
PFNGLXSWAPINTERVALEXTPROC SwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)
glXGetProcAddress ((const GLubyte *)"glXSwapIntervalEXT");
assert (SwapIntervalEXT != NULL);
SwapIntervalEXT (dpy, sys->win, 1);
is_swap_interval_set = true;
}
# endif
ReleaseCurrent (gl);
#endif
return VLC_SUCCESS;
error:
XCloseDisplay (dpy);
free (sys);
return VLC_EGENERIC;
}
bool CGLContextEGL::Refresh(bool force, int screen, Window glWindow, bool &newContext)
{
m_sync.cont = 0;
// refresh context
if (m_eglContext && !force)
{
if (m_eglSurface == EGL_NO_SURFACE)
{
m_eglSurface = eglCreateWindowSurface(m_eglDisplay, m_eglConfig, glWindow, NULL);
if (m_eglSurface == EGL_NO_SURFACE)
{
CLog::Log(LOGERROR, "failed to create EGL window surface %d\n", eglGetError());
return false;
}
}
CLog::Log(LOGDEBUG, "CWinSystemX11::RefreshEGLContext: refreshing context");
eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext);
return true;
}
// create context
bool retVal = false;
if (m_eglDisplay == EGL_NO_DISPLAY)
{
m_eglDisplay = eglGetDisplay((EGLNativeDisplayType)m_dpy);
if (m_eglDisplay == EGL_NO_DISPLAY)
{
CLog::Log(LOGERROR, "failed to get egl display\n");
return false;
}
if (!eglInitialize(m_eglDisplay, NULL, NULL))
{
CLog::Log(LOGERROR, "failed to initialize egl display\n");
return false;
}
}
XVisualInfo vMask;
XVisualInfo *vInfo = nullptr;
int availableVisuals = 0;
vMask.screen = screen;
XWindowAttributes winAttr;
if (XGetWindowAttributes(m_dpy, glWindow, &winAttr))
{
vMask.visualid = XVisualIDFromVisual(winAttr.visual);
vInfo = XGetVisualInfo(m_dpy, VisualScreenMask | VisualIDMask, &vMask, &availableVisuals);
if (!vInfo)
{
CLog::Log(LOGWARNING, "Failed to get VisualInfo of visual 0x%x", (unsigned) vMask.visualid);
}
else if(!IsSuitableVisual(vInfo))
{
CLog::Log(LOGWARNING, "Visual 0x%x of the window is not suitable, looking for another one...",
(unsigned) vInfo->visualid);
XFree(vInfo);
vInfo = nullptr;
}
}
else
CLog::Log(LOGWARNING, "Failed to get window attributes");
if (vInfo)
{
CLog::Log(LOGNOTICE, "Using visual 0x%x", (unsigned) vInfo->visualid);
if (m_eglContext)
{
eglMakeCurrent(m_eglContext, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroyContext(m_eglDisplay, m_eglContext);
m_eglContext = EGL_NO_CONTEXT;
if (m_eglSurface)
{
eglDestroySurface(m_eglDisplay, m_eglSurface);
m_eglSurface = EGL_NO_SURFACE;
}
eglTerminate(m_eglDisplay);
m_eglDisplay = EGL_NO_DISPLAY;
XSync(m_dpy, False);
newContext = true;
}
m_eglDisplay = eglGetDisplay((EGLNativeDisplayType)m_dpy);
if (m_eglDisplay == EGL_NO_DISPLAY)
{
CLog::Log(LOGERROR, "failed to get egl display");
return false;
}
if (!eglInitialize(m_eglDisplay, NULL, NULL))
{
CLog::Log(LOGERROR, "failed to initialize egl\n");
return false;
}
if (!eglBindAPI(EGL_OPENGL_API))
{
CLog::Log(LOGERROR, "failed to initialize egl");
XFree(vInfo);
return false;
}
if (m_eglConfig == EGL_NO_CONFIG)
{
m_eglConfig = GetEGLConfig(m_eglDisplay, vInfo);
}
if (m_eglConfig == EGL_NO_CONFIG)
{
CLog::Log(LOGERROR, "failed to get eglconfig for visual id");
XFree(vInfo);
return false;
}
if (m_eglSurface == EGL_NO_SURFACE)
{
m_eglSurface = eglCreateWindowSurface(m_eglDisplay, m_eglConfig, glWindow, NULL);
if (m_eglSurface == EGL_NO_SURFACE)
{
CLog::Log(LOGERROR, "failed to create EGL window surface %d", eglGetError());
XFree(vInfo);
return false;
}
}
EGLint contextAttributes[] =
{
EGL_CONTEXT_MAJOR_VERSION_KHR, 3,
EGL_CONTEXT_MINOR_VERSION_KHR, 2,
EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR,
EGL_NONE
};
m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, contextAttributes);
if (m_eglContext == EGL_NO_CONTEXT)
{
EGLint contextAttributes[] =
{
EGL_CONTEXT_MAJOR_VERSION_KHR, 2,
EGL_NONE
};
m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, contextAttributes);
if (m_eglContext == EGL_NO_CONTEXT)
{
CLog::Log(LOGERROR, "failed to create EGL context\n");
return false;
}
CLog::Log(LOGWARNING, "Failed to get an OpenGL context supporting core profile 3.2, \
using legacy mode with reduced feature set");
}
if (!eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext))
{
CLog::Log(LOGERROR, "Failed to make context current %p %p %p\n", m_eglDisplay, m_eglSurface, m_eglContext);
return false;
}
XFree(vInfo);
retVal = true;
}
int found;
app_shell =\
XtAppInitialize(\
&app_context,"mcamip by Panteltje (c)", NULL, 0, &argc, argv, NULL, NULL, 0);
XtMakeResizeRequest(app_shell, xsize, ysize, NULL, NULL);
dpy = XtDisplay(app_shell);
root = DefaultRootWindow(dpy);
template.screen = XDefaultScreen(dpy);
template.visualid =\
XVisualIDFromVisual(DefaultVisualOfScreen(DefaultScreenOfDisplay(dpy)));
info =\
XGetVisualInfo(dpy, VisualIDMask | VisualScreenMask, &template,&found);
if (!info)
{
fprintf(stderr, "XGetVisualInfo failed\n");
return -1;
}
display_bits = info -> depth;
//UNCOMMENT ONE OF THESE LINES IF YOU WANT FIXED COLOR DEPTH.
//display_bits = 16;
//display_bits = 24;
display_bits = 32;
already_AddRefed<GLContext>
GLContextProviderGLX::CreateForWindow(nsIWidget *aWidget)
{
const LibType libType = GLXLibrary::OPENGL_LIB;
if (!sDefGLXLib.EnsureInitialized(libType)) {
return nullptr;
}
// Currently, we take whatever Visual the window already has, and
// try to create an fbconfig for that visual. This isn't
// necessarily what we want in the long run; an fbconfig may not
// be available for the existing visual, or if it is, the GL
// performance might be suboptimal. But using the existing visual
// is a relatively safe intermediate step.
Display *display = (Display*)aWidget->GetNativeData(NS_NATIVE_DISPLAY);
int xscreen = DefaultScreen(display);
Window window = GET_NATIVE_WINDOW(aWidget);
int numConfigs;
ScopedXFree<GLXFBConfig> cfgs;
if (sDefGLXLib.IsATI() ||
!sDefGLXLib.GLXVersionCheck(1, 3)) {
const int attribs[] = {
LOCAL_GLX_DOUBLEBUFFER, False,
0
};
cfgs = sDefGLXLib.xChooseFBConfig(display,
xscreen,
attribs,
&numConfigs);
} else {
cfgs = sDefGLXLib.xGetFBConfigs(display,
xscreen,
&numConfigs);
}
if (!cfgs) {
NS_WARNING("[GLX] glXGetFBConfigs() failed");
return nullptr;
}
NS_ASSERTION(numConfigs > 0, "No FBConfigs found!");
// XXX the visual ID is almost certainly the LOCAL_GLX_FBCONFIG_ID, so
// we could probably do this first and replace the glXGetFBConfigs
// with glXChooseConfigs. Docs are sparklingly clear as always.
XWindowAttributes widgetAttrs;
if (!XGetWindowAttributes(display, window, &widgetAttrs)) {
NS_WARNING("[GLX] XGetWindowAttributes() failed");
return nullptr;
}
const VisualID widgetVisualID = XVisualIDFromVisual(widgetAttrs.visual);
#ifdef DEBUG
printf("[GLX] widget has VisualID 0x%lx\n", widgetVisualID);
#endif
int matchIndex = -1;
for (int i = 0; i < numConfigs; i++) {
int visid = None;
sDefGLXLib.xGetFBConfigAttrib(display, cfgs[i], LOCAL_GLX_VISUAL_ID, &visid);
if (!visid) {
continue;
}
if (sDefGLXLib.IsATI()) {
int depth;
Visual *visual;
FindVisualAndDepth(display, visid, &visual, &depth);
if (depth == widgetAttrs.depth &&
AreCompatibleVisuals(widgetAttrs.visual, visual)) {
matchIndex = i;
break;
}
} else {
if (widgetVisualID == static_cast<VisualID>(visid)) {
matchIndex = i;
break;
}
}
}
if (matchIndex == -1) {
NS_WARNING("[GLX] Couldn't find a FBConfig matching widget visual");
return nullptr;
}
GLContextGLX *shareContext = GetGlobalContextGLX();
SurfaceCaps caps = SurfaceCaps::Any();
nsRefPtr<GLContextGLX> glContext = GLContextGLX::CreateGLContext(caps,
shareContext,
false,
display,
window,
cfgs[matchIndex],
false,
libType);
return glContext.forget();
}
