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

## Chapter 18. Using the X Composite Extension

X.Org X servers, beginning with X11R6.8.0, contain experimental support for a new 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 F, X Config Options for more details.

When the NVIDIA X driver is used with an X.Org X server X11R6.9.0 or newer 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 Composite with GLX, it is recommended that you also enable the `DamageEvents` X option for enhanced performance. 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:

- In X servers prior to X.Org 7.1, Xv cannot draw into pixmaps that have been redirected offscreen and will draw directly onto the screen instead. For some programs you can work around this issue by using an alternative video driver. For example, "mplayer -vo x11" will work correctly, as will "xine -V xshm". If you must use Xv with an older server, you can also disable the compositing manager and re-enable it when you are finished.

  On X.Org 7.1 and higher, the driver will properly redirect video into offscreen pixmaps. Note that the Xv adaptors will ignore the sync-to-vblank option when drawing into a redirected window.

- Workstation overlays, stereo visuals, and the unified back buffer (UBB) are incompatible with Composite. These features will be automatically disabled when Composite is detected.

This NVIDIA FreeBSD supports OpenGL rendering to 32-bit ARGB windows on X.Org 7.2 and higher or when the `AddARGBGLXVisuals` X config file option is enabled. 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
Appendix D. Configuring Low-level Parameters | Home | Chapter 19. Using the nvidia-settings Utility