Pipeline.hpp

Go to the documentation of this file.

/* ************************************************************************************************************* */
/*                                                                                                               */
/*     GLIP-LIB                                                                                                  */
/*     OpenGL Image Processing LIBrary                                                                           */
/*                                                                                                               */
/*     Author        : R. Kerviche                                                                               */
/*     LICENSE       : MIT License                                                                               */
/*     Website       : glip-lib.net                                                                              */
/*                                                                                                               */
/*     File          : Pipeline.hpp                                                                              */
/*     Original Date : August 15th 2011                                                                          */
/*                                                                                                               */
/*     Description   : Pipeline object                                                                           */
/*                                                                                                               */
/* ************************************************************************************************************* */

#ifndef __GLIPLIB_PIPELINE__
#define __GLIPLIB_PIPELINE__

        // Includes
        #include <ctime>
        #include <algorithm>
        #include <map>
        #include <limits>
        #include "Core/LibTools.hpp"
        #include "Core/Component.hpp"
        #include "Core/Filter.hpp"

        namespace Glip
        {
                namespace CoreGL
                {
                        // Prototypes
                        class HdlTexture;
                        class __HdlTextureFormat_OnlyData;
                        class HdlFBO;
                        class ShaderSource;
                        class HdlShader;
                        class HdlProgram;
                }

                namespace CorePipeline
                {
                        // Prototypes
                        class PipelineLayout;
                        class Pipeline;

                        // Constants
                        #define ELEMENT_NOT_ASSOCIATED (-2)

                        // Objects
                        class GLIP_API AbstractPipelineLayout : virtual public AbstractComponentLayout
                        {
                                public :
                                        enum ComponentKind
                                        {
                                                THIS_PIPELINE = -1,
                                                FILTER        =  0,
                                                PIPELINE      =  1
                                        };

                                        struct Connection // Connection goes from idOut::portOut to idIn::portIn
                                        {
                                                int idIn;
                                                int portIn;
                                                int idOut;
                                                int portOut;
                                        };

                                private :
                                        // Data
                                        typedef std::vector<AbstractComponentLayout*> ComponentList;
                                        std::vector<Connection>         connections;
                                        ComponentList                   elementsLayout;
                                        std::vector<ComponentKind>      elementsKind;
                                        std::vector<std::string>        elementsName;   
                                        std::vector<int>                elementsID;

                                        // Friends
                                        friend class PipelineLayout;

                                protected :
                                        // Tools
                                        AbstractPipelineLayout(const std::string& type);
                                        void                            setElementID(int i, int ID);
                                        std::vector<Connection>         getConnectionDestinations(int id, int p);
                                        Connection                      getConnectionSource(int id, int p);

                                        // Friends
                                        friend class Pipeline;

                                public :
                                        // Tools
                                        AbstractPipelineLayout(const AbstractPipelineLayout& c);
                                        virtual ~AbstractPipelineLayout(void);

                                        void                            checkElement(int i) const;
                                        int                             getNumElements(void) const;
                                        int                             getNumConnections(void) const;
                                        void                            getInfoElements(int& numFilters, int& numPipelines, int& numUniformVariables);
                                        int                             getElementIndex(const std::string& name) const;
                                        bool                            doesElementExist(const std::string& name) const;
                                        bool                            doesElementExist(const std::vector<std::string>& path) const;
                                        ComponentKind                   getElementKind(int i) const;
                                        const std::string&              getElementName(int i) const;    
                                        int                             getElementID(int i) const;
                                        int                             getElementID(const std::string& name) const;
                                        AbstractComponentLayout&        componentLayout(int i) const;
                                        AbstractComponentLayout&        componentLayout(const std::string& name) const;

                                        AbstractFilterLayout&           filterLayout(int i) const;
                                        AbstractFilterLayout&           filterLayout(const std::string& name) const;
                                        AbstractPipelineLayout&         pipelineLayout(int i) const;
                                        AbstractPipelineLayout&         pipelineLayout(const std::string& name) const;
                                        AbstractPipelineLayout&         pipelineLayout(const std::vector<std::string>& path); // Cannot be const as it can return itself.

                                        Connection                      getConnection(int i) const;
                                        bool                            check(bool exception = true);
                        };

                        typedef AbstractPipelineLayout::ComponentKind ComponentKind;

                        class GLIP_API PipelineLayout : virtual public ComponentLayout, virtual public AbstractPipelineLayout
                        {
                                public :
                                        // Tools
                                        PipelineLayout(const std::string& type);
                                        PipelineLayout(const AbstractPipelineLayout& c);
                                        int     add(const AbstractFilterLayout& filterLayout,     const std::string& name);
                                        int     add(const AbstractPipelineLayout& pipelineLayout, const std::string& name);
                                        int     addInput(const std::string& name);
                                        int     addOutput(const std::string& name);

                                        void    connect(int filterOut, int portOut, int filterIn, int portIn);
                                        void    connect(const std::string& filterOut, const std::string& portOut, const std::string& filterIn, const std::string& portIn);
                                        void    connectToInput(int port, int filterIn, int portIn);
                                        void    connectToInput(const std::string& port, const std::string& filterIn, const std::string& portIn);
                                        void    connectToOutput(int filterOut, int portOut, int port);
                                        void    connectToOutput(const std::string& filterOut, const std::string& portOut, const std::string& port);
                                        void    autoConnect(void);
                        };

                        class GLIP_API Pipeline : public AbstractPipelineLayout, public Component
                        {
                                public :
                                        enum ActionType
                                        {
                                                Process,
                                                Reset
                                        };

                                private :
                                        struct ActionHub
                                        {
                                                std::vector<int>                inputBufferIdx;         // The index of the buffer providing the argument k.
                                                std::vector<int>                inputArgumentIdx;       // The index of the output providing the argument k.
                                                int                             bufferIdx;              // The index of the buffer to use for output.
                                                int                             filterIdx;              // The index of the filter.
                                        };

                                        struct OutputHub
                                        {
                                                int                             bufferIdx;              // The index of the targeted buffer holding the input.
                                                int                             outputIdx;              // The index of the output for this buffer which has to be used.
                                        };

                                        struct BufferFormatsCell
                                        {
                                                std::vector<HdlTextureFormat>   formats;                // Format of the FBO.
                                                std::vector<int>                outputCounts;           // Number of output textures for the current FBO.

                                                int size(void) const;
                                                void append(const HdlAbstractTextureFormat& fmt, int count);
                                        };

                                        struct BuffersCell
                                        {
                                                std::vector<HdlFBO*>            buffersList;
                
                                                BuffersCell(const BufferFormatsCell& bufferFormats);
                                                ~BuffersCell(void);
                                        };

                                        // Data
                                        std::vector<HdlTexture*>                inputsList;
                                        BufferFormatsCell                       bufferFormats;
                                        std::map<int, BuffersCell*>             cells;
                                        BuffersCell*                            currentCell;            
                                        std::vector<Filter*>                    filtersList;                                    
                                        std::vector<ActionHub>                  actionsList;
                                        std::vector<OutputHub>                  outputsList;
                                        std::map<int, int>                      filtersGlobalIDsList;

                                        bool                                    firstRun,
                                                                                broken,
                                                                                perfsMonitoring;
                                        GLuint                                  queryObject;
                                        std::vector<double>                     perfs;
                                        double                                  totalPerf;

                                        // Tools
                                        Pipeline(const AbstractPipelineLayout& p, const std::string& name, bool fake);
                                        void cleanInput(void);
                                        void build(int& currentIdx, std::vector<Filter*>& filters, std::map<int, int>& filtersGlobalID, std::vector<Connection>& connections, AbstractPipelineLayout& originalLayout);
                                        void allocateBuffers(std::vector<Connection>& connections);

                                protected :
                                        // Tools
                                        void process(void);

                                public :
                                        // Tools
                                        Pipeline(const AbstractPipelineLayout& p, const std::string& name);
                                        ~Pipeline(void);

                                        int                     getNumActions(void) const;
                                        int                     getSize(bool askDriver = false);

                                        Pipeline&               operator<<(HdlTexture& texture);
                                        Pipeline&               operator<<(Pipeline& pipeline);
                                        Pipeline&               operator<<(ActionType a);
                                        HdlTexture&             out(int id = 0, int cellID=0);
                                        HdlTexture&             out(const std::string& portName, int cellID=0);
                                        Filter&                 operator[](int filterID);
                                        bool                    wentThroughFirstRun(void) const;
                                        bool                    isBroken(void) const;

                                        int                     createBuffersCell(void);
                                        int                     getNumBuffersCells(void) const;
                                        bool                    isBuffersCellValid(int cellID) const;
                                        int                     getCurrentCellID(void) const;
                                        std::vector<int>        getCellIDs(void) const;
                                        void                    changeTargetBuffersCell(int cellID);
                                        void                    removeBuffersCell(int cellID);

                                        void                    enablePerfsMonitoring(void);
                                        void                    disablePerfsMonitoring(void);
                                        double                  getTiming(int filterID);
                                        double                  getTiming(int action, std::string& filterName);
                                        double                  getTotalTiming(void);
                        };
                }
        }


#endif