audio_signal_flow.hpp

Go to the documentation of this file.

/* Copyright Institute of Sound and Vibration Research - All rights reserved */

#ifndef VISR_LIBRRL_AUDIO_SIGNAL_FLOW_HPP_INCLUDED
#define VISR_LIBRRL_AUDIO_SIGNAL_FLOW_HPP_INCLUDED

#include "export_symbols.hpp"

#include <libvisr/audio_port_base.hpp>
#include <libvisr/communication_protocol_base.hpp>
#include <libvisr/constants.hpp>
#include <libvisr/signal_flow_context.hpp>

#include <iosfwd>
#include <map>
#include <memory>
#include <set>
#include <stdexcept>
#include <vector>

namespace visr
{
// Forward declarations
class AtomicComponent;
class ParameterPortBase;

namespace impl
{
class ComponentImplementation;
class CompositeComponentImplementation;
}

namespace rrl
{

// Forward declarations
class AudioSignalPool;
class AudioConnectionMap;
class ParameterConnectionMap;

class VISR_RRL_LIBRARY_SYMBOL AudioSignalFlow
{
public:
  using SignalIndexType = std::size_t; // TODO: Check whether to introduce a consistently used type alias for indices

  explicit AudioSignalFlow( Component & flow );

  ~AudioSignalFlow();

  bool process( SampleType const * const * captureSamples,
                SampleType * const * playbackSamples );

  void process( SampleType const * captureSamples,
                std::size_t captureChannelStride,
                std::size_t captureSampleStride,
                SampleType * playbackSamples,
                std::size_t playbackChannelStride,
                std::size_t playbackSampleStride );

  static void  processFunction( void* userData,
                                SampleType const * const * captureSamples,
                                SampleType * const * playbackSamples,
                                bool & status );


  std::size_t period() const;

  std::size_t numberOfAudioCapturePorts( ) const;

  std::size_t numberOfAudioPlaybackPorts( ) const;

  char const * audioCapturePortName( std::size_t idx ) const;

  char const * audioPlaybackPortName( std::size_t idx ) const;

  std::size_t numberOfCaptureChannels() const;
  
  std::size_t numberOfPlaybackChannels() const;


  using ProtocolReceiveEndpoints = std::map<std::string, std::unique_ptr<CommunicationProtocolBase::Output> >;
  using ProtocolSendEndpoints = std::map<std::string, std::unique_ptr<CommunicationProtocolBase::Input> >;

  std::size_t numberExternalParameterReceivePorts() const
  {
    return mProtocolReceiveEndpoints.size();
  }

  std::size_t numberExternalParameterSendPorts() const
  {
    return mProtocolSendEndpoints.size();
  }

  ProtocolReceiveEndpoints const & externalParameterReceiveEndpoints() const
  {
    return mProtocolReceiveEndpoints;
  }

  ProtocolSendEndpoints const & externalParameterSendEndpoints() const
  {
    return mProtocolSendEndpoints;
  }

  CommunicationProtocolBase::Output & externalParameterReceivePort( char const * portName );

  CommunicationProtocolBase::Input & externalParameterSendPort( char const * portName );


private:
  bool initialiseAudioConnections( std::ostream & messages, AudioConnectionMap const & originalConnections, AudioConnectionMap & finalConnections);

  bool initialiseParameterInfrastructure( std::ostream & messages, ParameterConnectionMap const & originalConnections, ParameterConnectionMap & finalConnections );

  bool initialiseSchedule( std::ostream & messages,
                           AudioConnectionMap const & audioConnections,
                           ParameterConnectionMap const & parameterConnections );
  std::size_t numberCommunicationProtocols() const;

  void executeComponents( );

  impl::ComponentImplementation & mFlow;


  using CommunicationProtocolContainer = std::vector<std::unique_ptr<CommunicationProtocolBase> >;

  CommunicationProtocolContainer mCommunicationProtocols;


  std::vector<impl::AudioPortBaseImplementation *> mToplevelInputs;

  std::vector<impl::AudioPortBaseImplementation *> mToplevelOutputs;

  std::unique_ptr<AudioSignalPool> mAudioSignalPool;

  std::vector < impl::AudioPortBaseImplementation*> mTopLevelAudioInputs;
  std::vector < impl::AudioPortBaseImplementation*> mTopLevelAudioOutputs;

  std::vector<char*> mCaptureChannels;
  std::vector<char*> mPlaybackChannels;

  ProtocolReceiveEndpoints mProtocolReceiveEndpoints;

  ProtocolSendEndpoints mProtocolSendEndpoints;


  using InternalComponentList = std::vector<std::unique_ptr<AtomicComponent> >;
    
  InternalComponentList mInfrastructureComponents;

  using ProcessingSchedule = std::vector<AtomicComponent * >;

  ProcessingSchedule mProcessingSchedule;
};

} // namespace rrl
} // namespace visr

#endif // #ifndef VISR_LIBRRL_AUDIO_SIGNAL_FLOW_HPP_INCLUDED