image.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_IMAGE_H
#define EQ_IMAGE_H

#include <eq/client/frame.h>         // for Frame::Buffer enum
#include <eq/client/pixelViewport.h> // member
#include <eq/client/texture.h>       // member
#include <eq/client/viewport.h>      // member
#include <eq/client/windowSystem.h>  // for OpenGL types

namespace eq
{
    class Compressor;

    class Image
    {
    public:
        EQ_EXPORT Image();
        EQ_EXPORT virtual ~Image();

        struct PixelData : public base::NonCopyable
        {
            PixelData();
            ~PixelData();
            void flush();

            uint32_t format;         
            uint32_t type;           
            
            base::Bufferb pixels;    
        
            uint32_t compressorName; 
            bool isCompressed;       

            std::vector< uint64_t > compressedSize;
            std::vector< void* >    compressedData;
        };


        EQ_EXPORT void setFormat( const Frame::Buffer buffer,
                                  const uint32_t format );

        EQ_EXPORT uint32_t getFormat( const Frame::Buffer buffer ) const;

        EQ_EXPORT void setType( const Frame::Buffer buffer, 
                                const uint32_t type );

        EQ_EXPORT uint32_t getType( const Frame::Buffer buffer ) const;

        EQ_EXPORT bool hasAlpha() const;

        void setStorageType( const Frame::Type type) { _type = type; }

        Frame::Type getStorageType() const{ return _type; }

        EQ_EXPORT bool hasData( const Frame::Buffer buffer ) const;

        //const eq::Viewport& getViewport() const { return _data.vp; }

        EQ_EXPORT void setPixelViewport( const PixelViewport& pvp );

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

        EQ_EXPORT void reset();


        EQ_EXPORT const uint8_t* getPixelPointer( const Frame::Buffer buffer )
                                     const;
        EQ_EXPORT uint8_t* getPixelPointer( const Frame::Buffer buffer );

        uint32_t getPixelDataSize( const Frame::Buffer buffer ) const
            { return _pvp.getArea() * getDepth( buffer ); }

        EQ_EXPORT const PixelData& getPixelData( const Frame::Buffer buffer )
                                       const;

        EQ_EXPORT const PixelData& compressPixelData( const Frame::Buffer 
                                                          buffer );

        bool hasPixelData( const Frame::Buffer buffer ) const
            { return _getAttachment( buffer ).memory.state == Memory::VALID; }

        EQ_EXPORT void clearPixelData( const Frame::Buffer buffer );

        EQ_EXPORT void validatePixelData( const Frame::Buffer buffer );

        EQ_EXPORT void setPixelData( const Frame::Buffer buffer, 
                                     const uint8_t* data );

        EQ_EXPORT void setPixelData( const Frame::Buffer buffer,
                                     const PixelData& data );

        void enablePBO() { _usePBO = true; }

        void disablePBO() { _usePBO = false; }

        bool usePBO() const { return _usePBO; }

        EQ_EXPORT void enableAlphaUsage();

        EQ_EXPORT void disableAlphaUsage();

        bool ignoreAlpha() const { return _ignoreAlpha; }


        EQ_EXPORT const Texture& getTexture( const Frame::Buffer buffer ) const;

        EQ_EXPORT bool hasTextureData( const Frame::Buffer buffer ) const;

        EQ_EXPORT uint32_t getInternalTextureFormat( const Frame::Buffer which )
                               const;


        EQ_EXPORT void startReadback( const uint32_t buffers, 
                                      const PixelViewport& pvp,
                                      const Zoom& zoom,
                                      Window::ObjectManager* glObjects );

        EQ_EXPORT void syncReadback();

        EQ_EXPORT void writeImage( const std::string& filename,
                                   const Frame::Buffer buffer ) const;

        EQ_EXPORT void writeImages( const std::string& filenameTemplate ) const;

        EQ_EXPORT bool readImage( const std::string& filename, 
                                  const Frame::Buffer buffer   );

        void setOffset( int32_t x, int32_t y ) { _pvp.x = x; _pvp.y = y; }

        EQ_EXPORT void flush();

        GLEWContext* glewGetContext() { return _glObjects->glewGetContext(); }

        EQ_EXPORT uint8_t getNumChannels( const Frame::Buffer buffer ) const;

        EQ_EXPORT uint8_t getChannelSize( const Frame::Buffer buffer ) const;

        EQ_EXPORT uint32_t getDepth( const Frame::Buffer buffer ) const;

        EQ_EXPORT std::vector< uint32_t > 
        findCompressors( const Frame::Buffer buffer ) const;

        EQ_EXPORT bool allocCompressor( const Frame::Buffer buffer, 
                                        const uint32_t name );

    private:
        struct Data
        {
            Viewport vp;
        } _data;

        PixelViewport _pvp;

        struct Memory : public PixelData
        {
        public:
            Memory() : state( INVALID ), pboSize(0) {}

            void resize( const uint32_t size );
            void flush();

            enum State
            {
                INVALID,
                PBO_READBACK,
                ZOOM_READBACK,
                VALID
            };

            State     state;   
            uint32_t  pboSize; 
        };

        uint32_t _getCompressorTokenType( const Frame::Buffer buffer ) const;

        uint32_t _getCompressorName( const Frame::Buffer buffer ) const;

        Window::ObjectManager* _glObjects;

        Frame::Type _type;

        class Attachment
        {
        public:  
            struct CompressorData
            {
                CompressorData();
                void flush();

                uint32_t name;      
                void* instance;     
                Compressor* plugin; 
                bool isCompressor;  
            }
                compressor;

            Texture texture;

            Memory memory;
        }; 
        
        Attachment _color;
        Attachment _depth;

        Attachment& _getAttachment( const Frame::Buffer buffer );
        const Attachment& _getAttachment( const Frame::Buffer buffer ) const;

        bool _allocDecompressor( Attachment& attachment, uint32_t name );

        bool _usePBO;

        bool _ignoreAlpha;

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

        const void* _getBufferKey( const Frame::Buffer buffer ) const;

        bool _canIgnoreAlpha( const Frame::Buffer buffer ) const;

        void _startReadback( const Frame::Buffer buffer, const Zoom& zoom );
        void _startReadbackPBO( const Frame::Buffer buffer );
        void _startReadbackZoom( const Frame::Buffer buffer, const Zoom& zoom );
                                
        void _syncReadback( const Frame::Buffer buffer );
        void _syncReadbackPBO( const Frame::Buffer buffer );
        void _syncReadbackZoom( const Frame::Buffer buffer );

        friend std::ostream& operator << ( std::ostream& os, const Image* );
    };

    std::ostream& operator << ( std::ostream& os, const Image* image );
};
#endif // EQ_IMAGE_H