Processing.hxx

Go to the documentation of this file.

/*
 * Copyright (c) 2001-2005 MUSIC TECHNOLOGY GROUP (MTG)
 *                         UNIVERSITAT POMPEU FABRA
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */


#ifndef _Processing_hxx_
#define _Processing_hxx_


#include "ErrProcessingObj.hxx"
#include "InControlRegistry.hxx"
#include "OutControlRegistry.hxx"
#include "TypedInControlRegistry.hxx"
#include "TypedOutControlRegistry.hxx"
#include "InPortRegistry.hxx"
#include "OutPortRegistry.hxx"
#include "ProcessingConfig.hxx"
#include "NullProcessingConfig.hxx"

#include <list>
#include <typeinfo>
#include <string>

namespace CLAM
{

        class Processing;
        class InPortBase;
        class OutPortBase;
        class InControl;
        class OutControl;
        class ProcessingComposite;
        class Network;
        void ConnectPorts(
                        Processing & sender, const std::string & outPortName, 
                        Processing & receiver, const std::string & inPortName );
        void ConnectPorts(
                        Processing & sender, unsigned outPortNumber, 
                        Processing & receiver, unsigned inPortNumber );
        void ConnectControls(
                        Processing & sender, unsigned outControlNumber, 
                        Processing & receiver, unsigned inControlNumber );
        void ConnectControls(
                        Processing & sender, const std::string & outControlName, 
                        Processing & receiver, const std::string & inControlName );
        void ConnectTypedControls(
                        Processing & sender, unsigned typedOutControlNumber, 
                        Processing & receiver, unsigned typedInControlNumber );
        void ConnectTypedControls(
                        Processing & sender, const std::string & typedOutControlName, 
                        Processing & receiver, const std::string & typedInControlName );

        void ConnectPorts(
                        OutPortBase & sender, 
                        Processing & receiver, unsigned inPortNumber );
        void ConnectPorts(
                        Processing & sender, unsigned outPortNumber, 
                        InPortBase & receiver );
        void SendFloatToInControl(Processing & receiver, const std::string & inControlName, float value);
        void SendFloatToInControl(Processing & receiver, int inControlIndex, float value);
        void SendFloatToOutControl(Processing & sender, const std::string & inControlName, float value);
        void SendFloatToOutControl(Processing & sender, int inControlIndex, float value);
        float GetFloatFromInControl(Processing & proc, const std::string & inControlName);
        float GetFloatFromInControl(Processing & proc, int inControlIndex);

        class Processing {
        public:
                typedef enum {
                        Unconfigured=0,
                        Ready, 
                        Running
                } ExecState;

                typedef NullProcessingConfig Config;

// Basic usage interface:

        public:

                bool Configure(const ProcessingConfig& config);

                void Start(void);

                virtual bool Do(void)=0;

                void Stop(void);

                Processing();
                virtual ~Processing();

// Overridable interface:
        public:

                virtual const char * GetClassName() const = 0;
                
                virtual bool CanProcessInplace() { return true; }

        protected:
                virtual bool ConcreteConfigure(const ProcessingConfig&) { return true; }; 
                
                virtual bool ConcreteStart() {return true;};

                virtual bool ConcreteStop() {return true;};
                
                unsigned BackendBufferSize();
                unsigned BackendSampleRate();
// Public interface:    
        public:
                bool CanConsumeAndProduce();

                virtual const ProcessingConfig &GetConfig() const;

        private:
                ExecState GetExecState() const {return _execState;} 
        public:
                std::string GetExecStateString() const;
                bool IsConfigured() const { return _execState != Unconfigured; }
                bool IsRunning() const { return _execState == Running; }

                
                void RegisterOutPort(OutPortBase* out);
                void RegisterInPort(InPortBase* in);
                void RegisterOutControl(OutControl* out);
                void RegisterInControl(InControl* in);
                void RegisterTypedOutControl(BaseTypedOutControl* out);
                void RegisterTypedInControl(BaseTypedInControl* in);


                void SetParent(Processing *p);
                void SetNetworkBackLink(Network * network);
                virtual bool ModifiesPortsAndControlsAtConfiguration()  { return false; }
        
                bool HasInPort( const std::string & name )
                {
                        return mInPortRegistry.Has(name);
                }

                bool HasOutPort( const std::string & name )
                {
                        return mOutPortRegistry.Has(name);
                }

                bool HasInControl( const std::string & name )
                {
                        return mInControlRegistry.Has(name);
                }

                bool HasOutControl( const std::string & name )
                {
                        return mOutControlRegistry.Has(name);
                }

                bool HasTypedInControl( const std::string & name )
                {
                        return mTypedInControlRegistry.Has(name);
                }

                bool HasTypedOutControl( const std::string & name )
                {
                        return mTypedOutControlRegistry.Has(name);
                }

                InPortBase & GetInPort( const std::string & name )
                {
                        return mInPortRegistry.Get(name);
                }
                OutPortBase & GetOutPort( const std::string & name )
                {
                        return mOutPortRegistry.Get(name);
                }
                InControl & GetInControl( const std::string & name )
                {
                        return mInControlRegistry.Get(name);
                }               
                OutControl & GetOutControl( const std::string & name )
                {
                        return mOutControlRegistry.Get(name);
                }

                InControlRegistry& GetInControls() { return mInControlRegistry; }
                
                OutControlRegistry& GetOutControls() { return mOutControlRegistry; }
                
                TypedInControlRegistry& GetTypedInControls() { return mTypedInControlRegistry; }

                TypedOutControlRegistry& GetTypedOutControls() { return mTypedOutControlRegistry; }

                InPortRegistry& GetInPorts() { return mInPortRegistry; }
                
                OutPortRegistry& GetOutPorts() { return mOutPortRegistry; }

                const std::string& GetConfigErrorMessage() const { return _configErrorMessage; }

                virtual bool IsSyncSource() const { return false; }

// Helpers only for subclasses
        protected:
                
                void AddConfigErrorMessage( const std::string& msg );
        
                bool AbleToExecute(void) const;

                template <typename ConcreteConfig>
                void CopyAsConcreteConfig(ConcreteConfig & concrete, const ProcessingConfig & abstract) const;
        protected:
                void SetExecState(ExecState state)
                {
                        _execState = state;
                }
// Attributes:
                ProcessingComposite *mpParent;
                Network * _network;
        private:

                ExecState _execState;

                std::string _configErrorMessage;


        private:
                InControlRegistry mInControlRegistry;
                OutControlRegistry mOutControlRegistry;
                TypedInControlRegistry mTypedInControlRegistry;
                TypedOutControlRegistry mTypedOutControlRegistry;
                InPortRegistry mInPortRegistry;
                OutPortRegistry mOutPortRegistry;
        };

        

// -----------------------------------------------------------------------------------------------      
// Inline implementations

inline bool Processing::AbleToExecute(void) const
{
        CLAM_BEGIN_DEBUG_CHECK
                if (!IsRunning())
                {
                        std::string err(GetClassName());
                        err += ": Do(): Not in execution mode - did you call Start on this "
                                        "object, the composite it is in, or the ToplevelProcessing singleton?";
                                CLAM_DEBUG_ASSERT( false, err.c_str() );
                }
        CLAM_END_DEBUG_CHECK
        return IsRunning();
}

template <typename ConcreteConfig>
inline void Processing::CopyAsConcreteConfig(ConcreteConfig & concrete, const ProcessingConfig & abstract) const 
{
        CLAM_ASSERT(typeid(ConcreteConfig)==typeid(abstract), 
                "Configuring a Processing with a configuration not being the proper type.");
        concrete = static_cast<const ConcreteConfig &>(abstract);
}

};//namespace CLAM

#endif

---