include/eq/client/frameData.h

/* Copyright (c) 2006-2012, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2011, 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_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 <lunchbox/monitor.h>         // member
#include <lunchbox/spinLock.h>        // member

namespace eq
{
namespace server { class FrameData; }

    class ROIFinder;

    class FrameData : public co::Object, public lunchbox::Referenced
    {
    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();

        Frame::Type getType() const { return _data.frameType; }

        void setType( const Frame::Type type ){ _data.frameType = type; }

        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; }

        const PixelViewport& getPixelViewport() const { return _data.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 );

        EQ_API void clear();

        void flush();

        void deleteGLObjects( ObjectManager* om );

        EQ_API void resetPlugins();

#ifndef EQ_2_0_API

        void readback( const Frame& frame, ObjectManager* glObjects,
                       const DrawableConfig& config );
#endif

        Images startReadback( const Frame& frame, ObjectManager* glObjects,
                              const DrawableConfig& config,
                              const PixelViewports& regions );

        void setReady();

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

        void waitReady( const uint32_t timeout = LB_TIMEOUT_INDEFINITE ) const;

        void setVersion( const uint64_t version );

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

        void removeListener( lunchbox::Monitor<uint32_t>& listener );

        void disableBuffer( const Frame::Buffer buffer )
            { _data.buffers &= ~buffer; }

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

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

            PixelViewport pvp;
            fabric::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;

        bool addImage( const co::ObjectVersion& frameDataVersion,
                       const PixelViewport& pvp, const Zoom& zoom,
                       const uint32_t buffers, const bool useAlpha,
                       uint8_t* data );
        void setReady( const co::ObjectVersion& frameData,
                       const FrameData::Data& data ); 

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

    private:
        Images _images;
        Images _imageCache;
        lunchbox::Lock _imageCacheLock;

        ROIFinder* _roiFinder;

        Images _pendingImages;

        uint64_t _version; 

        typedef lunchbox::Monitor< uint64_t > Monitor;

        Monitor _readyVersion;

        typedef lunchbox::Monitor< uint32_t > Listener;
        typedef std::vector< Listener* > Listeners;
        lunchbox::Lockable< Listeners, lunchbox::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 );

        LB_TS_VAR( _commandThread );
    };

    EQ_API std::ostream& operator << ( std::ostream&, const FrameData& );
}

namespace lunchbox
{
template<> inline void byteswap( eq::FrameData::Data& value )
{
    byteswap( value.pvp );
    byteswap( value.frameType );
    byteswap( value.buffers );
    byteswap( value.period );
    byteswap( value.phase );
    byteswap( value.range );
    byteswap( value.pixel );
    byteswap( value.subpixel );
    byteswap( value.zoom );
}
}

#endif // EQ_FRAMEDATA_H