lib/client/pipe.h

/* Copyright (c) 2005-2009, Stefan Eilemann <eile@equalizergraphics.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

#ifdef EQUALIZER_EXPORTS
   // We need to instantiate a Monitor< State > when compiling the library,
   // but we don't want to have <pthread.h> for a normal build, hence this hack
#  include <pthread.h>
#endif
#include <eq/base/monitor.h>

#include <eq/client/eye.h>            // Eye enum
#include <eq/client/pixelViewport.h>  // member
#include <eq/client/types.h>
#include <eq/client/visitorResult.h>  // enum
#include <eq/client/windowSystem.h>   // WGLEWContext

#include <eq/net/object.h>
#include <eq/net/objectVersion.h>

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

namespace eq
{
    class CommandQueue;
    class OSPipe;
    class PipeVisitor;

    class Pipe : public net::Object
    {
    public:
        EQ_EXPORT Pipe( Node* parent );

        EQ_EXPORT virtual ~Pipe();

        EQ_EXPORT net::CommandQueue* getPipeThreadQueue();
        Node*       getNode()       { return _node; }
        const Node* getNode() const { return _node; }

        EQ_EXPORT Config* getConfig();
        EQ_EXPORT const Config* getConfig() const;

        EQ_EXPORT ClientPtr getClient();
        EQ_EXPORT ServerPtr getServer();

        const WindowVector& getWindows() const { return _windows; }

        const std::string& getName() const { return _name; }

        uint32_t getTasks() const { return _tasks; }

        bool isThreaded() const { return ( _thread != 0 ); }
        uint32_t getCurrentFrame()  const { return _currentFrame; }
        EQ_EXPORT uint32_t getFinishedFrame() const;

        EQ_EXPORT VisitorResult accept( PipeVisitor& visitor );

         void setPixelViewport( const eq::PixelViewport& pvp ){ _pvp = pvp; }

        const PixelViewport& getPixelViewport() const { return _pvp; }

        uint32_t getPort() const { return _port; }

        uint32_t getDevice() const { return _device; }

        WindowSystem getWindowSystem() const { return _windowSystem; }

        EQ_EXPORT int64_t getFrameTime() const;

        EQ_EXPORT WGLEWContext* wglewGetContext();

        Frame* getFrame( const net::ObjectVersion& frameVersion, 
                         const Eye eye );

        void flushFrames();

        bool isCurrent( const Window* window ) const;

        void setCurrent( const Window* window ) const;

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

        EQ_EXPORT void waitExited() const;
        EQ_EXPORT bool isRunning() const;
        
        EQ_EXPORT void waitFrameFinished( const uint32_t frameNumber ) const;

        EQ_EXPORT void waitFrameLocal( const uint32_t frameNumber ) const;

        void startThread();

        void joinThread();

        void setOSPipe( OSPipe* pipe )  { _osPipe = pipe; }

        const OSPipe* getOSPipe() const { return _osPipe; }
              OSPipe* getOSPipe()       { return _osPipe; }


        void setErrorMessage( const std::string& message ) { _error = message; }

    protected:
        friend class Node;

        EQ_EXPORT void startFrame( const uint32_t frameNumber );

        EQ_EXPORT void releaseFrame( const uint32_t frameNumber );

        EQ_EXPORT void releaseFrameLocal( const uint32_t frameNumber );

        EQ_EXPORT virtual bool supportsWindowSystem( const WindowSystem system )
                                   const;

        EQ_EXPORT virtual WindowSystem selectWindowSystem() const;

        EQ_EXPORT virtual bool configInit( const uint32_t initID );

        EQ_EXPORT virtual bool configExit();

        EQ_EXPORT virtual void frameStart( const uint32_t frameID, 
                                           const uint32_t frameNumber );

        EQ_EXPORT virtual void frameFinish( const uint32_t frameID, 
                                            const uint32_t frameNumber );

        EQ_EXPORT virtual void frameDrawFinish( const uint32_t frameID, 
                                                const uint32_t frameNumber );

        virtual bool useMessagePump() { return true; }

        EQ_EXPORT virtual void attachToSession( const uint32_t id, 
                                                const uint32_t instanceID, 
                                                net::Session* session );

    private:
        //-------------------- Members --------------------
        std::string _error;

        OSPipe *_osPipe;

        Node* const    _node;

        std::string    _name;

        WindowVector   _windows;

        WindowSystem _windowSystem;

        PixelViewport _pvp;

        uint32_t _tasks;

        uint32_t _port;

        uint32_t _device;

        enum State
        {
            STATE_STOPPED,
            STATE_INITIALIZING,
            STATE_RUNNING
        };
        base::Monitor< State > _state;

        uint32_t _currentFrame;

        base::Monitor< uint32_t > _finishedFrame;

        base::Monitor<uint32_t> _unlockedFrame;

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

        int64_t _frameTime;

        int64_t _waitTime;

        typedef stde::hash_map< uint32_t, Frame* > FrameHash;
        FrameHash _frames;

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

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

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

        eq::CommandQueue*   _pipeThreadQueue;

        const mutable Window* _currentWindow;

        union // placeholder for binary-compatible changes
        {
            char dummy[64];
        };

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

        friend class Window;
        void _addWindow( Window* window );
        void _removeWindow( Window* window );
        Window* _findWindow( const uint32_t id );

        virtual void getInstanceData( net::DataOStream& os ) { EQDONTCALL }
        virtual void applyInstanceData( net::DataIStream& is ) { EQDONTCALL }

        void _releaseViews();

        void _flushViews();

        /* The command functions. */
        net::CommandResult _cmdCreateWindow( net::Command& command );
        net::CommandResult _cmdDestroyWindow( net::Command& command );
        net::CommandResult _cmdConfigInit( net::Command& command );
        net::CommandResult _cmdConfigExit( net::Command& command );
        net::CommandResult _cmdFrameStartClock( net::Command& command );
        net::CommandResult _cmdFrameStart( net::Command& command );
        net::CommandResult _cmdFrameFinish( net::Command& command );
        net::CommandResult _cmdFrameDrawFinish( net::Command& command );

        CHECK_THREAD_DECLARE( _pipeThread );
    };
}

#endif // EQ_PIPE_H