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

Search this page:

PCMProcess.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/PCMProcess.h"

#include "../include/PCMApplication.h"

#include "../include/PCMNode.h"

#include "../include/PCMHost.h"

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

#include "../include/PCMOpenGLExtensionLoader.h"

//
// Outer includes
//

#include <GL/glu.h>

namespace ParCompMark
{

  //
  // Class constants
  //

  const std::string Process::PROCESSINITNUT = "scripts/framework/process-init.nut";
  const std::string Process::DEFAULTEXPORTPATTERN = "%06d.png";

  //
  // Constructors & destructor
  //

   Process::Process():
        // Parent class initializer 
   Thread("invalid host"        /* Name of the host */
        )
        // You have to initialize the following attributes:
        // - mContexts
        // - mProcessType
        // - mParent
        // - mRenderWindow
        // - mRenderingEngine
        // - mSqVM
        // - mInitProcCode
        // - mRunningProcCode
        // - mBuffer
        // - mInitialized
        // - mSortOrder
        // - mStopID
        // - mOperate
        // - mDisplayOutput
        // - mGatherStatistics
        // - mFrameNumber
        // - mFrameTime
        // - mStartTime
        // - mStop
        // - mStopAble
        // - mCountedStop
        // - mOutputDocument
        // - mShowFrameletIcon
        // - mExportFrameStep
        // - mFrameFilenamePattern
  {
        Except(INVALID_OPERATION_ERROR, "Process::Process()",
           "Default constructor for Squirrel compatibility. Calling this constructor always raises an exception.");
  }

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

  Process::Process(const std::string & name, Node * parent):
        // Parent class initializer 
   Thread(name          /* Name of the host */
  ),
        // Parent class initializer 
   Name(name                    /* Name of the node */
  ),
        // Initialize parent node 
   mParent(parent               /* Parent node */
        )
        // You have to initialize the following attributes:
        // - mContexts
        // - mProcessType
        // - mParent
        // - mRenderWindow
        // - mRenderingEngine
        // - mSqVM
        // - mInitProcCode
        // - mRunningProcCode
        // - mBuffer
        // - mInitialized
        // - mSortOrder
        // - mStopID
        // - mOperate
        // - mDisplayOutput
        // - mGatherStatistics
        // - mFrameNumber
        // - mFrameTime
        // - mStartTime
        // - mStop
        // - mStopAble
        // - mCountedStop
        // - mOutputDocument
        // - mShowFrameletIcon
        // - mExportFrameStep
        // - mFrameFilenamePattern
  {
        Assert(parent, NULL_POINTER_ERROR, "Process::Process()");

        mProcessType = RENDER;

        // mBuffer is autoinitialized

        // Create context by default

        //mContexts

        // No squirrel operation by default
        mInitProcCode = "";
        mRunningProcCode = "";

        mInitialized = false;

        mStopID = 0;

        // By default this process is an ideal good-working man saying nothing
        mOperate = true;
        mDisplayOutput = false;
        mGatherStatistics = true;

        mFrameNumber = 0;
        mFrameTime = 0.0;

        mStop = false;
        mStopAble = false;
        mCountedStop = false;

        mStartTime = Timer::getSystemTime();

        // Create output document
        mOutputDocument = new OutputNode("process", OutputNode::INFORMATION);
        mOutputDocument->setAttribute("name", mName);

        // Show framelet icon by default
        mShowFrameletIcon = true;

        // Frame exporting
        mExportFrameStep = 0;
        mFrameFilenamePattern = (char *) (DEFAULTEXPORTPATTERN.c_str());

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

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

  Process::~Process()
  {
        if(mInitProcCode)
         delete mInitProcCode;

        if(mRunningProcCode)
         delete mRunningProcCode;

        if(mFrameFilenamePattern && mFrameFilenamePattern != DEFAULTEXPORTPATTERN.c_str())
         delete mFrameFilenamePattern;

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

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

  //
  // Methods
  //

  void Process::threadInitialize()
  {

        //fprintf(stderr, "threadInit start: %s\n", mName.c_str());

        Assert(!mInitialized, INVALID_OPERATION_ERROR, "Process::initialize()");

        // Create virtual machine
        mSqVM = new SqVM(mName + "-VM");

        // TODO: every Process opens a window (offline rendering)
        openRenderWindow(mThreadName, "", false, 0, GLXRenderWindow::DEFAULTWINDOWWIDTH,
                         GLXRenderWindow::DEFAULTWINDOWHEIGHT);

        // Create rendering engine
        mRenderingEngine = new OpenGLRenderingEngine(this);

        // Initialize process from squirrel
        mSqVM.lock();
        // Load PC API, ParCompMark API, and utils
        mSqVM->runScriptFromFile(FileSystemManager::getInstance()->getPathDataFile(Application::PCAPINUT),
                                 SqVM::NOMAINMETHOD);
        mSqVM->runScriptFromFile(FileSystemManager::getInstance()->getPathDataFile(Application::PARCOMPMARKNUT),
                                 SqVM::NOMAINMETHOD);
        mSqVM->runScriptFromFile(FileSystemManager::getInstance()->getPathDataFile(Application::UTILSNUT),
                                 SqVM::NOMAINMETHOD);
        std::list < std::string > params;
        params.push_back(StringConverter::toString((void *) mRenderingEngine.getPtr()));
        mSqVM->runScriptFromFile(FileSystemManager::getInstance()->getPathDataFile(PROCESSINITNUT), "main", params);
        mSqVM.unlock();

        // Load queued extensions
        mRenderWindow.lock();
        mRenderWindow->setCurrent();
        OpenGLExtensionLoader::loadDelayed();
        mRenderWindow.unlock();

        // Process initialization
        initProcess();

        // PC initialization
        initPC();

        // Actualize GLX render window on PC information 
        actualizeRenderWindow();

        // Disable framelet ico
        if(Application::getInstance()->getConfigOptions()->testString("frameletIcon", "false"))
         mShowFrameletIcon = false;

        //TODO: hack
        if(mProcessType == COMPOSITE)
        {
         mStopAble = true;
        }

        if(mStopID != 0 && Application::getInstance()->getCommanderMode())
        {
         mCountedStop = true;
        }
        // Re-reset window to get the most accurate window statistics
        mRenderWindow.lock();
        mRenderWindow->resetStatistics();
        mRenderWindow.unlock();

        mInitialized = true;
        Logger::getInstance()->log(Logger::DEBUG, "Process `" + mName + "\' has been initialized.");
  }

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

  void Process::threadFinalize()
  {

        //if(mSqVM->getInitialized())
        // mSqVM->finalize();
        mSqVM.kill();
        mRenderingEngine.kill();

        for(ContextListIterator i = mContexts.begin(); i != mContexts.end(); i++)
         (*i)->finalize();

        mRenderWindow.kill();

        Host::IntPointer intP = Host::getInstance()->getEndProcessCount();

        intP.lock();
        (*intP.getPtr())++;

        if(*intP.getPtr() == Host::getInstance()->getProcessCount())
        {
         if(mCountedStop)
                Application::getInstance()->_pseudoStop();
        }

        intP.unlock();

        mInitialized = false;
        Logger::getInstance()->log(Logger::DEBUG, "Process `" + mName + "\' has been finalized.");
  }

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

  void Process::start()
  {
        startThread();
  }

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

  u32 Process::stop()
  {
        if(mStopAble)
        {
         mStop = true;
         wait();
         //Timer::sleep(1.5);
         return (*mContexts.begin())->getFrameID();
        } else
        {
         return 0;
        }
  }

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

  Context *Process::addContext()
  {

        Context::Pointer context = Context::Pointer(new Context(this));

        mContexts.push_back(context);

        return context.getPtr();

  }

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

  void Process::initPC()
  {
        // Initialize context if neeeded

        for(ContextListIterator i = mContexts.begin(); i != mContexts.end(); i++)
         if(!(*i)->getInitialized())
                (*i)->initialize();

        if(mProcessType == COMPOSITE)
        {
         Assert(mContexts.size() == 1, INVALID_VALUE_ERROR, "Process::initPC()");
         if(PCerr err =
           pcContextSetInteger((*mContexts.begin())->getContext(), PC_OUTPUT_WIDTH,
                                 (*mContexts.begin())->getHostIndex(), mBuffer->getWidth()) != PC_NO_ERROR)
                Except(INTERNAL_ERROR, "Process::initPC()", pcGetErrorString(err));

         if(PCerr err =
           pcContextSetInteger((*mContexts.begin())->getContext(), PC_OUTPUT_X_OFFSET,
                                 (*mContexts.begin())->getHostIndex(), mBuffer->getLeft()) != PC_NO_ERROR)
                Except(INTERNAL_ERROR, "Process::initPC()", pcGetErrorString(err));

         if(PCerr err =
           pcContextSetInteger((*mContexts.begin())->getContext(), PC_OUTPUT_HEIGHT,
                                 (*mContexts.begin())->getHostIndex(), mBuffer->getHeight()) != PC_NO_ERROR)
                Except(INTERNAL_ERROR, "Process::initPC()", pcGetErrorString(err));

         if(PCerr err =
           pcContextSetInteger((*mContexts.begin())->getContext(), PC_OUTPUT_Y_OFFSET,
                                 (*mContexts.begin())->getHostIndex(), mBuffer->getTop()) != PC_NO_ERROR)
                Except(INTERNAL_ERROR, "Process::initPC()", pcGetErrorString(err));
        }
        // Set default sort order
        mSortOrder = (*mContexts.begin())->getHostIndex();
  }

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

  void Process::openRenderWindow(const std::string caption, const std::string & displayName,
                                 const bool & fullScreen, const u32 & colourDepth,
                                 const u32 & width, const u32 & height, const s32 & left,
                                 const s32 & top, const u32 & fsaaSamples)
  {

        // Get display
        XDisplay::Pointer display(getParent()->getParent()->openXDisplay(displayName));

        // Create window
        mRenderWindow =
         new GLXRenderWindow(display, this, caption, fullScreen, colourDepth, width, height, left, top, fsaaSamples);

        // Show window
        mRenderWindow.lock();
        mRenderWindow->initialize();
        mRenderWindow->setVisible(true);
        mRenderWindow->setCurrent();
        mRenderWindow.unlock();

        // If no multi-threading is supported wait for a while and pray :)
        if(!display->getXMTSupported())
        {
         Logger::getInstance()->log(Logger::WARNING,
                                   "Since multi-threading is not supported for your Xlib, wait a second to avoid crashes. Some pray might be also useful :)");
         Timer::sleep(1.0);
        }

        Logger::getInstance()->log(Logger::DEBUG,
                                 "Process `" + mName + "\' has opened render window `" + caption + "\'");
  }

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

  void Process::actualizeRenderWindow()
  {
        mRenderWindow.lock();
        mRenderWindow->resize(mBuffer->getWidth(), mBuffer->getHeight());
        mRenderWindow->reposition(GLXRenderWindow::CENTERED, GLXRenderWindow::CENTERED);
        //glViewport(0, 0, mRenderWindow->getWidth(), mRenderWindow->getHeight());
        mRenderWindow.unlock();

        // Resize the canvas of the custom renderers
        mRenderingEngine->resizeRenderers(mBuffer->getWidth(), mBuffer->getHeight());
  }

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

  void Process::setViewportForRendering()
  {
        //never mind which context, because RENDER process render the same frame to several contexts
        double Xn0 =
         (2.0 / (*mContexts.begin())->getFrameWidth() * mBuffer->getLeft() -
          1.0) * (*mContexts.begin())->getProcessCount();
        double Xnw =
         (2.0 * mBuffer->getWidth() / (*mContexts.begin())->getFrameWidth()) *
         (*mContexts.begin())->getProcessCount();
        double Yn0 =
         (2.0 / (*mContexts.begin())->getFrameHeight() * mBuffer->getTop() -
          1.0) * (*mContexts.begin())->getProcessCount();
        double Ynw =
         (2.0 * mBuffer->getHeight() / (*mContexts.begin())->getFrameHeight()) *
         (*mContexts.begin())->getProcessCount();

        double viewportLeft = -(Xn0 + 1.0) / Xnw;
        double viewportTop = -(Yn0 + 1.0) / Ynw;
        double viewportWidth = 2.0 / Xnw;
        double viewportHeight = 2.0 / Ynw;

        mRenderingEngine->viewport(viewportLeft, viewportTop, viewportWidth, viewportHeight);
  }

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

  void Process::displayFrameletIcon()
  {
        mRenderingEngine->viewport(0.0, 0.0, 1.0, 1.0);

        // Setup pixel operations
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_DEPTH_TEST);
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        // Get window sizes
        Real winWidth = (Real) mRenderWindow->getWidth();
        Real winHeight = (Real) mRenderWindow->getHeight();

        // Setup 2D projection mode
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0.0, winWidth, winHeight, 0.0);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        // Get frame sizes, never mind which context beacuse RENDER process render the same frame in several contexts
        Real frameWidth = (Real) (*mContexts.begin())->getFrameWidth();
        Real frameHeight = (Real) (*mContexts.begin())->getFrameHeight();

        // Get framelet sizes
        Real frameletLeft = (Real) mBuffer->getLeft();
        Real frameletTop = (Real) mBuffer->getTop();
        Real frameletWidth = (Real) mBuffer->getWidth();
        Real frameletHeight = (Real) mBuffer->getHeight();

        // Frame icons position and sizes
        Real frameIconLeft = 10.0;
        Real frameIconTop = 10.0;
        Real frameIconWidth = 32.0;
        Real frameIconHeight = frameHeight / frameWidth * 32.0;

        // Framelet icons position and sizes
        Real frameletIconLeft = 10.0 + frameletLeft / frameWidth * frameIconWidth;
        Real frameletIconTop = 10.0 + frameletTop / frameHeight * frameIconHeight;
        Real frameletIconWidth = frameletWidth / frameWidth * frameIconWidth;
        Real frameletIconHeight = frameletHeight / frameHeight * frameIconHeight;

        glBegin(GL_QUADS);
        {
         // Draw frame icon
         glColor4f(1.0, 1.0, 1.0, 0.1);
         glVertex2f(frameIconLeft + frameIconWidth, frameIconTop);
         glVertex2f(frameIconLeft, frameIconTop);
         glVertex2f(frameIconLeft, frameIconTop + frameIconHeight);
         glVertex2f(frameIconLeft + frameIconWidth, frameIconTop + frameIconHeight);

         // Draw framelet icon
         glColor4f(1.0, 1.0, 1.0, 0.4);
         glVertex2f(frameletIconLeft + frameletIconWidth, frameletIconTop);
         glVertex2f(frameletIconLeft, frameletIconTop);
         glVertex2f(frameletIconLeft, frameletIconTop + frameletIconHeight);
         glVertex2f(frameletIconLeft + frameletIconWidth, frameletIconTop + frameletIconHeight);
        }
        glEnd();

        glBegin(GL_LINE_LOOP);
        {
         // Draw frame icon border
         glColor4f(1.0, 1.0, 1.0, 0.4);
         glVertex2f(frameIconLeft, frameIconTop);
         glVertex2f(frameIconLeft + frameIconWidth, frameIconTop);
         glVertex2f(frameIconLeft + frameIconWidth, frameIconTop + frameIconHeight);
         glVertex2f(frameIconLeft, frameIconTop + frameIconHeight);
        }
        glEnd();

        glEnable(GL_DEPTH_TEST);
        glDisable(GL_BLEND);
  }

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

  void Process::initProcess()
  {
        // If the process has a window, do initialization
        if(mRenderWindow.isNotNull() && strlen(mInitProcCode))
        {
         // Run squirrel code
         mSqVM.lock();
         mSqVM->runScriptFromString(mInitProcCode, "initProc", "initProc");
         mSqVM.unlock();
        }

        Logger::getInstance()->log(Logger::DEBUG, "Process `" + mName + "\' has executed its initProcess method.");
  }

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

  void Process::runningProcess()
  {
        mRenderWindow.lock();

        // Start a new frame
        mRenderWindow->startFrame();

        // Frame number and elapsed time since the start of the benchmark
        mFrameNumber = mRenderWindow->getWindowStatistics().frameCount;
        mFrameTime = Timer::getSystemTime() - mStartTime;

        // TODO: should not be here
        setViewportForRendering();

        // Clear output
        glClearColor(0.0, 0.2, 0.4, 0.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        switch (mProcessType)
        {
         case RENDER:
                {
                 glEnable(GL_DEPTH_TEST);

                 // The automatic renderings are done before the explicit runningProc method
                 mRenderingEngine->doAutoRendering();

                 // Execture squirrel task if specified
                 if(strlen(mRunningProcCode))
                 {
                        // Create parameters (time and number of current frame)
                        std::list < std::string > params;
                        params.push_back(StringConverter::toString(mFrameTime));
                        params.push_back(StringConverter::toString(mFrameNumber));

                        // Run squirrel code
                        mSqVM.lock();
                        mSqVM->runScriptFromString(mRunningProcCode, "runningProc", "runningProc", params);
                        mSqVM.unlock();
                 }

                 break;
                }
         case COMPOSITE:
                {
                 // Blit composited output to the screen (if specified)
                 if(mDisplayOutput)
                 {
                        glDisable(GL_DEPTH_TEST);
                        glPixelStorei(GL_UNPACK_ROW_LENGTH, mBuffer->getOutputRowPixel());
                        glDrawPixels(mBuffer->getWidth(), mBuffer->getHeight(), GL_BGRA, GL_UNSIGNED_BYTE,
                                  mBuffer->getColour());
                 }
                }
                break;
        }

        // Finish the frame now on composite type process
        // (render type process will finish after calling pcFrameAdd*Framelet)
        if(mProcessType == COMPOSITE)
        {
         mRenderWindow->finishFrame();
         mRenderWindow.unlock();
        }

  }

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

  void Process::setBufferByName(const char *name)
  {
        mBuffer = mParent->getBuffer(name);
  }

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

  void Process::setFinito(const u32 & frameID)
  {
        if(frameID != 0)
        {
         mStopID = frameID;
         mStop = false;
        }

  }

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

  void Process::task()
  {
        switch (mProcessType)
        {
         case RENDER:

                // If this rendering process operates, start a normal frame
                if(mOperate)
                {

                 // Refresh sort order
                 refreshSortOrder();

                 for(ContextListIterator i = mContexts.begin(); i != mContexts.end(); i++)
                 {

                        if(PCerr err =
                         pcFrameBegin((*i)->getContext(), &(*mContexts.begin())->getFrameID(), 1,
                                        (PCuint *) & mBuffer->getLeft(), (PCuint *) & mBuffer->getTop(),
                                        (PCuint *) & mBuffer->getWidth(), (PCuint *) & mBuffer->getHeight(),
                                        &mSortOrder) != PC_NO_ERROR)
                         Except(INTERNAL_ERROR, "Process::task()", pcGetErrorString(err));

                 }

                 // Call running process
                 runningProcess();

                 for(ContextListIterator i = mContexts.begin(); i != mContexts.end(); i++)
                 {

                        if(!(*i)->getUseGLFrameletEXT())
                        {

                         // Read back data
                         PCuint *colour = mBuffer->getColour();
                         void *depth = mBuffer->getDepth();

                         glPixelStorei(GL_PACK_ROW_LENGTH, mBuffer->getWidth());
                         glReadPixels(0, 0, mBuffer->getWidth(), mBuffer->getHeight(), GL_BGRA, GL_UNSIGNED_BYTE,
                                         colour);
                         if(glGetError() != GL_NO_ERROR)
                                Except(INTERNAL_ERROR, "Process::task()",
                                   "glReadPixels colour channel failed on process `" + mName + "\'");
                         glReadPixels(0, 0, mBuffer->getWidth(), mBuffer->getHeight(), GL_DEPTH_COMPONENT,
                                         GL_UNSIGNED_INT, depth);
                         if(glGetError() != GL_NO_ERROR)
                                Except(INTERNAL_ERROR, "Process::task()",
                                   "glReadPixels depth channel failed on process `" + mName + "\'");

                         if(PCerr err =
                           pcFrameAddFramelet((*i)->getContext(), (*mContexts.begin())->getFrameID(),
                                                mBuffer->getColour(), mBuffer->getDepth()) != PC_NO_ERROR)
                                Except(INTERNAL_ERROR, "Process::task()", pcGetErrorString(err));
                        }

                        else
                        {
#ifdef PC_EXT_CUR_GFX_CTX
                         if(PCerr err =
                           pcFrameAddGLFrameletEXT((*i)->getContext(), (*mContexts.begin())->getFrameID(), 0,
                                                   0) != PC_NO_ERROR)
                                Except(INTERNAL_ERROR, "Process::task()", pcGetErrorString(err));
#else
                         Except(INTERNAL_ERROR, "Process::task()",
                                 "PC_EXT_CUR_GFX_CTX extension is not present in your PC interface, cannot call pcFrameAddGLFrameletEXT.");
#endif
                        }
                 }
                 // Display small icon on to top-left corner of the GLX window indicating 
                 // the frame/framelet relationship for this process.
                 if(mShowFrameletIcon)
                        displayFrameletIcon();

                 // Finish frame now
                 mRenderWindow->finishFrame();
                 mRenderWindow.unlock();

                }
                // Only start an empty frame (just like compositing process)
                else
                {
                 for(ContextListIterator i = mContexts.begin(); i != mContexts.end(); i++)
                 {
                        if(PCerr err =
                         pcFrameBegin((*i)->getContext(), &(*mContexts.begin())->getFrameID(), 0, 0, 0, 0, 0,
                                        0) != PC_NO_ERROR)
                         Except(INTERNAL_ERROR, "Process::task()", pcGetErrorString(err));
                 }
                }

                break;
         case COMPOSITE:
                Assert(mContexts.size() == 1, INVALID_VALUE_ERROR, "Proccess::task");
                if(PCerr err =
                 pcFrameBegin((*mContexts.begin())->getContext(), &(*mContexts.begin())->getFrameID(), 0, 0, 0, 0, 0,
                                0) != PC_NO_ERROR)
                 Except(INTERNAL_ERROR, "Process::task()", pcGetErrorString(err));
                break;
        }

        for(ContextListIterator i = mContexts.begin(); i != mContexts.end(); i++)
        {

         if(PCerr err = pcFrameEnd((*i)->getContext(), (*mContexts.begin())->getFrameID()) != PC_NO_ERROR)
                Except(INTERNAL_ERROR, "Process::task()", pcGetErrorString(err));
        }

        if(mStop && mStopAble)
        {

         go();

         wait();

        }

        if(mStopID && (*mContexts.begin())->getFrameID() >= mStopID)
        {
         stopThread();
        }

        else
        {

         if(mProcessType == COMPOSITE)
         {
                Assert(mContexts.size() == 1, INVALID_VALUE_ERROR, "Process::task");

                mBuffer.lock();

                PCchannel channel;

                if(PCerr err =
                 pcFrameResultChannel((*mContexts.begin())->getContext(), (*mContexts.begin())->getFrameID(),
                                        mBuffer->getLeft(), mBuffer->getTop(), mBuffer->getWidth(),
                                        mBuffer->getHeight(), PC_CHANNEL_COLOR, &channel) != PC_NO_ERROR)
                 Except(INTERNAL_ERROR, "Process::task()", pcGetErrorString(err));

                mBuffer->setColour((PCuint *) channel.address);
                mBuffer->setOutputRowPixel(channel.rowLength);

                // Call running process
                runningProcess();

                // Export actual frame
                if(mExportFrameStep && !(mFrameNumber % mExportFrameStep))
                {
                 // TODO: this can cause memory fault
                 char *filename = new char[strlen(mFrameFilenamePattern) + 16];

                 sprintf(filename, mFrameFilenamePattern, mFrameNumber);
                 mBuffer->saveToFile(filename);

                 delete[]filename;
                }

                mBuffer.unlock();
         }
         // Gather statistics
         if(mGatherStatistics)
                gatherStatistics();
        }
  }

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

  void Process::refreshSortOrder()
  {
        // Refresh sort order from rendering plugins, if have
        int order = mRenderingEngine->getSortOrderFromRenderers();

        if(order != -1)
         mSortOrder = order;
  }

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

  void Process::gatherStatistics()
  {
        GLXRenderWindow::WindowStatistics w = mRenderWindow->getWindowStatistics();

        OutputNode::Pointer statistics(new OutputNode("frame", OutputNode::STATISTICS));
        statistics->setAttribute("frame-id", StringConverter::toString((*mContexts.begin())->getFrameID()));
        statistics->setAttribute("time", StringConverter::toString(w.renderingTime));
        statistics->setAttribute("last-fps", StringConverter::toString(w.lastFPS));
        statistics->setAttribute("average-fps", StringConverter::toString(w.avgFPS));
        statistics->setAttribute("best-fps", StringConverter::toString(w.bestFPS));
        statistics->setAttribute("worst-fps", StringConverter::toString(w.worstFPS));
        statistics->setAttribute("frame-begin-time",
                                 StringConverter::toString(w.frameBeginTime, StringConverter::DEFAULTFIELDWIDTH, 6));
        statistics->setAttribute("frame-end-time",
                                 StringConverter::toString(w.frameEndTime, StringConverter::DEFAULTFIELDWIDTH, 6));
        statistics->setAttribute("last-frame-time", StringConverter::toString(w.lastFrameTime));
        statistics->setAttribute("best-frame-time", StringConverter::toString(w.bestFrameTime));
        statistics->setAttribute("worst-frame-time", StringConverter::toString(w.worstFrameTime));
        statistics->setAttribute("last-triangle-count", StringConverter::toString(w.lastTriangleCount));
        statistics->setAttribute("average-triangle-count", StringConverter::toString(w.avgTriangleCount));
        statistics->setAttribute("minimal-triangle-count", StringConverter::toString(w.minTriangleCount));
        statistics->setAttribute("maximal-triangle-count", StringConverter::toString(w.maxTriangleCount));

#ifdef PC_EXT_IO_COUNT
        int write,
        read;

        if(PCerr err =
         pcContextGetInteger((*mContexts.begin())->getContext(), PC_WRITE_COUNT_EXT,
                           (*mContexts.begin())->getHostIndex(), &write) != PC_NO_ERROR)
         Except(INTERNAL_ERROR, "Process::initPC()", pcGetErrorString(err));
        statistics->setAttribute("write-count", StringConverter::toString(write));

        if(PCerr err =
         pcContextGetInteger((*mContexts.begin())->getContext(), PC_READ_COUNT_EXT,
                           (*mContexts.begin())->getHostIndex(), &read) != PC_NO_ERROR)
         Except(INTERNAL_ERROR, "Process::initPC()", pcGetErrorString(err));
        statistics->setAttribute("read-count", StringConverter::toString(read));
#endif

        mOutputDocument->addChildNode(statistics);
  }

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

}

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