BufferedNode.h

// Copyright (C) 1999 Jean-Marc Valin & Dominic Letourneau

#ifndef BUFFERED_NODE_H
#define BUFFERED_NODE_H

#include "Node.h"
#include "Buffer.h"

namespace FD {

class OutputCacheInfo {
public:
   OutputCacheInfo () 
      : lookAhead(0)
      , lookBack(0)
   {}

   RCPtr<Buffer> buffer;
   int lookAhead;
   int lookBack;
};

class InputCacheInfo {
public:
   InputCacheInfo () 
      : lookAhead(0)
      , lookBack(0)
   {}
   int lookAhead;
   int lookBack;
};

class BufferedNode : public Node {
protected:

   int processCount;

   std::vector<OutputCacheInfo> outputs;

   std::vector<InputCacheInfo> inputsCache;
   
   bool inOrder;
public:
   BufferedNode(std::string nodeName, const ParameterSet &params);
   
   virtual ~BufferedNode() {}

   virtual ObjectRef getOutput(int output_id, int count); 

   virtual void calculate(int output_id, int count, Buffer &buf) = 0;

   virtual void request(int outputID, const ParameterSet &req);

   //virtual void request(const ParameterSet &req) {throw "error: maudit request";}

   virtual void initialize();

   virtual void reset();

   virtual int addOutput (const std::string &outputName);

   virtual int addInput (const std::string &inputName);

   /***/
   virtual void initializeBuffers();

   /***/
   virtual void performRequests();

protected:
   BufferedNode() {throw new GeneralException("BufferedNode copy constructor should not be called",__FILE__,__LINE__);}
};

#ifdef ENABLE_SPEED_HACKS

#define NO_ORDER_NODE_SPEEDUP(nodeClass)                    \
ObjectRef getOutput(int output_id, int count)               \
{                                                           \
      Buffer &outBuffer = *(outputs[output_id].buffer);     \
      if (!outBuffer.isValid(count))                        \
         nodeClass::calculate (output_id, count, outBuffer);\
      return outBuffer.get(count);}

#define IN_ORDER_NODE_SPEEDUP(nodeClass)                    \
ObjectRef getOutput(int output_id, int count)               \
{                                                           \
      Buffer &outBuffer = *(outputs[output_id].buffer);     \
      for (int i=processCount+1;i<=count;i++)               \
         nodeClass::calculate(output_id, i, outBuffer);     \
      if (count > processCount)                             \
         processCount = count;                              \
      return outBuffer.get(count);                          \
}


#else


#define NO_ORDER_NODE_SPEEDUP(nodeClass)                    \
ObjectRef getOutput(int output_id, int count)               \
{                                                           \
   try {                                                    \
      Buffer &outBuffer = *(outputs[output_id].buffer);     \
      if (!outBuffer.isValid(count))                        \
         nodeClass::calculate (output_id, count, outBuffer);\
      return outBuffer.get(count);                          \
   } catch (BaseException *e)                               \
   {                                                        \
      throw e->add(new NodeException (this, "Exception caught in BufferedNode::getOutput", __FILE__, __LINE__));\
   }                                                        \
}

#define IN_ORDER_NODE_SPEEDUP(nodeClass)                    \
ObjectRef getOutput(int output_id, int count)               \
{                                                           \
   try {                                                    \
      Buffer &outBuffer = *(outputs[output_id].buffer);     \
      for (int i=processCount+1;i<=count;i++)               \
         nodeClass::calculate(output_id, i, outBuffer);     \
      if (count > processCount)                             \
         processCount = count;                              \
      return outBuffer.get(count);                          \
   } catch (BaseException *e)                               \
   {                                                        \
      throw e->add(new NodeException (this, "Exception caught in BufferedNode::getOutput", __FILE__, __LINE__));\
   }                                                        \
}


#endif

}//namespace FD

#endif

---