• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMXDisplay.cpp

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

//
// Inner includes
//

#include "../include/PCMXDisplay.h"

#include "../include/PCMStringConverter.h"

namespace ParCompMark
{

  //
  // Class constants
  //

  const s32 XDisplay::IGNOREMULTISAMPLE = -1;
  const s32 XDisplay::UNKNOWNDIMENSION = 0;

  //
  // Class variables
  //

  bool XDisplay::mXMTInitialized = false;
  bool XDisplay::mXMTSupported = false;
  Mutex XDisplay::mErrorHandlerMutex;
  bool XDisplay::mTolerateErrors = false;

  //
  // Constructors & destructor
  //

   XDisplay::XDisplay(const std::string & displayName)
        // You have to initialize the following attributes:
        // - mDisplayName
        // - mDisplay
        // - mInitialized
        // - mXMTInitialized
        // - mXMTSupported
        // - mWidth
        // - mHeight
        // - mErrorHandlerMutex
        // - mTolerateErrors
  {
        mDisplayName = displayName;
        mDisplay = 0;
        mInitialized = false;

        mWidth = mHeight = UNKNOWNDIMENSION;

        Logger::getInstance()->log(Logger::NOTICE, "Display `" + mDisplayName + "\' has been created.");
  }

 /*----------------------------------------------------------------------*/

  XDisplay::~XDisplay()
  {
        if(mInitialized)
         finalize();

        Logger::getInstance()->log(Logger::NOTICE, "Display `" + mDisplayName + "\' has been destroyed.");
  }

 /*----------------------------------------------------------------------*/

  //
  // Class methods
  //

  int XDisplay::errorHandler(Display * display, XErrorEvent * errorEvent)
  {
        // Skip Xlib errors
        if(mTolerateErrors)
         return 0;

        // For synchronization the class level error handling
        mErrorHandlerMutex.lock();

        const u32 bufSize = 10240;
        char buffer_return[bufSize];

        memset(buffer_return, 0, bufSize);

        // Obtain error message
        XGetErrorText(errorEvent->display, errorEvent->error_code, buffer_return, bufSize);

        std::string errorMessage =
         buffer_return + std::string(" (error code: " + StringConverter::toString((u16) errorEvent->error_code) +
                                        ") on display `") + DisplayString(errorEvent->display) +
         "\', serial number of failed request: " + StringConverter::toString((u32) errorEvent->serial) +
         ", op-code of failed request: " + StringConverter::toString((u16) errorEvent->request_code) + "." +
         StringConverter::toString((u16) errorEvent->minor_code);

        // For synchronization the class level error handling
        mErrorHandlerMutex.unlock();

        // Throw an exception
        Except(XLIB_ERROR, "XDisplay::errorHandler()", errorMessage);

        return 0;
  }

 /*----------------------------------------------------------------------*/

  //
  // Methods
  //

  void XDisplay::initialize()
  {
        Assert(!mInitialized, INVALID_OPERATION_ERROR, "XDisplay::initialize()");

        // Initialize multi-threading if needed
        if(!mXMTInitialized)
         initializeMT();

        if(mDisplayName.length() > 0)
         mDisplay = XOpenDisplay(mDisplayName.c_str());
        else
         mDisplay = XOpenDisplay(0);

        // If XOpenDisplay() does not succeed, it returns NULL
        Assert(mDisplay, INVALID_NAME_ERROR, "XDisplay::initialize()");

        // Get dimensions
        int screen = DefaultScreen(mDisplay);

        mWidth = (u32) DisplayWidth(mDisplay, screen);
        mHeight = (u32) DisplayHeight(mDisplay, screen);

        mInitialized = true;

        Logger::getInstance()->log(Logger::DEBUG,
                                 "Display `" + mDisplayName + "\' has been initialized: " +
                                 StringConverter::toString(mDisplay) + ".");
  }

 /*----------------------------------------------------------------------*/

  void XDisplay::finalize()
  {
        Assert(mInitialized, INVALID_OPERATION_ERROR, "XDisplay::finalize()");
        Assert(mDisplay, NULL_POINTER_ERROR, "XDisplay::finalize()");

        synchronize();

        // Close display
        XCloseDisplay(mDisplay);
        mDisplay = 0;

        mInitialized = false;

        Logger::getInstance()->log(Logger::DEBUG, "Display `" + mDisplayName + "\' has been finalized.");
  }

 /*----------------------------------------------------------------------*/

  void XDisplay::synchronize(const bool & discard)
  {
        // The XSync() function flushes the output buffer and then waits until all 
        // requests have been received and processed by the X server.
        XSync(mDisplay, discard ? True : False);
  }

 /*----------------------------------------------------------------------*/

  s32 XDisplay::findBestVisual(const s32 & screenNumber, const s32 & multiSample)
  {
        XVisualInfo theTemplate;
        XVisualInfo *visuals;
        int numVisuals;
        long mask;
        int i;
        VisualAttribs bestVis;

        // get list of all visuals on this screen 
        theTemplate.screen = screenNumber;
        mask = VisualScreenMask;
        visuals = XGetVisualInfo(mDisplay, mask, &theTemplate, &numVisuals);
        if(numVisuals == 0 || visuals == 0)
        {
         // something went wrong 
         if(visuals)
                XFree(visuals);
         return -1;
        }
        // init bestVis with first visual info 
        getVisualAttribs(&visuals[0], bestVis);

        // try to find a "better" visual 
        for(i = 1; i < numVisuals; i++)
        {
         VisualAttribs vis;

         getVisualAttribs(&visuals[i], vis);

         // always skip visuals that are slow 
         if(vis.visualCaveat == GLX_SLOW_VISUAL_EXT)
                continue;

         // skip visual if it doesn't have the desired number of multisamples 
         if(multiSample != -1 && vis.numSamples != multiSample)
                continue;

         // see if this vis is better than bestVis 
         if((!bestVis.supportsGL && vis.supportsGL) || (bestVis.visualCaveat != GLX_NONE_EXT)
           || (!bestVis.rgba && vis.rgba) || (!bestVis.doubleBuffer && vis.doubleBuffer)
           || (bestVis.redSize < vis.redSize) || (bestVis.greenSize < vis.greenSize)
           || (bestVis.blueSize < vis.blueSize) || (bestVis.alphaSize < vis.alphaSize)
           || (bestVis.depthSize < vis.depthSize) || (bestVis.stencilSize < vis.stencilSize)
           || (bestVis.accumRedSize < vis.accumRedSize))
         {
                // found a better visual 
                bestVis = vis;
         }

        }

        XFree(visuals);

        // We found no visual with the desired FSAA
        if(multiSample != -1 && bestVis.numSamples != multiSample)
         return -1;

        Logger::getInstance()->log(Logger::DEBUG,
                                 std::string("Found visual attributes: ") +
                                 (bestVis.supportsGL ? "OpenGL;" : "no OpenGL;") +
                                 (bestVis.doubleBuffer ? "double;" : "single;") + "R" +
                                 StringConverter::toString(bestVis.redSize) + "G" +
                                 StringConverter::toString(bestVis.greenSize) + "B" +
                                 StringConverter::toString(bestVis.blueSize) + "A" +
                                 StringConverter::toString(bestVis.alphaSize) + "-Z" +
                                 StringConverter::toString(bestVis.depthSize));

        return bestVis.id;
  }

 /*----------------------------------------------------------------------*/

  void XDisplay::getVisualAttribs(XVisualInfo * vInfo, VisualAttribs & attribs)
  {
        const char *ext = glXQueryExtensionsString(mDisplay, vInfo->screen);

        // initialize with zeros
        memset(&attribs, 0, sizeof(VisualAttribs));

        attribs.id = vInfo->visualid;
        attribs.klass = vInfo->c_class;

        attribs.depth = vInfo->depth;
        attribs.redMask = vInfo->red_mask;
        attribs.greenMask = vInfo->green_mask;
        attribs.blueMask = vInfo->blue_mask;
        attribs.colormapSize = vInfo->colormap_size;
        attribs.bitsPerRGB = vInfo->bits_per_rgb;

        if(glXGetConfig(mDisplay, vInfo, GLX_USE_GL, &attribs.supportsGL) != 0)
         return;
        glXGetConfig(mDisplay, vInfo, GLX_BUFFER_SIZE, &attribs.bufferSize);
        glXGetConfig(mDisplay, vInfo, GLX_LEVEL, &attribs.level);
        glXGetConfig(mDisplay, vInfo, GLX_RGBA, &attribs.rgba);
        glXGetConfig(mDisplay, vInfo, GLX_DOUBLEBUFFER, &attribs.doubleBuffer);
        glXGetConfig(mDisplay, vInfo, GLX_STEREO, &attribs.stereo);
        glXGetConfig(mDisplay, vInfo, GLX_AUX_BUFFERS, &attribs.auxBuffers);
        glXGetConfig(mDisplay, vInfo, GLX_RED_SIZE, &attribs.redSize);
        glXGetConfig(mDisplay, vInfo, GLX_GREEN_SIZE, &attribs.greenSize);
        glXGetConfig(mDisplay, vInfo, GLX_BLUE_SIZE, &attribs.blueSize);
        glXGetConfig(mDisplay, vInfo, GLX_ALPHA_SIZE, &attribs.alphaSize);
        glXGetConfig(mDisplay, vInfo, GLX_DEPTH_SIZE, &attribs.depthSize);
        glXGetConfig(mDisplay, vInfo, GLX_STENCIL_SIZE, &attribs.stencilSize);
        glXGetConfig(mDisplay, vInfo, GLX_ACCUM_RED_SIZE, &attribs.accumRedSize);
        glXGetConfig(mDisplay, vInfo, GLX_ACCUM_GREEN_SIZE, &attribs.accumGreenSize);
        glXGetConfig(mDisplay, vInfo, GLX_ACCUM_BLUE_SIZE, &attribs.accumBlueSize);
        glXGetConfig(mDisplay, vInfo, GLX_ACCUM_ALPHA_SIZE, &attribs.accumAlphaSize);

        // get transparent pixel stuff 
        glXGetConfig(mDisplay, vInfo, GLX_TRANSPARENT_TYPE, &attribs.transparentType);
        if(attribs.transparentType == GLX_TRANSPARENT_RGB)
        {
         glXGetConfig(mDisplay, vInfo, GLX_TRANSPARENT_RED_VALUE, &attribs.transparentRedValue);
         glXGetConfig(mDisplay, vInfo, GLX_TRANSPARENT_GREEN_VALUE, &attribs.transparentGreenValue);
         glXGetConfig(mDisplay, vInfo, GLX_TRANSPARENT_BLUE_VALUE, &attribs.transparentBlueValue);
         glXGetConfig(mDisplay, vInfo, GLX_TRANSPARENT_ALPHA_VALUE, &attribs.transparentAlphaValue);
        } else if(attribs.transparentType == GLX_TRANSPARENT_INDEX)
        {
         glXGetConfig(mDisplay, vInfo, GLX_TRANSPARENT_INDEX_VALUE, &attribs.transparentIndexValue);
        }
        // multisample attribs 
        if(ext && strstr("GLX_ARB_multisample", ext) == 0)
        {
         glXGetConfig(mDisplay, vInfo, GLX_SAMPLE_BUFFERS_ARB, &attribs.numMultisample);
         glXGetConfig(mDisplay, vInfo, GLX_SAMPLES_ARB, &attribs.numSamples);
        } else
        {
         attribs.numSamples = 0;
         attribs.numMultisample = 0;
        }

        if(ext && strstr(ext, "GLX_EXT_visual_rating"))
        {
         glXGetConfig(mDisplay, vInfo, GLX_VISUAL_CAVEAT_EXT, &attribs.visualCaveat);
        } else
        {
         attribs.visualCaveat = GLX_NONE_EXT;
        }
  }

 /*----------------------------------------------------------------------*/

  void XDisplay::initializeMT()
  {
        if((mXMTSupported = XInitThreads() != 0))
         Logger::getInstance()->log(Logger::NOTICE, "Multi-threading is initialized for Xlib. ");
        else
         Logger::getInstance()->log(Logger::WARNING,
                                   "No multi-threading is supported for your Xlib. No warranty for thread safeness. Some crashes might be occured.");

        // Also set error handler
        XSetErrorHandler(XDisplay::errorHandler);
        Logger::getInstance()->log(Logger::NOTICE, "Error handler registered for X errors");

        mXMTInitialized = true;
  }

 /*----------------------------------------------------------------------*/

}

© Copyright - 2006 (IT)² ParCompMark Dev. Team