lib/client/frameData.h

/* Copyright (c) 2006-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_FRAMEDATA_H
#define EQ_FRAMEDATA_H

#include <eq/client/frame.h>         // enum Frame::Buffer
#include <eq/client/pixelViewport.h> // member
#include <eq/client/pixel.h>         // member
#include <eq/client/range.h>         // member
#include <eq/client/types.h>         // member

#include <eq/base/monitor.h>         // member
#include <eq/net/object.h>           // base class

#include <set>                       // member

namespace eq
{

namespace server
{
    class FrameData;
}

    class  Image;
    class  ROIFinder;
    struct FrameDataTransmitPacket;

    class FrameData : public net::Object
    {
    public:
        EQ_EXPORT FrameData();
        EQ_EXPORT virtual ~FrameData();

        uint32_t getBuffers() const { return _data.buffers; }
        void     setBuffers( const uint32_t buffers ){ _data.buffers = buffers;}

        const Range& getRange() const { return _data.range; }
        void setRange( const Range& range ) { _data.range = range; }
        
        const Pixel& getPixel() const { return _data.pixel; }
        
        const ImageVector& getImages() const { return _images; }

        void setPixelViewport( const PixelViewport& pvp ) { _data.pvp = pvp; }

        /* Set color buffer type to read */
        void setColorType( const GLuint colorType ) { _colorType = colorType; }
        
        void setAlphaUsage( const bool useAlpha ) { _useAlpha = useAlpha; }


        void flush();

        EQ_EXPORT Image* newImage( const Frame::Type type = Frame::TYPE_MEMORY);

        EQ_EXPORT void clear();

        void startReadback( const Frame& frame, 
                            Window::ObjectManager* glObjects );

        void syncReadback();

        void transmit( net::NodePtr toNode, const uint32_t frameNumber );

        void setReady();

        bool isReady() const   { return _readyVersion >= getVersion(); }

        void waitReady() const { _readyVersion.waitGE( getVersion( )); }

        void addListener( base::Monitor<uint32_t>& listener );

        void removeListener( base::Monitor<uint32_t>& listener );
        
        void disableBuffer( const Frame::Buffer buffer )
            { _data.buffers &= ~buffer; }
 
        void useSendToken( const bool use ) { _useSendToken = use; }

        void update( const uint32_t version );

    protected:
        virtual ChangeType getChangeType() const { return INSTANCE; }
        virtual void getInstanceData( net::DataOStream& os );
        virtual void applyInstanceData( net::DataIStream& is );

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

    private:
        struct Data
        {
            Data() : offset( Vector2i::ZERO ), buffers( 0 ), format( 0 )
                   , type( 0 ), frameType( Frame::TYPE_MEMORY ){}

            PixelViewport pvp;
            Vector2i      offset;
            uint32_t      buffers;
            uint32_t      format;
            uint32_t      type;
            Frame::Type   frameType;
            Range         range;     //<! database-range of src wrt to dest
            Pixel         pixel;     //<! pixel decomposition of source
        } _data;

        friend class eq::server::FrameData;

        ImageVector  _images;
        ImageVector  _imageCache;
        base::Lock   _imageCacheLock;

        GLuint     _colorType; 
        ROIFinder* _roiFinder;

        struct ImageVersion
        {
            ImageVersion( Image* _image, const uint32_t _version )
                    : image( _image ), version( _version ) {}

            Image*   image;
            uint32_t version;
        };
        std::list<ImageVersion> _pendingImages;
        std::set< uint32_t >    _readyVersions;

        base::Monitor<uint32_t> _readyVersion;

        std::vector< base::Monitor<uint32_t>* > _listeners;
        base::Lock                              _listenersMutex;

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

        Image* _allocImage( const eq::Frame::Type type );

        void _applyVersion( const uint32_t version );

        void _setReady( const uint32_t version );

        /* The command handlers. */
        net::CommandResult _cmdTransmit( net::Command& command );
        net::CommandResult _cmdReady( net::Command& command );
        net::CommandResult _cmdUpdate( net::Command& command );

        CHECK_THREAD_DECLARE( _commandThread );
    };
    std::ostream& operator << ( std::ostream& os, const FrameData* data );
}

#endif // EQ_FRAMEDATA_H