ngcppAPP.hpp

Go to the documentation of this file.

#ifndef ngcppAPP_H
#define ngcppAPP_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
/* 
 * System Headers 
 */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
 
/*
 * Local Headers 
 */
#include <ngc/core/ngcpp.h>
#include <ngc/core/ngcbTHREAD.hpp>

struct ngcpp_thr_t {
  ngcbSEM *semSync;      //< Sync semaphpore
  ngcbSEM *semAck;       //< Acknowledge semaphore
  pthread_t thid;        //< Thread id
  int idx;               //< Process index

  ngcpp_thr_t() {
    // cppcheck-suppress useInitializationList
    thid = 0;
    idx = 0; 
    semSync = new ngcbSEM(0);
    semAck = new ngcbSEM(0);
  }

  ngcpp_thr_t(const ngcpp_thr_t &other) : thid(other.thid), idx(other.idx) {
    semSync = new ngcbSEM(0);
    semAck = new ngcbSEM(0);
  }

  ngcpp_thr_t &operator=(const ngcpp_thr_t &other) {
    if (this != &other)
      {
      thid = other.thid;
      idx = other.idx;
      if (semSync != NULL) delete semSync;
      semSync = new ngcbSEM(0);
      if (semAck != NULL) delete semAck;
      semAck = new ngcbSEM(0);
      }
    return (*this);
  }
  
  virtual ~ngcpp_thr_t() {
    if (semSync != NULL) delete semSync;
    if (semAck != NULL) delete semAck;
  }
};

struct ngcppFRAME_QUEUE {
  ngcppFRAME frame;
  
  ngcppFRAME_QUEUE() {
    // cppcheck-suppress memsetClassFloat
    memset(&frame, 0, sizeof(ngcppFRAME));   
    frame.fbuf = NULL;
  }

  ngcppFRAME_QUEUE(int ftype, int dtype, int nx, int ny, int nq, int scal = 1) {
    char **queue = static_cast<char **>(malloc(nq * sizeof(char **)));
 
    if (queue != NULL)
      {
      int i;
      size_t size = static_cast<size_t>(nx) * static_cast<size_t>(ny);
      switch (dtype)
    {
    case ngcppDTYPE_INT16:
    case ngcppDTYPE_UINT16:
      size *= 2; break;
    case ngcppDTYPE_INT32:
    case ngcppDTYPE_REAL32:
      size *= 4; break;
    case ngcppDTYPE_INT64:
    case ngcppDTYPE_REAL64:
      size *= 8; break;
    default:
      break;
    }
      for (i=0;i<nq;i++)
    {
    queue[i] = static_cast<char *>(ngcppMalloc(size));
    if (queue[i] == NULL)
      {
      int j;
      for (j=0;j<i;j++) free(queue[j]);
      free(queue);
      
      // cppcheck-suppress memsetClassFloat
      memset(&frame, 0, sizeof(ngcppFRAME));
      frame.fbuf = NULL;
      return;
      }
    }
 
      // Initialize frame structure
      frame.h.start_x = 0;
      frame.h.start_y = 0;
      frame.h.nx = nx;
      frame.h.ny = ny;
      frame.h.scal = scal;
      frame.h.dtype = dtype;
      frame.h.ftype = ftype;
      ngcppInitFrame(&frame, queue, nq);
      free(queue);
      }
    else
      {
      // cppcheck-suppress memsetClassFloat
      memset(&frame, 0, sizeof(ngcppFRAME));
      frame.fbuf = NULL;
      return;
      }
  }

  virtual ~ngcppFRAME_QUEUE() {}

  int Valid() {return (frame.fbuf != NULL);}

  char *Ptr() {return (frame.fbuf[frame.dptr]);}

  void Publish(int flag) {ngcppPublish(flag, &frame);}
 
};

class ngcppAPP
{
public:
  int nx;

  int ny;

  int numProc;

  int skipData;
  
  ngcbSEM *semData;
  
  bool mainLoopRunning;

  ngcppAPP();
 
  virtual ~ngcppAPP();

  virtual int Configure(char *erms);

  virtual int Connect(const char *name, char *erms);

  virtual int Disconnect(char *erms);
  
  virtual int Alloc(unsigned char **buffer, int n, size_t size, char *erms);
  
  virtual void Free(unsigned char **buffer, int n);

  virtual int Clear(char *erms);

  virtual int StartAcquisition(char *erms);

  virtual int StopAcquisition(char *erms);

  virtual void SkipData();
  
  virtual int NextData(unsigned char *buffer, size_t size, uint64_t *ts,
               char *erms);

  virtual int Process(int instance, void *buffer, char *erms);

  virtual void Publish();

  virtual void ResetCounters(int cnt);

  virtual int CheckParam(int *param, int running, int *idx);

  virtual void Command(const char *command, char *reply);

  virtual void AppStart();

  int RunApp(int argc, char **argv, char *erms);

  void TerminateProcesses();
  
  void AddLog(const char *msg);
  
  void Failure(const char *msg);
  
  void FailureOverrun(const char *msg);
  
protected:
private:
  void MainLoop_();

  ngcpp_thr_t *thr_[8];
};
 
#endif