streamingalgorithm.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2021  Music Technology Group - Universitat Pompeu Fabra
 *
 * This file is part of Essentia
 *
 * Essentia is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Affero General Public License as published by the Free
 * Software Foundation (FSF), either version 3 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 Affero GNU General Public License
 * version 3 along with this program.  If not, see http://www.gnu.org/licenses/
 */
 
#ifndef ESSENTIA_STREAMINGALGORITHM_H
#define ESSENTIA_STREAMINGALGORITHM_H
 
#include "../configurable.h"
#include "../threading.h"
#include "sourcebase.h"
#include "sinkbase.h"
 
namespace essentia {
namespace scheduler {
 
  class Network;
 
} // namespace scheduler
} // namespace essentia
 
namespace essentia {
namespace streaming {
 
 
class ProcessTask;
 
 
void connect(SourceBase& source, SinkBase& sink);
 
inline void operator>>(SourceBase& source, SinkBase& sink) {
  connect(source, sink);
}
 
inline void connect(SinkBase& sink, SourceBase& source) {
  connect(source, sink);
}
 
void disconnect(SourceBase& source, SinkBase& sink);
 
void connect(Algorithm* sourceAlgo, const std::string& sourcePort,
             Algorithm* sinkAlgo, const std::string& sinkPort);
 
 
 
enum AlgorithmStatus {
  OK = 0,
  CONTINUE = 0,
  PASS,
  FINISHED,
  NO_INPUT,
  NO_OUTPUT
};
 
class ESSENTIA_API Algorithm : public Configurable {
 
 public:
  static const std::string processingMode;
 
  typedef OrderedMap<SinkBase> InputMap;
  typedef OrderedMap<SourceBase> OutputMap;
 
  DescriptionMap inputDescription;
  DescriptionMap outputDescription;
 
 
 public:
 
  Algorithm() : _shouldStop(false)
#if DEBUGGING_ENABLED
      , nProcess(0)
#endif
      {}
 
  virtual ~Algorithm() {
    // Note: no need to do anything here wrt to sources and sinks, as they
    //       disconnect themselves when destroyed.
  }
 
 
  SinkBase& input(const std::string& name);
  SourceBase& output(const std::string& name);
 
  SinkBase& input(int idx);
  SourceBase& output(int idx);
 
  const InputMap& inputs() const { return _inputs; }
  const OutputMap& outputs() const { return _outputs; }
 
 
  std::vector<std::string> inputNames() const { return _inputs.keys(); }
 
  std::vector<std::string> outputNames() const { return _outputs.keys(); }
 
 
  virtual void shouldStop(bool stop);
 
  virtual bool shouldStop() const { return _shouldStop; }
 
 
 
  void disconnectAll();
 
  AlgorithmStatus acquireData();
  void releaseData();
 
  virtual AlgorithmStatus process() = 0;
 
  virtual void reset();
 
 protected:
  void declareInput(SinkBase& sink, const std::string& name, const std::string& desc);
 
  void declareInput(SinkBase& sink, int n, const std::string& name, const std::string& desc);
 
  void declareInput(SinkBase& sink, int acquireSize, int releaseSize, const std::string& name, const std::string& desc);
 
 
  void declareOutput(SourceBase& source, const std::string& name, const std::string& desc);
 
  void declareOutput(SourceBase& source, int n, const std::string& name, const std::string& desc);
 
  void declareOutput(SourceBase& source, int acquireSize, int releaseSize, const std::string& name, const std::string& desc);
 
 
 
  bool _shouldStop;
 
  OutputMap _outputs;
  InputMap _inputs;
 
#if DEBUGGING_ENABLED
  friend class essentia::scheduler::Network;
 
  int nProcess;
#endif
 
};
 
 
} // namespace streaming
} // namespace essentia
 
 
// these #include have to go here, and not on top, because they need to have
// Algorithm defined first. Indeed, Source implementation (templated, so
// implementation goes into header) depends on PhantomBuffer (templated), which
// in turn depends on Algorithm for the synchronization for acquiring
// access to the buffer resources
#include "source.h"
#include "sink.h"
 
// also include template algorithms which are not in the factory, but are still
// useful most of the time
#include "algorithms/devnull.h"
 
 
#endif // ESSENTIA_STREAMINGALGORITHM_H