pipe.h

/* Copyright (c) 2005-2015, Stefan Eilemann <eile@equalizergraphics.com>
 *                          Cedric Stalder <cedric.stalder@gmail.com>
 *                          Daniel Nachbaur <danielnachbaur@gmail.com>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *
 * This library 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 Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef EQ_PIPE_H
#define EQ_PIPE_H

#include <eq/api.h>
#include <eq/eye.h> // Eye enum
#include <eq/types.h>
#include <eq/visitorResult.h> // enum

#include <co/objectVersion.h>
#include <eq/fabric/pipe.h> // base class

namespace eq
{
namespace detail
{
class Pipe;
class RenderThread;
class ThreadAffinityVisitor;
}

class Pipe : public fabric::Pipe<Node, Pipe, eq::Window, PipeVisitor>
{
public:
    EQ_API explicit Pipe(Node* parent);

    EQ_API virtual ~Pipe();

    EQ_API co::CommandQueue* getPipeThreadQueue(); 
    co::CommandQueue* getMainThreadQueue();        
    co::CommandQueue* getCommandThreadQueue();     
    co::CommandQueue* getTransferThreadQueue();    

    EQ_API Config* getConfig();
    EQ_API const Config* getConfig() const;

    EQ_API ClientPtr getClient();

    EQ_API ServerPtr getServer();

    bool isRunning() const;

    EQ_API bool isStopped() const;

    EQ_API uint32_t getCurrentFrame() const;
    EQ_API uint32_t getFinishedFrame() const; 

    EQ_API WindowSystem getWindowSystem() const;

    Frame* getFrame(const co::ObjectVersion& frameVersion, const Eye eye,
                    const bool output);

    co::QueueSlave* getQueue(const uint128_t& queueID);

    void flushFrames(util::ObjectManager& om);

    const View* getView(const co::ObjectVersion& viewVersion) const;

    View* getView(const co::ObjectVersion& viewVersion);

    void waitExited() const; 
    void notifyMapped();     

    EQ_API void waitFrameFinished(const uint32_t frameNumber);

    EQ_API EventOCommand sendError(const uint32_t error);

    EQ_API void waitFrameLocal(const uint32_t frameNumber) const;

    EQ_API bool processEvent(Statistic& event);

    void startThread();

    void exitThread();

    void cancelThread(); 

    bool startTransferThread();

    QThread* getTransferQThread();

    bool hasTransferThread() const;

    EQ_API void setSystemPipe(SystemPipe* pipe);

    EQ_API SystemPipe* getSystemPipe();

    EQ_API const SystemPipe* getSystemPipe() const;

    EQ_API virtual MessagePump* createMessagePump();

    MessagePump* getMessagePump();

    EQ_API virtual void setDirty(const uint64_t bits);

protected:
    EQ_API bool isWindowSystemAvailable(const std::string& name) const;

    EQ_API void startFrame(const uint32_t frameNumber);

    EQ_API void releaseFrame(const uint32_t frameNumber);

    EQ_API void releaseFrameLocal(const uint32_t frameNumber);

    EQ_API virtual WindowSystem selectWindowSystem() const;

    EQ_API virtual bool configInit(const uint128_t& initID);

    EQ_API virtual bool configInitSystemPipe(const uint128_t& initID);

    EQ_API virtual bool configExit();

    EQ_API virtual void frameStart(const uint128_t& frameID,
                                   const uint32_t frameNumber);

    EQ_API virtual void frameFinish(const uint128_t& frameID,
                                    const uint32_t frameNumber);

    EQ_API virtual void frameDrawFinish(const uint128_t& frameID,
                                        const uint32_t frameNumber);

    EQ_API virtual void attach(const uint128_t& id, const uint32_t instanceID);

private:
    detail::Pipe* const _impl;
    friend class detail::RenderThread;

    //-------------------- Methods --------------------
    void _setupCommandQueue();
    void _setupAffinity();
    void _exitCommandQueue();

    EQ_API int32_t _getAutoAffinity() const;
    friend class detail::ThreadAffinityVisitor;

    // friend class Window;

    void _stopTransferThread();

    void _releaseViews();

    void _flushViews();

    void _flushQueues();

    /* The command functions. */
    bool _cmdCreateWindow(co::ICommand& command);
    bool _cmdDestroyWindow(co::ICommand& command);
    bool _cmdConfigInit(co::ICommand& command);
    bool _cmdConfigExit(co::ICommand& command);
    bool _cmdFrameStartClock(co::ICommand& command);
    bool _cmdFrameStart(co::ICommand& command);
    bool _cmdFrameFinish(co::ICommand& command);
    bool _cmdFrameDrawFinish(co::ICommand& command);
    bool _cmdExitThread(co::ICommand& command);
    bool _cmdDetachView(co::ICommand& command);
    bool _cmdExitTransferThread(co::ICommand& command);

    LB_TS_VAR(_pipeThread);
};
}

#endif // EQ_PIPE_H