include/eq/client/frameData.h

/* Copyright (c) 2006-2011, 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/types.h>

#include <eq/fabric/pixelViewport.h> // member
#include <eq/fabric/pixel.h>         // member
#include <eq/fabric/range.h>         // member
#include <eq/fabric/subPixel.h>      // member

#include <co/object.h>               // base class
#include <co/base/monitor.h>         // member
#include <co/base/spinLock.h>        // member

namespace eq
{

namespace server
{
    class FrameData;
}
    class  ROIFinder;
    struct NodeFrameDataTransmitPacket;
    struct NodeFrameDataReadyPacket;

    class FrameData : public co::Object
    {
    public:
        void assembleFrame( Frame* frame, Channel* channel );
        struct ImageHeader
        {
            uint32_t                internalFormat;
            uint32_t                externalFormat;
            uint32_t                pixelSize;
            fabric::PixelViewport   pvp;
            uint32_t                compressorName;
            uint32_t                compressorFlags;
            uint32_t                nChunks;
            float                   quality;
        };

        EQ_API FrameData();

        EQ_API 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 SubPixel& getSubPixel() const { return _data.subpixel; }

        uint32_t getPeriod() const { return _data.period; }

        uint32_t getPhase() const { return _data.phase; }

        const Images& getImages() const { return _images; }

        void setPixelViewport( const PixelViewport& pvp ) { _data.pvp = pvp; }
        
        void setAlphaUsage( const bool useAlpha ) { _useAlpha = useAlpha; }

        void setQuality( const Frame::Buffer buffer, const float quality );

        void setZoom( const Zoom& zoom ) { _data.zoom = zoom; }

        const Zoom& getZoom() const { return _data.zoom; }

        void useCompressor( const Frame::Buffer buffer, const uint32_t name );

        EQ_API Image* newImage( const Frame::Type type,
                                const DrawableConfig& config );

        void flush();

        EQ_API void clear();

        void readback( const Frame& frame, 
                       util::ObjectManager< const void* >* glObjects,
                       const DrawableConfig& config );

        void setReady();

        bool isReady() const   { return _readyVersion.get() >= _version; }

        void waitReady( const uint32_t timeout = EQ_TIMEOUT_INDEFINITE ) const;
        
        void setVersion( const uint64_t version );

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

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

        bool addImage( const NodeFrameDataTransmitPacket* packet );
        void setReady( const NodeFrameDataReadyPacket* packet ); 

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

    private:
        friend struct NodeFrameDataReadyPacket;
        struct Data
        {
            Data() : frameType( Frame::TYPE_MEMORY ), buffers( 0 ), period( 1 )
                   , phase( 0 ) {}

            EQ_API Data& operator=( const Data& rhs );

            PixelViewport pvp;
            Frame::Type   frameType;
            uint32_t      buffers;
            uint32_t      period;
            uint32_t      phase;
            Range         range;     //<! database-range of src wrt to dest
            Pixel         pixel;     //<! pixel decomposition of source
            SubPixel      subpixel;  //<! subpixel decomposition of source
            Zoom          zoom;

            EQ_API void serialize( co::DataOStream& os ) const;
            EQ_API void deserialize( co::DataIStream& is );
        } _data;

        friend class server::FrameData;

        Images _images;
        Images _imageCache;
        co::base::Lock _imageCacheLock;

        ROIFinder* _roiFinder;

        Images _pendingImages;

        uint64_t _version; 

        typedef co::base::Monitor< uint64_t > Monitor;

        Monitor _readyVersion;

        typedef co::base::Monitor< uint32_t > Listener;
        typedef std::vector< Listener* > Listeners;
        co::base::Lockable< Listeners, co::base::SpinLock > _listeners;

        bool _useAlpha;
        float _colorQuality;
        float _depthQuality;

        uint32_t _colorCompressor;
        uint32_t _depthCompressor;

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

        Image* _allocImage( const Frame::Type type,
                            const DrawableConfig& config,
                            const bool setQuality );

        void _applyVersion( const uint128_t& version );

        void _setReady( const uint64_t version );

        EQ_TS_VAR( _commandThread );
    };

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

#endif // EQ_FRAMEDATA_H