include/eq/pipe.h

/* Copyright (c) 2005-2011, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2010, Cedric Stalder <cedric.stalder@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/eye.h>            // Eye enum
#include <eq/gl.h>             // WGLEWContext
#include <eq/types.h>
#include <eq/visitorResult.h>  // enum
#include <eq/windowSystem.h>   // enum

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

#include <co/objectVersion.h>

#include <co/base/lock.h>
#include <co/base/refPtr.h>
#include <co/base/thread.h>

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

        EQ_API virtual ~Pipe();

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

        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;

        uint32_t getCurrentFrame()  const { return _currentFrame; }
        EQ_API uint32_t getFinishedFrame() const; 

        WindowSystem getWindowSystem() const { return _windowSystem; }

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

        void flushFrames();

        bool isCurrent( const Window* window ) const;

        void setCurrent( const Window* window ) const;

        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 ) const;

        EQ_API void waitFrameLocal( const uint32_t frameNumber ) const;

        void startThread();

        void joinThread();

        void setSystemPipe( SystemPipe* pipe )  { _systemPipe = pipe; }

        SystemPipe* getSystemPipe() { return _systemPipe; }

        const SystemPipe* getSystemPipe() const { return _systemPipe; }

        void setComputeContext( ComputeContext* ctx ) { _computeContext = ctx; }

        const ComputeContext* getComputeContext() const
            { return _computeContext; }

        ComputeContext* getComputeContext() { return _computeContext; }

        EQ_API virtual MessagePump* createMessagePump();

        MessagePump* getMessagePump();

        EQ_API virtual void setDirty( const uint64_t bits );

    protected:
        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 bool supportsWindowSystem( const WindowSystem system )
                                   const;

        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 UUID& id, const uint32_t instanceID );

    private:
        //-------------------- Members --------------------
        SystemPipe* _systemPipe;

        WindowSystem _windowSystem;

        enum State
        {
            STATE_MAPPED,
            STATE_INITIALIZING,
            STATE_RUNNING,
            STATE_STOPPED, // must come after running
            STATE_FAILED
        };
       co::base::Monitor< State > _state;

        uint32_t _currentFrame;

       co::base::Monitor< uint32_t > _finishedFrame;

       co::base::Monitor<uint32_t> _unlockedFrame;

        std::deque< int64_t > _frameTimes;
        co::base::Lock _frameTimeMutex;

        int64_t _frameTime;

        int64_t _waitTime;

        typedef stde::hash_map< uint128_t, Frame* > FrameHash;
        typedef stde::hash_map< uint128_t, FrameData* > FrameDataHash;

        FrameHash _frames;

        FrameDataHash _outputFrameDatas;

        typedef stde::hash_map< uint128_t, View* > ViewHash;
        ViewHash _views;

        class PipeThread : public co::base::Thread
        {
        public:
            PipeThread( Pipe* pipe ) 
                    : _pipe( pipe )
                {}
            
            virtual void run(){ _pipe->_runThread(); }

        private:
            Pipe* _pipe;
        };
        PipeThread* _thread;

        eq::CommandQueue*   _pipeThreadQueue;

        const mutable Window* _currentWindow;

        ComputeContext *_computeContext;

        struct Private;
        Private* _private; // placeholder for binary-compatible changes

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

        friend class Window;

        void _releaseViews();

        void _flushViews();

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

        EQ_TS_VAR( _pipeThread );
    };
}

#endif // EQ_PIPE_H