ngcbPIX.hpp

Go to the documentation of this file.

#ifndef ngcbPIX_H
#define ngcbPIX_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
/* 
 * System Headers 
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
 
/*
 * Local Headers 
 */
#include <ngc/core/ngcb.h>
#include <ngc/core/ngcbSocket.h>

struct ngcb_pcfg_t {
  int port;

  unsigned int size;
  
  unsigned int boards;

  unsigned int channels;

  unsigned int bytes;

  unsigned int links;

  ngcb_pcfg_t() {
    port = 0; size = 8; channels = 4; boards = 1; bytes = 2; links = 1;
  }

  int Option(const char *name, const char *value) {
    if (strcmp(name, "-fd") == 0)
      {
      return (1);
      }
    else if (strcmp(name, "-p") == 0)
      {
      ngcbStr2Int(value, &port);
      if (port < 0) port = 0;
      return (1);
      }
    else if (strcmp(name, "-s") == 0)
      {
      unsigned int n;
      ngcbStr2UInt(value, &n);
      if (n < 1) n = 1;
      size = n * 4;
      return (1);
      }
    else if (strcmp(name, "-b") == 0)
      {
      ngcbStr2UInt(value, &boards);
      if (boards < 1) boards  = 1;
      return (1);
      }
    else if (strcmp(name, "-c") == 0)
      {
      ngcbStr2UInt(value, &channels);
      if (channels < 1) channels = 1;
      return (1);
      }
    else if (strcmp(name, "-nl") == 0)
      {
      ngcbStr2UInt(value, &links);
      if (links < 1) links = 1;
      return (1);
      }
    else if (strcmp(name, "-bitpix") == 0)
      {
      unsigned int bitPix;
      ngcbStr2UInt(value, &bitPix);
      bytes = bitPix / 8;
      if (bytes < 1) bytes = 1;
      return (1);
      }
    else
      {
      return (0);
      }
  }

  void Usage(FILE *fd) {
    fprintf(fd, "standard options:\n");
    fprintf(fd, "  -p <port>      - service port\n");
    fprintf(fd, "                   (default: 0)\n");
    fprintf(fd, "  -s <words>     - ADC packet size (32-bit words)\n");
    fprintf(fd, "                   (default: 2)\n");
    fprintf(fd, "  -b <boards>    - number of ADC boards\n");
    fprintf(fd, "                   (default: 1)\n");
    fprintf(fd, "  -c <channels>  - channels per ADC board\n");
    fprintf(fd, "                   (default: 4)\n");
    fprintf(fd, "  -bitpix <bits> - bits per pixel\n");
    fprintf(fd, "                   (default: 16)\n");
  }
  
};

class ngcbPIX
{
public:
  ngcbPIX &operator=(const ngcbPIX &other) {
    if (this != &other)
      {
      pktCfg = other.pktCfg;
      Initialize_();
      }
    return (*this);
  }

  ngcbPIX(const ngcbPIX &other):pktCfg(other.pktCfg) {
    Initialize_();
  }

  explicit ngcbPIX(const ngcb_pcfg_t &cfg):pktCfg(cfg) {
    Initialize_();
  }

  virtual ~ngcbPIX() {
    ngcbLog("shutdown service\n");
 
    /*
     * Disconnect client
     */
    Disconnect_();
    
    /*
     * Shutdown service
     */
    if (srv_ >= 0) ngcbTcpClose(srv_);
    
    /*
     * Free buffers
     */
    if (packetBuffer_ != NULL) free(packetBuffer_);
    if (linkBuffer_ != NULL) free(linkBuffer_);
  }

  const char *ErrMsg() {return (erms_);}

  int Port() {return (port_);}

  int Initialized() {return (srv_ >= 0);}

  void RstCnt() {cvt_ = 0;}

  int Service() {
 
    /*
     * Main loop
     */
    ngcbLog("port = %d\n", port_);
    while (Initialized())
      {
      /*
       * Wait for client connection
       */
      if (Connect_() >= 0) 
    {
    /*
     * Packet loop
     */
    ngcbLog("connected\n");
    while (Connected_()) Packet_();
    ngcbLog("disconnected\n");
    }
      }
 
    return (0);
  }
 
protected:
  ngcb_pcfg_t pktCfg;

  virtual unsigned short Sample16(size_t channel, size_t cvt) {
    unsigned short pix;
    pix = (unsigned short)channel;
    return (pix);
  }
  
  virtual int Sample32(size_t channel, size_t cvt) {
    int pix;
    pix = (int)channel;
    return (pix);
  }
 
private:
  char erms_[256];

  int port_;

  int srv_;

  int out_;

  char *packetBuffer_;

  char *linkBuffer_;

  size_t size_;

  size_t cvt_;

  void Initialize_() {
    erms_[0] = '\0';
    port_ = 0;
    out_ = -1;
    srv_ = -1;
    linkBuffer_ = NULL;
    cvt_ = 0;
    size_ = pktCfg.size * pktCfg.boards;
    packetBuffer_ = (char *)malloc(size_);
    if (packetBuffer_ == NULL)
      {
      strcpy(erms_, "cannot allocate packet buffer");
      }
    else
      {
      linkBuffer_ = (char *)malloc(size_);
      if (linkBuffer_ == NULL)
    {
    strcpy(erms_, "cannot allocate link buffer");
    free(packetBuffer_); packetBuffer_ = NULL;
    }
      else
    {
    /*
     * Open service port
     */
    char s[32];
    sprintf(s, "%d", pktCfg.port);
    srv_ = ngcbTcpService(s, erms_);
    if (srv_ >= 0)
      {
      /*
       * Get actual port number
       */
      port_ = ngcbSocketPort(srv_);
      if (port_ <= 0)
        {
        strcpy(erms_, "invalid port");
        free(linkBuffer_); linkBuffer_ = NULL;
        free(packetBuffer_); packetBuffer_ = NULL;
        ngcbTcpClose(srv_); srv_ = -1;
        }
      }
    else
      {
      free(linkBuffer_); linkBuffer_ = NULL;
      free(packetBuffer_); packetBuffer_ = NULL;
      }
    }
      }
  }

  int Connected_() {return (out_ >= 0);}

  int Connect_() {
 
    RstCnt();
 
    if (srv_ < 0)
      {
      strcpy(erms_, "service not established");
      return (-1);
      }
    else if (ngcbSocketWait(srv_, -1, erms_) != 0)
      {
      return (-1);
      }
    else
      {
      out_ = ngcbTcpAccept(srv_, erms_);
      return (out_); 
      }
  }

  void Disconnect_() {
    if (out_ >= 0)
      {
      ngcbTcpClose(out_); out_ = -1;
      }
  }

  void Packet_() {
    size_t b;
    size_t nPix = pktCfg.size / pktCfg.bytes; // pixels per packet per board
    size_t c0 = 0;
    char *buffer;
    unsigned int links;
 
    if (pktCfg.links > 1)
      {
      buffer = linkBuffer_;
      links = pktCfg.links;
      }
    else
      {
      buffer = packetBuffer_;
      links = 1;
      }
    
    if (pktCfg.bytes == 2)
      {
      unsigned short *p = (unsigned short *)buffer;
      for (b=0;b<pktCfg.boards;b++)
    {
    size_t n, c;
    for (n=0;n<nPix/pktCfg.channels;n++)
      {
      for (c=0;c<pktCfg.channels;c++) *p++ = Sample16(c0 + c, cvt_ + n);
      }
    c0 += pktCfg.channels;
    }
      }
    else if (pktCfg.bytes == 4)
      {
      int *p = (int *)buffer;
      for (b=0;b<pktCfg.boards;b++)
    {
    size_t n, c;
    for (n=0;n<nPix/pktCfg.channels;n++)
      {
      for (c=0;c<pktCfg.channels;c++) *p++ = Sample32(c0 + c, cvt_ + n);
      }
    c0 += pktCfg.channels;
    }
      }
    else
      {
      memset(packetBuffer_, 0, size_); // just fill packet buffer with zero
      links = 1;
      }
    
    if (links > 1)
      {
      /*
       * Our data is in the link buffer - we still have to distribute it
       */
      size_t i, j;
      size_t chunk = size_ / links;
      size_t x = links * 8;
      
      for (i=0;i<links;i++)
    {
    char *b1 = linkBuffer_ + (i * chunk);
    char *b2 = packetBuffer_ + (i * 8);
    for (j=0;j<links;j++)
      {
      memcpy(b2, b1, 8);
      b1 += 8;
      b2 += x;
      }
    }
      }
    
    if (ngcbTcpWrite(out_, packetBuffer_, size_, erms_) != 0) Disconnect_();
  
    cvt_ += (nPix / pktCfg.channels);    
  }
  
};
 
#endif