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 "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 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 );
#if 0

        void ConnectTypedControls(
                        Processing & sender, unsigned typedOutControlNumber,
                        Processing & receiver, unsigned typedInControlNumber );
        void ConnectTypedControls(
                        Processing & sender, const std::string & typedOutControlName,
                        Processing & receiver, const std::string & typedInControlName );

#endif

        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;

                // TODO: Temporary kludge to be able to access the connectors registry directly from connector classes
                friend class InPortBase;
                friend class OutPortBase;
                friend class InControlBase;
                friend class OutControlBase;
// 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();

                void ConsumeAndProduce();

                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(OutControlBase* out);
                void RegisterInControl(InControlBase* 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);
                }

                InPortBase & GetInPort( const std::string & name )
                {
                        return mInPortRegistry.Get(name);
                }
                OutPortBase & GetOutPort( const std::string & name )
                {
                        return mOutPortRegistry.Get(name);
                }
                InControlBase & GetInControl( const std::string & name )
                {
                        return mInControlRegistry.Get(name);
                }
                OutControlBase & GetOutControl( const std::string & name )
                {
                        return mOutControlRegistry.Get(name);
                }
                InPortBase & GetInPort( unsigned index )
                {
                        return mInPortRegistry.GetByNumber(index);
                }
                OutPortBase & GetOutPort( unsigned index )
                {
                        return mOutPortRegistry.GetByNumber(index);
                }
                InControlBase & GetInControl( unsigned index )
                {
                        return mInControlRegistry.GetByNumber(index);
                }
                OutControlBase & GetOutControl( unsigned index )
                {
                        return mOutControlRegistry.GetByNumber(index);
                }
                unsigned GetNInPorts() const
                {
                        return mInPortRegistry.Size();
                }
                unsigned GetNOutPorts() const
                {
                        return mOutPortRegistry.Size();
                }
                unsigned GetNInControls() const
                {
                        return mInControlRegistry.Size();
                }
                unsigned GetNOutControls() const
                {
                        return mOutControlRegistry.Size();
                }

        protected:
                InControlRegistry& GetInControls() { return mInControlRegistry; }

                OutControlRegistry& GetOutControls() { return mOutControlRegistry; }

                InPortRegistry& GetInPorts() { return mInPortRegistry; }

                OutPortRegistry& GetOutPorts() { return mOutPortRegistry; }
        public:
                const std::string& GetConfigErrorMessage() const { return _configErrorMessage; }

                virtual bool IsSyncSource() const { return false; }

                virtual bool SupportsVariableAudioSize() const {return ((GetNInPorts()+GetNOutPorts())==0)?true:false;}

// Helpers only for subclasses
        protected:
                bool 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;
                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),
                (std::string("Configuring a processing with a configuration of type ") + typeid(abstract).name() +
                " while it was expected a " + typeid(ConcreteConfig).name() + ".").c_str());
        concrete = static_cast<const ConcreteConfig &>(abstract);
}

};//namespace CLAM

#endif