agilentArb2sdds.c

#include <mdb.h>
#include <SDDS.h>
#include <scan.h>
#if defined(_WIN32)
#  include <io.h>
#  include <fcntl.h>
#endif
 
#define SET_ASCII 0
#define SET_BINARY 1
#define SET_PIPE 2
#define SET_WITHINDEX 3
#define SET_FLOAT 4
#define SET_DOUBLE 5
#define N_OPTIONS 6
 
char *option[N_OPTIONS] = {
  "ascii", "binary", "pipe", "withindex", "float", "double"};
 
char *USAGE = "agilentArb2sdds [<inputFile>] [<outputFile>] [-pipe[=in][,out]]\n\
[-ascii | -binary]\n\
[-withIndex]\n\
[-float | -double]\n\
[-dumpHeader]\n\n\
pipe            SDDS toolkit pipe option.\n\
ascii           Requests SDDS ASCII output.  Default is binary.\n\
binary          Requests SDDS BINARY output.\n\
withIndex       Add Index column.\n\
float           Output in float format. Default is double.\n\
double          Output in double format.\n\n\
Converts Agilent Arbitrary Waveform files to SDDS.\n\
Program by Robert Soliday. (" __DATE__ " " __TIME__ ", SVN revision: " SVN_VERSION ")\n";
 
#define MAX_NUM_POINTS 100001
int main(int argc, char *argv[]) {
  SCANNED_ARG *scanned;
  long iArg;
  int ascii = 0, withIndex = 0, floatValues = 0;
  unsigned long pipeFlags = 0;
  char *input = NULL, *output = NULL;
  FILE *fd;
  SDDS_DATASET SDDSout;
 
  long points;
  short waveform[2 * MAX_NUM_POINTS];
  char *pChar;
  char buf;
  int i;
  double *IwaveIn;
  double *QwaveIn;
  int32_t *index = NULL;
 
  SDDS_RegisterProgramName(argv[0]);
  argc = scanargs(&scanned, argc, argv);
  if (argc < 2) {
    fprintf(stderr, "%s", USAGE);
    return (1);
  }
  for (iArg = 1; iArg < argc; iArg++) {
    if (scanned[iArg].arg_type == OPTION) {
      switch (match_string(scanned[iArg].list[0], option, N_OPTIONS, 0)) {
      case SET_ASCII:
        ascii = 1;
        break;
      case SET_BINARY:
        ascii = 0;
        break;
      case SET_WITHINDEX:
        withIndex = 1;
        break;
      case SET_FLOAT:
        floatValues = 1;
        break;
      case SET_DOUBLE:
        floatValues = 0;
        break;
      case SET_PIPE:
        if (!processPipeOption(scanned[iArg].list + 1, scanned[iArg].n_items - 1, &pipeFlags)) {
          fprintf(stderr, "invalid -pipe syntax\n");
          return (1);
        }
        break;
      default:
        fprintf(stderr, "invalid option seen\n");
        fprintf(stderr, "%s", USAGE);
        return (1);
      }
    } else {
      if (!input)
        input = scanned[iArg].list[0];
      else if (!output)
        output = scanned[iArg].list[0];
      else {
        fprintf(stderr, "too many filenames\n");
        fprintf(stderr, "%s", USAGE);
        return (1);
      }
    }
  }
  processFilenames("agilentArb2sdds", &input, &output, pipeFlags, 0, NULL);
 
  if (input) {
    if (!fexists(input)) {
      fprintf(stderr, "input file not found\n");
      return (1);
    }
    if (!(fd = fopen(input, "rb"))) {
      fprintf(stderr, "problem opening input file\n");
      return (1);
    }
  } else {
#if defined(_WIN32)
    if (_setmode(_fileno(stdin), _O_BINARY) == -1) {
      fprintf(stderr, "error: unable to set stdin to binary mode\n");
      return (1);
    }
#endif
    fd = stdin;
  }
 
  points = fread((void *)waveform, sizeof(short), MAX_NUM_POINTS * 2, fd);
  if (points == MAX_NUM_POINTS * 2) {
    fprintf(stderr, "error: number of points in the waveform exceeds the MAX_NUM_POINTS hardcoded in the program.\n");
    return (1);
  }
  fclose(fd);
 
  if (!SDDS_IsBigEndianMachine()) {
    pChar = (char *)&waveform[0];
    for (i = 0; i < points; i++) {
      buf = *pChar;
      *pChar = *(pChar + 1);
      *(pChar + 1) = buf;
      pChar += 2;
    }
  }
 
  points = points / 2;
  IwaveIn = malloc(sizeof(double) * points);
  QwaveIn = malloc(sizeof(double) * points);
  for (i = 0; i < points; i++) {
    IwaveIn[i] = waveform[2 * i] / 32767.0;
    QwaveIn[i] = waveform[2 * i + 1] / 32767.0;
  }
  if (withIndex) {
    index = malloc(sizeof(int32_t) * points);
    for (i = 0; i < points; i++) {
      index[i] = i;
    }
  }
  if (!SDDS_InitializeOutput(&SDDSout, ascii ? SDDS_ASCII : SDDS_BINARY, 1, NULL, NULL, output)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return (1);
  }
  if (withIndex) {
    if (!SDDS_DefineSimpleColumn(&SDDSout, "Index", NULL, SDDS_LONG)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return (1);
    }
  }
  if (!SDDS_DefineSimpleColumn(&SDDSout, "I", NULL, floatValues ? SDDS_FLOAT : SDDS_DOUBLE)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return (1);
  }
  if (!SDDS_DefineSimpleColumn(&SDDSout, "Q", NULL, floatValues ? SDDS_FLOAT : SDDS_DOUBLE)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return (1);
  }
  if (!SDDS_WriteLayout(&SDDSout)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return (1);
  }
  if (!SDDS_StartTable(&SDDSout, points)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return (1);
  }
  if (withIndex) {
    if (!SDDS_SetColumnFromLongs(&SDDSout, SDDS_SET_BY_NAME, index, points, "Index")) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return (1);
    }
  }
  if (!SDDS_SetColumnFromDoubles(&SDDSout, SDDS_SET_BY_NAME, IwaveIn, points, "I")) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return (1);
  }
  if (!SDDS_SetColumnFromDoubles(&SDDSout, SDDS_SET_BY_NAME, QwaveIn, points, "Q")) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return (1);
  }
  if (!SDDS_WriteTable(&SDDSout)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return (1);
  }
 
  if (!SDDS_Terminate(&SDDSout)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return (1);
  }
 
  if (withIndex)
    free(index);
  free(IwaveIn);
  free(QwaveIn);
 
  free_scanargs(&scanned, argc);
 
  return 0;
}