Chapter 20. Using the X Composite Extension
Prev | Part I. Installation and Configuration Instructions | Next

## Chapter 20. Using the X Composite Extension

X.Org X servers support an X protocol extension called Composite. This extension allows windows to be drawn into pixmaps instead of directly onto the screen. In conjunction with the Damage and Render extensions, this allows a program called a composite manager to blend windows together to draw the screen.

Performance will be degraded significantly if the `RenderAccel` option is disabled in xorg.conf. See Appendix B, X Config Options for more details.

When the NVIDIA X driver is used and the Composite extension is enabled, NVIDIA's OpenGL implementation interacts properly with the Damage and Composite X extensions. This means that OpenGL rendering is drawn into offscreen pixmaps and the X server is notified of the Damage event when OpenGL renders to the pixmap. This allows OpenGL applications to behave properly in a composited X desktop.

If the Composite extension is enabled on an X server older than X11R6.9.0, then GLX will be disabled. You can force GLX on while Composite is enabled on pre-X11R6.9.0 X servers with the `AllowGLXWithComposite` X configuration option. However, GLX will not render correctly in this environment. Upgrading your X server to X11R6.9.0 or newer is recommended.

You can enable the Composite X extension by running nvidia-xconfig --composite. Composite can be disabled with nvidia-xconfig --no-composite. See the nvidia-xconfig(1) man page for details.

If you are using an OpenGL-based composite manager, you may also need the `DisableGLXRootClipping` option to obtain proper output.

The Composite extension also causes problems with other driver components:

- Xv adaptors will ignore the sync-to-vblank option when drawing into a redirected window.

- Workstation overlays are incompatible with Composite. Workstation overlays will be automatically disabled when Composite is detected.

- The NVIDIA FreeBSD driver supports quad-buffered stereo together with Composite. However, many composite managers will only texture from and display the left eye content, effectively disabling the stereo effect. Workarounds for this problem are either to use a different composite manager that supports stereo or disable the Composite extension.

- The Composite extension is incompatible with Xinerama in X.Org X servers prior to version 1.10. Composite will be automatically disabled when Xinerama is enabled on those servers.

- Prior to X.Org X server version 1.15, the Damage extension does not properly report rendering events on all physical X screens in Xinerama configurations. This prevents most composite mangers from rendering correctly.

This NVIDIA FreeBSD driver supports OpenGL rendering to 32-bit ARGB windows. 32-bit visuals are only available on screens with depths 24 or 30. If you are an application developer, you can use these new visuals in conjunction with a composite manager to create translucent OpenGL applications:

        int attrib[] = {
            GLX_RENDER_TYPE, GLX_RGBA_BIT,
            GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
            GLX_RED_SIZE, 1,
            GLX_GREEN_SIZE, 1,
            GLX_BLUE_SIZE, 1,
            GLX_ALPHA_SIZE, 1,
            GLX_DOUBLEBUFFER, True,
            GLX_DEPTH_SIZE, 1,
            None };
        GLXFBConfig *fbconfigs, fbconfig;
        int numfbconfigs, render_event_base, render_error_base;
        XVisualInfo *visinfo;
        XRenderPictFormat *pictFormat;

        /* Make sure we have the RENDER extension */
        if(!XRenderQueryExtension(dpy, &render_event_base, &render_error_base)) {
            fprintf(stderr, "No RENDER extension found\n");
            exit(EXIT_FAILURE);
        }

        /* Get the list of FBConfigs that match our criteria */
        fbconfigs = glXChooseFBConfig(dpy, scrnum, attrib, &numfbconfigs);
        if (!fbconfigs) {
            /* None matched */
            exit(EXIT_FAILURE);
        }

        /* Find an FBConfig with a visual that has a RENDER picture format that
         * has alpha */
        for (i = 0; i < numfbconfigs; i++) {
            visinfo = glXGetVisualFromFBConfig(dpy, fbconfigs[i]);
            if (!visinfo) continue;
            pictFormat = XRenderFindVisualFormat(dpy, visinfo->visual);
            if (!pictFormat) continue;

            if(pictFormat->direct.alphaMask > 0) {
                fbconfig = fbconfigs[i];
                break;
            }

            XFree(visinfo);
        }

        if (i == numfbconfigs) {
            /* None of the FBConfigs have alpha.  Use a normal (opaque)
             * FBConfig instead */
            fbconfig = fbconfigs[0];
            visinfo = glXGetVisualFromFBConfig(dpy, fbconfig);
            pictFormat = XRenderFindVisualFormat(dpy, visinfo->visual);
        }

        XFree(fbconfigs);

When rendering to a 32-bit window, keep in mind that the X RENDER extension, used by most composite managers, expects "premultiplied alpha" colors. This means that if your color has components (r,g,b) and alpha value a, then you must render (a*r, a*g, a*b, a) into the target window.

More information about Composite can be found at http://freedesktop.org/Software/CompositeExt

Prev | Up | Next
Chapter 19. Configuring Low-level Parameters | Home | Chapter 21. Using the nvidia-settings Utility