From: root <root>
Date: Wed, 16 Mar 2005 20:49:59 +0000 (+0000)
Subject: Initial revision
X-Git-Url: https://git.rkrishnan.org/pf/content/en/footer/reliability?a=commitdiff_plain;h=0156693d5da49b097b0083c264d616cdb97b5c74;p=dttsp.git

Initial revision
---

0156693d5da49b097b0083c264d616cdb97b5c74
diff --git a/jDttSP/DttSPrc b/jDttSP/DttSPrc
new file mode 100644
index 0000000..84a0397
--- /dev/null
+++ b/jDttSP/DttSPrc
@@ -0,0 +1,2 @@
+setMode CWL
+setFilter -1000 -500
diff --git a/jDttSP/Makefile b/jDttSP/Makefile
new file mode 100644
index 0000000..4c39051
--- /dev/null
+++ b/jDttSP/Makefile
@@ -0,0 +1,62 @@
+CFLAGS = -g -O3 -I. -I/usr/local/include
+#CFLAGS = -g -I. -I/usr/local/include
+LIBS = -L/usr/local/lib -ljack -lpthread -lfftw -lm
+#LIBS = -lefence -L/usr/local/lib -ljack -lpthread -lfftw -lm
+
+staticlibname=libDttSP.a
+
+OBJ =	am_demod.o\
+	banal.o\
+	bufvec.o\
+	chan.o\
+	chap.o\
+	correctIQ.o\
+	crc16.o\
+	cxops.o\
+	digitalagc.o\
+	fastrig.o\
+	filter.o\
+	fm_demod.o\
+	lmadf.o\
+	noiseblanker.o\
+	oscillator.o\
+	ovsv.o\
+	ringb.o\
+	sdr.o\
+	sdrexport.o\
+	speechproc.o\
+	splitfields.o\
+	spottone.o\
+	thunk.o\
+	window.o\
+	update.o
+
+jsdr:	main.o $(OBJ)
+	$(CC) -o jsdr main.o $(OBJ) $(LIBS)
+
+$(OBJ): sdrexport.h
+
+metermon:	metermon.o chan.o ringb.o bufvec.o cxops.o banal.o
+	$(CC) -o metermon metermon.o chan.o ringb.o bufvec.o cxops.o banal.o $(LIBS)
+
+mkchan:	mkchan.o bufvec.o banal.o cxops.o
+	$(CC) -o mkchan mkchan.o bufvec.o banal.o cxops.o $(LIBS)
+
+ipc:
+	./setup-ipc
+
+obj:	$(OBJ)
+
+clean:
+	/bin/rm *.o jsdr mkchan metermon $(staticlibname)
+
+staticlib:	$(OBJ)
+	ar rcs $(staticlibname) $(OBJ)
+	ranlib $(staticlibname)
+
+#CFLAGS = -fPIC -g -O3 -I. -I/usr/local/include
+# sharedlibname=libDttSP.so
+# sharedlibvers=0.0.1
+# sharedlib=$(sharedlibname).$(sharedlibvers)
+# sharedlib:	$(OBJ)
+# 	gcc -shared -Wl,-soname,$(sharedlib) -o $(sharedlib) $(OBJ) -lc
diff --git a/jDttSP/am_demod.c b/jDttSP/am_demod.c
new file mode 100644
index 0000000..61750ca
--- /dev/null
+++ b/jDttSP/am_demod.c
@@ -0,0 +1,134 @@
+/* am_demod.c */
+
+#include <am_demod.h>
+#include <cxops.h>
+
+/*------------------------------------------------------------------------------*/
+/* private to AM */
+/*------------------------------------------------------------------------------*/
+
+static void
+init_pll(AMD am,
+	 REAL samprate,
+	 REAL freq,
+	 REAL lofreq, 
+	 REAL hifreq,
+	 REAL bandwidth) {
+  REAL fac = TWOPI / samprate;
+  am->pll.freq.f = freq * fac;
+  am->pll.freq.l = lofreq * fac;
+  am->pll.freq.h = hifreq * fac;
+  am->pll.phs = 0.0;
+  am->pll.delay = cxJ;
+
+  am->pll.iir.alpha = bandwidth * fac; /* arm filter */
+  am->pll.alpha = am->pll.iir.alpha * 0.3;   /* pll bandwidth */
+  am->pll.beta = am->pll.alpha * am->pll.alpha * 0.25; /* second order term */
+  am->pll.fast_alpha = am->pll.alpha;
+}
+
+static void
+pll(AMD am, COMPLEX sig) {
+  COMPLEX z = Cmplx(cos(am->pll.phs), sin(am->pll.phs));
+  REAL diff;
+
+  am->pll.delay.re =  z.re * sig.re + z.im * sig.im;
+  am->pll.delay.im = -z.im * sig.re + z.re * sig.im;
+  diff = Cmag(sig) * ATAN2(am->pll.delay.im, am->pll.delay.re);
+
+  am->pll.freq.f += am->pll.beta * diff;
+
+  if (am->pll.freq.f < am->pll.freq.l)
+    am->pll.freq.f = am->pll.freq.l;
+  if (am->pll.freq.f > am->pll.freq.h)
+    am->pll.freq.f = am->pll.freq.h;
+
+  am->pll.phs += am->pll.freq.f + am->pll.alpha * diff;
+
+  while (am->pll.phs >= TWOPI) am->pll.phs -= TWOPI;
+  while (am->pll.phs < 0) am->pll.phs += TWOPI;
+}
+
+static double
+dem(AMD am) {
+  am->lock.curr = 0.999 * am->lock.curr + 0.001 * fabs(am->pll.delay.im);
+  
+  /* env collapse? */
+ /* if ((am->lock.curr < 0.05) && (am->lock.prev >= 0.05)) {
+    am->pll.alpha = 0.1 * am->pll.fast_alpha;
+    am->pll.beta = am->pll.alpha * am->pll.alpha * 0.25;
+  } else if ((am->pll.alpha > 0.05) && (am->lock.prev <= 0.05)) {
+	  am->pll.alpha = am->pll.fast_alpha;
+  }*/
+  am->lock.prev = am->lock.curr;
+  am->dc = 0.99*am->dc + 0.01*am->pll.delay.re;
+  return am->pll.delay.re-am->dc;
+}
+
+/*------------------------------------------------------------------------------*/
+/* public */
+/*------------------------------------------------------------------------------*/
+
+void
+AMDemod(AMD am) {
+  int i;
+  double demout;
+  switch (am->mode) {
+  case SAMdet:
+    for (i = 0; i < am->size; i++) {
+      pll(am, CXBdata(am->ibuf, i));
+      demout = dem(am);
+      CXBdata(am->obuf, i) = Cmplx(demout, demout);
+    }
+    break;
+  case AMdet:
+    for (i = 0; i < am->size; i++) {
+      am->lock.curr = Cmag(CXBdata(am->ibuf, i));
+      am->dc = 0.9999 * am->dc + 0.0001 * am->lock.curr;
+      am->smooth = 0.5 * am->smooth + 0.5 * (am->lock.curr - am->dc);
+      /* demout = am->smooth; */
+      CXBdata(am->obuf, i) = Cmplx(am->smooth, am->smooth);
+    }
+    break;
+  }
+}
+
+AMD
+newAMD(REAL samprate,
+       REAL f_initial,
+       REAL f_lobound,
+       REAL f_hibound,
+       REAL f_bandwid,
+       int size,
+       COMPLEX *ivec,
+       COMPLEX *ovec,
+       AMMode mode,
+       char *tag) {
+  AMD am = (AMD) safealloc(1, sizeof(AMDDesc), tag);
+
+  am->size = size;
+  am->ibuf = newCXB(size, ivec, tag);
+  am->obuf = newCXB(size, ovec, tag);
+  am->mode = mode;
+  init_pll(am,
+	   samprate,
+	   f_initial,
+	   f_lobound,
+	   f_hibound,
+	   f_bandwid);
+
+  am->lock.curr = 0.5;
+  am->lock.prev = 1.0;
+  am->dc = 0.0;
+  
+  return am;
+}
+
+void
+delAMD(AMD am) {
+  if (am) {
+    delCXB(am->ibuf);
+    delCXB(am->obuf);
+    safefree((char *) am);
+  }
+}
diff --git a/jDttSP/am_demod.h b/jDttSP/am_demod.h
new file mode 100644
index 0000000..8b63460
--- /dev/null
+++ b/jDttSP/am_demod.h
@@ -0,0 +1,58 @@
+/* am_demod.h */
+
+#ifndef _am_demod_h
+#define _am_demod_h
+
+#include <fromsys.h>
+#include <banal.h>
+#include <splitfields.h>
+#include <datatypes.h>
+#include <bufvec.h>
+#include <cxops.h>
+#include <fastrig.h>
+#include <update.h>
+#include <lmadf.h>
+#include <fftw.h>
+#include <ovsv.h>
+#include <filter.h>
+#include <oscillator.h>
+#include <chap.h>
+typedef enum _ammode {AMdet, SAMdet} AMMode;
+typedef
+struct _am_demod {
+  int size;
+  CXB ibuf, obuf;
+
+  struct {
+    REAL alpha, beta,fast_alpha;
+    struct { REAL f, l, h; } freq;
+    REAL phs;
+    struct { REAL alpha; } iir;
+    COMPLEX delay;
+  } pll;
+
+  struct { REAL curr, prev; } lock;
+
+  REAL dc;
+  REAL smooth;
+  AMMode mode;
+} AMDDesc, *AMD;
+
+extern void AMDemod(AMD am);
+extern AMD newAMD(REAL samprate,
+		  REAL f_initial,
+		  REAL f_lobound,
+		  REAL f_hibound,
+		  REAL f_bandwid,
+		  int size,
+		  COMPLEX *ivec,
+		  COMPLEX *ovec,
+		  AMMode mode,
+		  char *tag);
+extern void delAMD(AMD am);
+
+#ifndef TWOPI
+#define TWOPI (2.0*M_PI)
+#endif
+
+#endif
diff --git a/jDttSP/banal.c b/jDttSP/banal.c
new file mode 100644
index 0000000..a5e8447
--- /dev/null
+++ b/jDttSP/banal.c
@@ -0,0 +1,197 @@
+/* banal.c
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <fromsys.h>
+#include <banal.h>
+
+void
+nilfunc(void) {}
+
+double
+sqr(double x) { return x * x; }
+
+int
+popcnt(int k) {
+  int c, i;
+  c = k & 01;
+  for (i = 1; i < 32; i++) c += (k >> i) & 01;
+  return c;
+}
+
+int
+npoof2(int n) {
+  int i = 0;
+  --n;
+  while (n > 0) n >>= 1, i++;
+  return i;
+}
+
+int
+nblock2(int n) { return 1 << npoof2(n); }
+
+int
+in_blocks(int count, int block_size) {
+  if (block_size < 1) {
+    fprintf(stderr, "block_size zero in in_blocks\n");
+    exit(1);
+  }
+  return (1 + ((count - 1) / block_size));
+}
+
+FILE *
+efopen(char *path, char *mode) {
+  FILE *iop = fopen(path, mode);
+  if (!iop) {
+    fprintf(stderr, "can't open \"%s\" in mode \"%s\"\n", path, mode);
+    exit(1);
+  }
+  return iop;
+}
+
+FILE *
+efreopen(char *path, char *mode, FILE *strm) {
+  FILE *iop = freopen(path, mode, strm);
+  if (!iop) {
+    fprintf(stderr, "can't reopen \"%s\" in mode \"%s\"\n", path, mode);
+    exit(1);
+  }
+  return iop;
+}
+
+size_t
+filesize(char *path) {
+  struct stat sbuf;
+  if (stat(path, &sbuf) == -1) return -1;
+  return sbuf.st_size;
+}
+
+size_t
+fdsize(int fd) {
+  struct stat sbuf;
+  if (fstat(fd, &sbuf) == -1) return -1;
+  return sbuf.st_size;
+}
+
+#define MILLION (1000000)
+
+// return current tv
+struct timeval
+now_tv(void) {
+  struct timeval tv;
+  gettimeofday(&tv, 0);
+  return tv;
+}
+
+// return ta - tb
+struct timeval
+diff_tv(struct timeval *ta, struct timeval *tb) {
+  struct timeval tv;
+  if (tb->tv_usec > ta->tv_usec) {
+    ta->tv_sec--;
+    ta->tv_usec += MILLION;
+  }
+  tv.tv_sec = ta->tv_sec - tb->tv_sec;
+  if ((tv.tv_usec = ta->tv_usec - tb->tv_usec) >= MILLION) {
+    tv.tv_usec -= MILLION;
+    tv.tv_sec++;
+  }
+  return tv;
+}
+
+// return ta + tb
+struct timeval
+sum_tv(struct timeval *ta, struct timeval *tb) {
+  struct timeval tv; 
+  tv.tv_sec = ta->tv_sec + tb->tv_sec;
+  if ((tv.tv_usec = ta->tv_usec + tb->tv_usec) >= MILLION) {
+    tv.tv_usec -= MILLION;
+    tv.tv_sec++;
+  }
+  return tv;
+}
+
+char *
+fmt_tv(struct timeval *tv) {
+  static char buff[256];
+  snprintf(buff, sizeof(buff), "%ds%du", tv->tv_sec, tv->tv_usec);
+  return buff;
+}
+
+char *
+since(struct timeval *tv) {
+  struct timeval nt = now_tv(),
+                 dt = diff_tv(&nt, tv);
+  return fmt_tv(&dt);
+}
+
+// linear integer interpolation:
+// real vector v, n long, -> real vector u, m long
+// *** n must divide m
+// returns actual number of valid points in u
+// (== n - m/n since v[n] is undefined)
+
+int
+hinterp_vec(REAL *u, int m, REAL *v, int n) {
+  if (!u || !v || (n < 2) || (m < n) || (m % n)) return 0;
+  else {
+    int div = m / n, i, j = 0;
+    for (i = 1; i < n; i++) {
+      int k;
+      REAL vl = v[i - 1], del = (v[i] - vl) / div;
+      u[j++] = vl;
+      for (k = 1; k < div; k++) u[j++] = vl + k * del;
+    }
+    u[j++] = v[n - 1];
+    return j;
+  }
+}
+
+void
+status_message(char *msg) { write(2, msg, strlen(msg)); }
+
+FILE *
+find_rcfile(char *base) {
+  char path[MAXPATHLEN];
+  FILE *fp;
+  sprintf(path, "./%s", base);
+  if ((fp = fopen(path, "r"))) return fp;
+  else {
+    char *home = getenv("HOME");
+    if (!home)
+      fprintf(stderr, "can't get HOME!\n"), exit(1);
+    sprintf(path, "%s/%s", home, base);
+    if ((fp = fopen(path, "r"))) return fp;
+  }
+  return 0;
+}
+
diff --git a/jDttSP/banal.h b/jDttSP/banal.h
new file mode 100644
index 0000000..1ca3ffe
--- /dev/null
+++ b/jDttSP/banal.h
@@ -0,0 +1,82 @@
+/* banal.h
+   stuff we're too embarrassed to declare otherwise
+   
+   This file is part of a program that implements a Software-Defined Radio.
+   
+   Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 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 GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+   
+   The authors can be reached by email at
+   
+   ab2kt@arrl.net
+   or
+   rwmcgwier@comcast.net
+   
+   or by paper mail at
+   
+   The DTTS Microwave Society
+   6 Kathleen Place
+   Bridgewater, NJ 08807
+*/
+
+#ifndef _banal_h
+
+#define _banal_h
+
+#include <fromsys.h>
+#include <datatypes.h>
+
+#ifndef min
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#endif
+#ifndef max
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#endif
+#define abs(a) ((a) >= 0 ? (a) : -(a))
+
+#define MONDO 1e15
+#define BITSY 1e-15
+
+#define TRUE 1
+#define FALSE 0
+
+extern void nilfunc(void);
+extern double sqr(double);
+extern int popcnt(int);
+extern int npoof2(int);
+extern int nblock2(int);
+
+extern int in_blocks(int count, int block_size);
+
+extern FILE *efopen(char *path, char *mode);
+extern FILE *efreopen(char *path, char *mode, FILE *strm);
+extern size_t filesize(char *path);
+extern size_t fdsize(int fd);
+
+extern struct timeval now_tv(void);
+extern struct timeval diff_tv(struct timeval *, struct timeval *);
+extern struct timeval sum_tv(struct timeval *, struct timeval *);
+extern char *fmt_tv(struct timeval *);
+extern char *since(struct timeval *);
+extern struct timeval now_tv(void);
+
+extern int hinterp_vec(REAL *, int, REAL *, int);
+
+extern void status_message(char *msg);
+
+extern FILE *find_rcfile(char *base);
+
+#endif
diff --git a/jDttSP/bufvec.c b/jDttSP/bufvec.c
new file mode 100644
index 0000000..606992b
--- /dev/null
+++ b/jDttSP/bufvec.c
@@ -0,0 +1,203 @@
+/* bufvec.c
+   creation, deletion, management for vectors and buffers 
+   
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <bufvec.h>
+
+/*------------------------------------------------------------------------*/
+/* wrapper around calloc */
+
+char *
+safealloc(int count, int nbytes, char *tag) {
+  char *p = calloc(count, nbytes);
+  if (!p) {
+    if (tag && *tag) fprintf(stderr, "safealloc: %s\n", tag);
+    else perror("safealloc");
+    exit(1);
+  }
+  return p;
+}
+
+void
+safefree(char *p) { if (p) free(p); }
+
+/*------------------------------------------------------------------------*/
+/* allocate/free just vectors */
+
+REAL *
+newvec_REAL(int size, char *tag) {
+  return (REAL *) safealloc(size, sizeof(REAL), tag);
+}
+
+void
+delvec_REAL(REAL *vec) { if (vec) free((char *) vec); }
+
+IMAG *
+newvec_IMAG(int size, char *tag) {
+  return (IMAG *) safealloc(size, sizeof(IMAG), tag);
+}
+
+void
+delvec_IMAG(IMAG *vec) { if (vec) free((char *) vec); }
+
+COMPLEX *
+newvec_COMPLEX(int size, char *tag) {
+  return (COMPLEX *) safealloc(size, sizeof(COMPLEX), tag);
+}
+
+void
+delvec_COMPLEX(COMPLEX *vec) { if (vec) free((char *) vec); }
+
+/*------------------------------------------------------------------------*/
+/* buffers (mainly i/o) */
+/*------------------------------------------------------------------------*/
+/* complex */
+
+CXB
+newCXB(int size, COMPLEX *base, char *tag) {
+  CXB p = (CXB) safealloc(1, sizeof(CXBuffer), tag);
+  if (base) {
+    CXBbase(p) = base;
+    CXBmine(p) = FALSE;
+  } else {
+    CXBbase(p) = newvec_COMPLEX(size, "newCXB");
+    CXBmine(p) = TRUE;
+  }
+  CXBsize(p) = CXBwant(p) = size;
+  CXBovlp(p) = CXBhave(p) = CXBdone(p) = 0;
+  return p;
+}
+
+void
+delCXB(CXB p) {
+  if (p) {
+    if (CXBmine(p)) delvec_COMPLEX(CXBbase(p));
+    free((char *) p);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+/* real */
+
+RLB
+newRLB(int size, REAL *base, char *tag) {
+  RLB p = (RLB) safealloc(1, sizeof(RLBuffer), tag);
+  if (base) {
+    RLBbase(p) = base;
+    RLBmine(p) = FALSE;
+  } else {
+    RLBbase(p) = newvec_REAL(size, "newRLB");
+    RLBmine(p) = TRUE;
+  }
+  RLBsize(p) = RLBwant(p) = size;
+  RLBovlp(p) = RLBhave(p) = RLBdone(p) = 0;
+  return p;
+}
+
+void
+delRLB(RLB p) {
+  if (p) {
+    delvec_REAL(RLBbase(p));
+    free((char *) p);
+  }
+}
+
+//========================================================================
+// return normalization constant
+
+REAL
+normalize_vec_REAL(REAL *v, int n) {
+  if (v && (n > 0)) {
+    int i;
+    REAL big = -MONDO;
+    for (i = 0; i < n; i++) {
+      REAL a = abs(v[i]);
+      big = max(big, a);
+    }
+    if (big > 0.0) {
+      REAL scl = 1.0 / big;
+      for (i = 0; i < n; i++) v[i] *= scl;
+      return scl;
+    } else return 0.0;
+  } else return 0.0;
+}
+
+REAL
+normalize_vec_COMPLEX(COMPLEX *z, int n) {
+  if (z && (n > 0)) {
+    int i;
+    REAL big = -MONDO;
+    for (i = 0; i < n; i++) {
+      REAL a = Cabs(z[i]);
+      big = max(big, a);
+    }
+    if (big > 0.0) {
+      REAL scl = 1.0 / big;
+      for (i = 0; i < n; i++) z[i] = Cscl(z[i], scl);
+      return scl;
+    } else return 0.0;
+  } else return 0.0;
+}
+
+/*------------------------------------------------------------------------*/
+/*------------------------------------------------------------------------*/
+/* mostly for debugging when necessary */
+
+void
+dump_REAL(FILE *fp, char *head, REAL *ptr, int beg, int fin) {
+  int i;
+  FILE *iop = fp? fp : stderr;
+  if (head && *head) fprintf(iop, "dump_REAL: %s\n", head);
+  for (i = beg; i < fin; i++)
+    fprintf(iop, "%5d %g\n", i, ptr[i]);
+}
+
+void
+dump_IMAG(FILE *fp, char *head, IMAG *ptr, int beg, int fin) {
+  int i;
+  FILE *iop = fp? fp : stderr;
+  if (head && *head) fprintf(iop, "dump_REAL: %s\n", head);
+  for (i = beg; i < fin; i++)
+    fprintf(iop, "%5d %g\n", i, ptr[i]);
+}
+
+void
+dump_CX(FILE *fp, char *head, COMPLEX *ptr, int beg, int fin) {
+  int i;
+  FILE *iop = fp? fp : stderr;
+  if (head && *head) fprintf(iop, "dump_CX: %s\n", head);
+  for (i = beg; i < fin; i++)
+    fprintf(iop, "%5d %g %g\n", i, ptr[i].re, ptr[i].im);
+}
+
+
diff --git a/jDttSP/bufvec.h b/jDttSP/bufvec.h
new file mode 100644
index 0000000..3da0db6
--- /dev/null
+++ b/jDttSP/bufvec.h
@@ -0,0 +1,99 @@
+/* bufvec.h
+
+defs for vector and buffer data structures and utilities
+   
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _bufvec_h
+
+#define _bufvec_h
+
+#include <fromsys.h>
+#include <datatypes.h>
+#include <complex.h>
+#include <cxops.h>
+
+typedef struct _complex_buffer_desc {
+  COMPLEX *data;
+  int size, ovlp, want, have, done, mine;
+} CXBuffer, *CXB;
+
+/* all these should be OK rhs or lhs */
+
+#define CXBbase(p) ((p)->data)
+#define CXBdata(p, i) (CXBbase(p)[(i)])
+#define CXBreal(p, i) (CXBbase(p)[(i)].re)
+#define CXBimag(p, i) (CXBbase(p)[(i)].im)
+#define CXBsize(p) ((p)->size)
+#define CXBovlp(p) ((p)->ovlp)
+#define CXBwant(p) ((p)->want)
+#define CXBhave(p) ((p)->have)
+#define CXBdone(p) ((p)->done)
+#define CXBmine(p) ((p)->mine)
+
+typedef struct _real_buffer_desc {
+  REAL *data;
+  int size, ovlp, want, have, done, mine;
+} RLBuffer, *RLB;
+
+#define RLBbase(p) ((p)->data)
+#define RLBdata(p, i) (RLBbase(p)[(i)])
+#define RLBsize(p) ((p)->size)
+#define RLBovlp(p) ((p)->ovlp)
+#define RLBwant(p) ((p)->want)
+#define RLBhave(p) ((p)->have)
+#define RLBdone(p) ((p)->done)
+#define RLBmine(p) ((p)->mine)
+
+extern char *safealloc(int count, int nbytes, char *tag);
+extern void safefree(char *p);
+extern REAL *newvec_REAL(int size, char *tag);
+extern void delvec_REAL(REAL *vec);
+extern IMAG *newvec_IMAG(int size, char *tag);
+extern void delvec_IMAG(IMAG *vec);
+extern COMPLEX *newvec_COMPLEX(int size, char *tag);
+extern void delvec_COMPLEX(COMPLEX *buf);
+extern void dump_REAL(FILE *fp, char *head, REAL *ptr, int beg, int fin);
+extern void dump_IMAG(FILE *fp, char *head, IMAG *ptr, int beg, int fin);
+extern void dump_CX(FILE *fp, char *head, COMPLEX *ptr, int beg, int fin);
+
+extern CXB newCXB(int size, COMPLEX *base, char *tag);
+extern void delCXB(CXB p);
+
+extern RLB newRLB(int size, REAL *base, char *tag);
+extern void delRLB(RLB p);
+
+extern REAL normalize_vec_REAL(REAL *, int);
+extern REAL normalize_vec_COMPLEX(COMPLEX *, int);
+
+#endif
+
diff --git a/jDttSP/chan.c b/jDttSP/chan.c
new file mode 100644
index 0000000..651274c
--- /dev/null
+++ b/jDttSP/chan.c
@@ -0,0 +1,106 @@
+/* chan.c
+
+fast inter-user-process single-reader/single-writer channels
+using a modified version of jack ringbuffers and memory-mapped files.
+   
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <chan.h>
+
+size_t
+putChan(Chan c, char *data, size_t size) {
+  return ringb_write(c->rb, data, size);
+}
+
+size_t
+getChan(Chan c, char *data, size_t size) {
+  return ringb_read(c->rb, data, size);
+}
+
+BOOLEAN
+putChan_nowait(Chan c, char *data, size_t size) {
+  if (ringb_write_space(c->rb) >= size) {
+    ringb_write(c->rb, data, size);
+    return TRUE;
+  } else return FALSE;
+}
+
+BOOLEAN
+getChan_nowait(Chan c, char *data, size_t size) {
+  if (ringb_read_space(c->rb) >= size) {
+    ringb_read(c->rb, data, size);
+    return TRUE;
+  } else return FALSE;
+}
+
+Chan
+openChan(char *path, size_t want) {
+  Chan c = (Chan) safealloc(sizeof(ChanDesc), 1, "Chan header");
+  c->size.rib = sizeof(ringb_t);
+  c->size.buf = nblock2(want);
+  c->file.path = path;
+  if ((c->file.desc = open(c->file.path, O_RDWR)) == -1) {
+    fprintf(stderr, "can't open Chan file %s\n", c->file.path);
+    exit(1);
+  }
+  c->size.tot = c->size.rib + c->size.buf;
+  if ((c->size.tru = fdsize(c->file.desc)) < c->size.tot) {
+    fprintf(stderr,
+	    "Chan file %s is too small (%d) for required size (%s)\n",
+	    c->file.path, c->size.tru, c->size.tot);
+    exit(1);
+  }
+  if (!(c->map.base = (char *) mmap(0,
+				    c->size.tot,
+				    PROT_READ | PROT_WRITE,
+				    MAP_SHARED,
+				    c->file.desc,
+				    0))) {
+    fprintf(stderr, "can't memory map %s for Chan\n",
+	    c->file.path);
+    exit(1);
+  }
+  if (!(c->rb = ringb_create(c->map.base, c->size.buf))) {
+    fprintf(stderr, "can't map RB for Chan\n");
+    exit(1);
+  }
+  return c;
+}
+
+void
+closeChan(Chan c) {
+  if (c) {
+    close(c->file.desc);
+    munmap(c->map.base, c->size.tot);
+    safefree((char *) c);
+  }
+}
diff --git a/jDttSP/chan.h b/jDttSP/chan.h
new file mode 100644
index 0000000..bf92625
--- /dev/null
+++ b/jDttSP/chan.h
@@ -0,0 +1,83 @@
+/* chan.h
+
+fast inter-user-process single-reader/single-writer channels
+using a modified version of jack ringbuffers and memory-mapped files.
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _chan_h
+#define _chan_h
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <values.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <math.h>
+#include <assert.h>
+#include <libgen.h>
+#include <datatypes.h>
+#include <banal.h>
+#include <bufvec.h>
+#include <ringb.h>
+
+typedef
+struct _chan {
+  struct {
+    size_t buf, rib, tot, tru;
+  } size;
+  struct {
+    char *path;
+    int desc;
+  } file;
+  struct {
+    char *base;
+  } map;
+  ringb_t *rb;
+} ChanDesc, *Chan;
+
+extern size_t putChan(Chan c, char *data, size_t size);
+extern size_t getChan(Chan c, char *data, size_t size);
+extern BOOLEAN putChan_nowait(Chan c, char *data, size_t size);
+extern BOOLEAN getChan_nowait(Chan c, char *data, size_t size);
+// NB want will be rounded up to a power of 2
+extern Chan openChan(char *path, size_t want);
+extern void closeChan(Chan c);
+
+#endif
diff --git a/jDttSP/chap.c b/jDttSP/chap.c
new file mode 100644
index 0000000..474e81c
--- /dev/null
+++ b/jDttSP/chap.c
@@ -0,0 +1,109 @@
+/* chap.c 
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <chap.h>
+
+REAL
+ChAp_eval(ChAp ca, REAL x, BOOLEAN *err) {
+  int i;
+  REAL d, e, u, v;
+
+  if (x < ChApLob(ca)) {
+    x = ChApLob(ca);
+    if (err) *err = TRUE;
+  } else if (x > ChApHib(ca)) {
+    x = ChApHib(ca);
+    if (err) *err = TRUE;
+  } else if (err) *err = FALSE;
+
+  d = e = 0.0;
+  u = (2.0 * x - ChApDif(ca)) / ChApDif(ca);
+  v = 2.0 * u;
+  for (i = ChApLen(ca) - 1; i > 0; --i) {
+    REAL sv = d;
+    d = v * d - e + ChApCoef(ca, i);
+    e = sv;
+  }
+
+  return u * d - e + 0.5 * ChApCoef(ca, 0);
+}
+
+ChAp
+ChAp_fit(ChAp ca) {
+  int i, j, n = ChApLen(ca);
+  REAL (*func)(REAL) = ChApFunc(ca),
+       bma = 0.5 * (ChApHib(ca) - ChApLob(ca)),
+       bpa = 0.5 * (ChApHib(ca) + ChApLob(ca)),
+       fac = 2.0 / n,
+      *tbl = newvec_REAL(n, ChApTag(ca));
+  for (j = 0; j < n; j++) {
+    REAL y = cos(M_PI * (j + 0.5) / n);
+    tbl[j] = (*func)(y * bma + bpa);
+  }
+  for (i = 0; i < n; i++) {
+    REAL sum = 0.0;
+    for (j = 0; j < n; j++)
+      sum += tbl[j] * cos((M_PI * i) * ((j + 0.5) / n));
+    ChApCoef(ca, i) = fac * sum;
+  }
+  delvec_REAL(tbl);
+  return ca;
+}
+
+ChAp
+newChAp(REAL (*func)(REAL arg),
+	REAL lo,
+	REAL hi,
+	int len,
+	char *tag) {
+  ChAp ca = (ChAp) safealloc(1, sizeof(ChApDesc), tag);
+  ChApFunc(ca) = func;
+  ChApLen(ca) = len;
+  ChApLob(ca) = lo;
+  ChApHib(ca) = hi;
+  ChApDif(ca) = hi - lo;
+  ChApCoefBase(ca) = newvec_REAL(len, tag);
+  ChApTag(ca) = strdup(tag);
+  return ChAp_fit(ca);
+}
+
+void
+delChAp(ChAp ca) {
+  if (ca) {
+    safefree((char *) ChApCoefBase(ca));
+    safefree(ChApTag(ca));
+    safefree((char *) ca);
+  }
+}
+
+
diff --git a/jDttSP/chap.h b/jDttSP/chap.h
new file mode 100644
index 0000000..a201ad9
--- /dev/null
+++ b/jDttSP/chap.h
@@ -0,0 +1,79 @@
+/* chap.h
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _chap_h
+#define _chap_h
+
+#include <fromsys.h>
+#include <banal.h>
+#include <splitfields.h>
+#include <datatypes.h>
+#include <bufvec.h>
+#include <cxops.h>
+#include <fastrig.h>
+#include <update.h>
+#include <lmadf.h>
+#include <fftw.h>
+#include <ovsv.h>
+#include <filter.h>
+#include <oscillator.h>
+
+typedef struct
+_cheby_approx {
+  REAL (*func)(REAL);
+  int len;
+  REAL *coef;
+  struct { REAL lo, hi, df; } lim;
+  char *tag;
+} ChApDesc, *ChAp;
+
+#define ChApFunc(p) ((p)->func)
+#define ChApLen(p) ((p)->len)
+#define ChApLob(p) ((p)->lim.lo)
+#define ChApHib(p) ((p)->lim.hi)
+#define ChApDif(p) ((p)->lim.df)
+#define ChApCoefBase(p) ((p)->coef)
+#define ChApCoef(p, i) (((p)->coef)[i])
+#define ChApTag(p) ((p)->tag)
+
+extern REAL ChAp_eval(ChAp ca, REAL x, BOOLEAN *err);
+extern ChAp ChAp_fit(ChAp ca);
+extern ChAp newChAp(REAL (*func)(REAL arg),
+		    REAL lo,
+		    REAL hi,
+		    int len,
+		    char *tag);
+
+extern void delChAp(ChAp ca);
+
+#endif
diff --git a/jDttSP/cmdr b/jDttSP/cmdr
new file mode 100755
index 0000000..e979db5
--- /dev/null
+++ b/jDttSP/cmdr
@@ -0,0 +1,14 @@
+#!/bin/sh
+
+CMDPIPE=./IPC/SDR-1000-0-commands.fifo
+
+while true
+do
+  read -p "command: " -e cmdline
+  if [ $? -ne 0 ]
+  then
+    break
+  fi
+  sendline="$cmdline"
+  echo $sendline
+done | m4 -e enums.m4 - >$CMDPIPE
diff --git a/jDttSP/command-vocabulary b/jDttSP/command-vocabulary
new file mode 100644
index 0000000..f927b5d
--- /dev/null
+++ b/jDttSP/command-vocabulary
@@ -0,0 +1,54 @@
+[TRX] indicates optional arg (RX or TX), RX default
+T|F indicates TRUE or FALSE
+(see enums.m4)
+
+setANF T|F		// on/off, RX only
+setANFvals taps delay gain leak	// int, int, float, float, RX only
+setATTOffset val	// float, RX only, appears only in squelch calc
+setBIN T|F		// binaural mode, on/off, RX only
+setFilter low-freq high-freq TRX
+setFinished		// shutdown gracefully
+setGainOffset		// float, RX only, appears only in squelch calc
+setMeterOffset lev	// float, RX only, appears only in squelch calc
+setMode mode [TRX]	// mode = USB, LSB, CWL, CWU, etc.
+setNB T|F		// on/off, RX only
+setNBvals thresh	// float, RX only
+setNR T|F		// on/off, RX only
+setNRvals taps delay gain leak	// int, int, float, float; RX only
+setOsc freq [TRX]	// freq in Hz (float)
+setRXAGC T|F		// on/off
+setRXAGC mode		// mode = agcOFF, agcSLOW, etc.
+setRXAGCCompression lev	// float
+setRXAGCHang dur	// float
+setRXAGCLimit lim	// float
+setRXEQ <bandspec>	// f0 dB0 f1 dB1 f2 dB2 ... fN (see setTXEQ)
+setRXPostScl T|F	// on/off
+setRXPostSclVal valQ	// dB
+setRXPreScl T|F		// on/off
+setRXPreSclVal valQ	// dB
+setRunState state	// RUN_MUTE, RUN_PASS, RUN_PLAY
+setSWCH trx [zap]	// trx = RX|TX, int (always zaps at least 1)
+setSampleRate rate	// Hz (float)
+setSpotTone T|F		// turn on, off
+setSpotToneVals gain freq rise fall // dB, Hz, msec, msec [-12, 700, 5, 5]
+setSquelch lev		// float, gain, RX only; default -30dB
+setSquelchSt T|F	// on/off, RX only
+setTRX trx		// trx = RX|TX
+setTXAGC T|F		// on/off
+setTXAGCCompression lev	// float
+setTXAGCHang dur	// float
+setTXAGCLimit lim	// float
+setTXEQ <bandspec>	// f0 dB0 f1 dB1 f2 dB2 ... fN
+	// typical:
+	// 0 dB1 75 dB2 150 dB3 300 dB4 600 dB5 1200 dB6 2000 dB7 2800 dB8 3600
+	// approximates W2IHY bandcenters
+setTXPostScl T|F	// on/off
+setTXPostSclVal valQ	// dB
+setTXPreScl T|F		// on/off
+setTXPreSclVal valQ	// dB
+setTXSpeechCompression T|F	// on/off
+setTXSpeechCompressionGain gain	// float
+setcorrectIQ phase gain	// int, int
+setcorrectIQgain gain	// int
+setcorrectIQphase phase	// int
+setfixedAGC gain [TRX]	// float
diff --git a/jDttSP/common.h b/jDttSP/common.h
new file mode 100644
index 0000000..0f71b86
--- /dev/null
+++ b/jDttSP/common.h
@@ -0,0 +1,66 @@
+/* common.h
+a simple way to get all the necessary includes
+   
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _common_h
+
+#define _common_h
+
+#include <fromsys.h>
+#include <banal.h>
+#include <splitfields.h>
+#include <datatypes.h>
+#include <bufvec.h>
+#include <cxops.h>
+#include <ringb.h>
+#include <chan.h>
+#include <lmadf.h>
+#include <fftw.h>
+#include <ovsv.h>
+#include <filter.h>
+#include <oscillator.h>
+#include <digitalagc.h>
+#include <am_demod.h>
+#include <fm_demod.h>
+#include <noiseblanker.h>
+#include <correctIQ.h>
+#include <crc16.h>
+#include <speechproc.h>
+#include <spottone.h>
+#include <update.h>
+#include <meter.h>
+#include <sdrexport.h>
+#include <local.h>
+
+#endif
+
diff --git a/jDttSP/complex.h b/jDttSP/complex.h
new file mode 100644
index 0000000..cf66d35
--- /dev/null
+++ b/jDttSP/complex.h
@@ -0,0 +1,46 @@
+/* complex.h
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _complex_h
+#define _complex_h
+
+typedef
+struct _COMPLEX {
+  double re, im;
+} COMPLEX;
+
+#define c_re(x) ((x).re)
+#define c_im(x) ((x).im)
+
+#endif
+
diff --git a/jDttSP/correctIQ.c b/jDttSP/correctIQ.c
new file mode 100644
index 0000000..3fc3e52
--- /dev/null
+++ b/jDttSP/correctIQ.c
@@ -0,0 +1,57 @@
+/* correctIQ.c
+
+This routine restores quadrature between arms of an analytic signal
+possibly distorted by ADC hardware.
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <common.h>
+
+IQ
+newCorrectIQ(REAL phaseadjustment, REAL gainadjustment) {
+  IQ iq = (IQ) safealloc(1, sizeof(iqstate), "IQ state");
+  iq->phase = phaseadjustment;
+  iq->gain = gainadjustment;
+  return iq;
+}
+
+void 
+delCorrectIQ(IQ iq) { safefree((char *) iq); }
+
+void
+correctIQ(CXB sigbuf, IQ iq) {
+  int i;
+  for (i = 0; i < CXBhave(sigbuf); i++) {
+    CXBimag(sigbuf, i) += iq->phase * CXBreal(sigbuf, i);
+    CXBreal(sigbuf, i) *= iq->gain;
+  }
+}
diff --git a/jDttSP/correctIQ.h b/jDttSP/correctIQ.h
new file mode 100644
index 0000000..0077a0a
--- /dev/null
+++ b/jDttSP/correctIQ.h
@@ -0,0 +1,14 @@
+#ifndef _correctIQ_h
+#define _correctIQ_h
+
+#include <bufvec.h>
+
+typedef  struct _iqstate {
+  REAL phase, gain;
+} *IQ, iqstate;
+
+extern IQ newCorrectIQ(REAL phaseadjusment, REAL gainadjustment);
+extern void delCorrectIQ(IQ iq);
+extern void correctIQ(CXB sigbuf, IQ iq);
+
+#endif
diff --git a/jDttSP/crc16.c b/jDttSP/crc16.c
new file mode 100644
index 0000000..a38e6c9
--- /dev/null
+++ b/jDttSP/crc16.c
@@ -0,0 +1,110 @@
+/* crc16.c */
+
+/* CCITT 16-bit CRC table and calculation function */
+
+/* $Id$ */
+
+/****************************************************************************
+ * @format.tab-size 4		(Plain Text/Source Code File Header)
+ * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)
+ *
+ * Copyright 2003 Rob Swindell - http://www.synchro.net/copyright.html
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * See the GNU General Public License for more details: gpl.txt or
+ * http://www.fsf.org/copyleft/gpl.html
+ *
+ * Anonymous FTP access to the most recent released source is available at
+ * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net
+ *
+ * Anonymous CVS access to the development source and modification history
+ * is available at cvs.synchro.net:/cvsroot/sbbs, example:
+ * cvs -d :pserver:anonymous@cvs.synchro.net:/cvsroot/sbbs login
+ *     (just hit return, no password is necessary)
+ * cvs -d :pserver:anonymous@cvs.synchro.net:/cvsroot/sbbs checkout src
+ *
+ * For Synchronet coding style and modification guidelines, see
+ * http://www.synchro.net/source.html
+ *
+ * You are encouraged to submit any modifications (preferably in Unix diff
+ * format) via e-mail to mods@synchro.net
+ *
+ * Note: If this box doesn't appear square, then you need to fix your tabs.
+ ****************************************************************************/
+
+/* modifications for DttSP
+   Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+   who can be reached by email at
+   ab2kt@arrl.net
+   or
+   rwmcgwier@comcast.net
+
+   or by paper mail at
+
+   The DTTS Microwave Society
+   6 Kathleen Place
+   Bridgewater, NJ 08807 */
+
+#include <crc16.h>
+
+static unsigned short crc16tbl[] = {
+0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
+0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
+0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
+0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
+0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
+0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
+0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
+0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
+0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
+0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
+0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
+0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
+0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
+0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
+0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
+0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
+0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
+0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
+0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
+0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
+0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
+0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
+0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
+0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
+0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
+0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
+0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
+0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
+0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
+0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
+0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
+};
+
+#define ucrc16(ch,crc) (crc16tbl[(((crc)>>8)&0xff)^(unsigned char)(ch)]^((crc)<<8))
+
+unsigned short
+crc16(char *data, unsigned long len) {
+  unsigned short crc = 0;
+  if (data)
+    while (len-- > 0) {
+      char d = *data++;
+      crc = ucrc16(d, crc);
+    }
+  return crc;
+}
+
+#ifdef notdef
+unsigned short
+crc16(char *data, unsigned long len) {
+  unsigned short crc = 0;
+  unsigned long l;
+  if (len == 0 && data != NULL) len = strlen(data);
+  for (l = 0; l < len; l++) crc = ucrc16(data[l], crc);
+  return crc;
+}
+#endif
diff --git a/jDttSP/crc16.h b/jDttSP/crc16.h
new file mode 100644
index 0000000..a244b1c
--- /dev/null
+++ b/jDttSP/crc16.h
@@ -0,0 +1,57 @@
+/* crc16.h */
+
+/* CCITT 16-bit CRC table and calculation function header */
+
+/* $Id$ */
+
+/****************************************************************************
+ * @format.tab-size 4		(Plain Text/Source Code File Header)
+ * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)
+ *
+ * Copyright 2003 Rob Swindell - http://www.synchro.net/copyright.html
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * See the GNU General Public License for more details: gpl.txt or
+ * http://www.fsf.org/copyleft/gpl.html
+ *
+ * Anonymous FTP access to the most recent released source is available at
+ * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net
+ *
+ * Anonymous CVS access to the development source and modification history
+ * is available at cvs.synchro.net:/cvsroot/sbbs, example:
+ * cvs -d :pserver:anonymous@cvs.synchro.net:/cvsroot/sbbs login
+ *     (just hit return, no password is necessary)
+ * cvs -d :pserver:anonymous@cvs.synchro.net:/cvsroot/sbbs checkout src
+ *
+ * For Synchronet coding style and modification guidelines, see
+ * http://www.synchro.net/source.html
+ *
+ * You are encouraged to submit any modifications (preferably in Unix diff
+ * format) via e-mail to mods@synchro.net
+ *
+ * Note: If this box doesn't appear square, then you need to fix your tabs.
+ ****************************************************************************/
+/* modifications for DttSP
+   Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+   who can be reached by email at
+   ab2kt@arrl.net
+   or
+   rwmcgwier@comcast.net
+
+   or by paper mail at
+
+   The DTTS Microwave Society
+   6 Kathleen Place
+   Bridgewater, NJ 08807 */
+
+#ifndef _crc16_h
+#define _crc16_h
+
+#include <fromsys.h>
+
+extern unsigned short crc16(char *data, unsigned long len);
+
+#endif
diff --git a/jDttSP/cxops.c b/jDttSP/cxops.c
new file mode 100644
index 0000000..b54dbef
--- /dev/null
+++ b/jDttSP/cxops.c
@@ -0,0 +1,109 @@
+/* cxops.c
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <cxops.h>
+
+// useful constants
+
+COMPLEX cxzero = {0.0, 0.0};
+COMPLEX cxone = {1.0, 0.0};
+COMPLEX cxJ = {0.0, 1.0};
+COMPLEX cxminusone = {-1.0, 0.0};
+COMPLEX cxminusJ = {0.0, -1.0};
+
+// scalar
+
+COMPLEX
+Cscl(COMPLEX x, REAL a) {
+  COMPLEX z;
+  c_re(z) = c_re(x) * a;
+  c_im(z) = c_im(x) * a;
+  return z;
+}
+
+COMPLEX
+Cadd(COMPLEX x, COMPLEX y) {
+  COMPLEX z;
+  c_re(z) = c_re(x) + c_re(y);
+  c_im(z) = c_im(x) + c_im(y);
+  return z;
+}
+
+COMPLEX
+Csub(COMPLEX x, COMPLEX y) {
+  COMPLEX z;
+  c_re(z) = c_re(x) - c_re(y);
+  c_im(z) = c_im(x) - c_im(y);
+  return z;
+}
+
+COMPLEX
+Cmul(COMPLEX x, COMPLEX y) {
+  COMPLEX z;
+  c_re(z) = c_re(x) * c_re(y) - c_im(x) * c_im(y);
+  c_im(z) = c_im(x) * c_re(y) + c_re(x) * c_im(y);
+  return z;
+}
+
+COMPLEX
+Cdiv(COMPLEX x, COMPLEX y) {
+  REAL d = sqr(c_re(y)) + sqr(c_im(y));
+  COMPLEX z;
+  c_re(z) = (c_re(x) * c_re(y) + c_im(x) * c_im(y)) / d;
+  c_im(z) = (c_re(y) * c_im(x) - c_im(y) * c_re(x)) / d;
+  return z;
+}
+
+REAL
+Cmag(COMPLEX z) { return sqrt(sqr(z.re) + sqr(z.im)); }
+
+REAL
+Cabs(COMPLEX z) { return sqrt(sqr(z.re) + sqr(z.im)); }
+
+REAL
+Csqrmag(COMPLEX z) { return sqr(z.re) + sqr(z.im); }
+
+COMPLEX
+Cmplx(REAL x, IMAG y) {
+  COMPLEX z;
+  z.re = x, z.im = y;
+  return z;
+}
+
+COMPLEX
+Conjg(COMPLEX z) { return Cmplx(z.re, -z.im); }
+
+COMPLEX
+Cexp(COMPLEX z) {
+  REAL r = exp(z.re);
+  return Cmplx(r * cos(z.im), r * sin(z.im));
+}
diff --git a/jDttSP/cxops.h b/jDttSP/cxops.h
new file mode 100644
index 0000000..83d2e26
--- /dev/null
+++ b/jDttSP/cxops.h
@@ -0,0 +1,58 @@
+/* cxops.h
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _cxops_h
+
+#define _cxops_h
+
+#include <datatypes.h>
+
+extern COMPLEX cxzero;
+extern COMPLEX cxone;
+extern COMPLEX cxJ;
+extern COMPLEX cxminusone;
+extern COMPLEX cxminusJ;
+
+extern INLINE COMPLEX Cscl(COMPLEX, REAL);
+extern INLINE COMPLEX Cadd(COMPLEX, COMPLEX);
+extern INLINE COMPLEX Csub(COMPLEX, COMPLEX);
+extern INLINE COMPLEX Cmul(COMPLEX, COMPLEX);
+extern INLINE COMPLEX Cdiv(COMPLEX, COMPLEX);
+extern INLINE REAL Cmag(COMPLEX);
+extern INLINE REAL Cabs(COMPLEX);
+extern INLINE REAL Csqrmag(COMPLEX);
+extern INLINE COMPLEX Cmplx(REAL, IMAG);
+extern INLINE COMPLEX Conjg(COMPLEX);
+extern INLINE COMPLEX Cexp(COMPLEX);
+
+#endif
+
diff --git a/jDttSP/datatypes.h b/jDttSP/datatypes.h
new file mode 100644
index 0000000..6bc3a4e
--- /dev/null
+++ b/jDttSP/datatypes.h
@@ -0,0 +1,58 @@
+/* datatypes.h
+   local definitions and aliases for our data
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _datatypes_h
+
+#define _datatypes_h
+
+#include <fromsys.h>
+
+typedef int BOOLEAN;
+typedef double REAL;
+typedef double IMAG;
+typedef short SAMPLE_16t;
+
+#include <complex.h>
+
+#ifndef PRIVATE
+#define PRIVATE static
+#endif
+
+#ifndef INLINE
+#define INLINE inline
+#endif
+
+#include <banal.h>
+
+#endif
+
diff --git a/jDttSP/digitalagc.c b/jDttSP/digitalagc.c
new file mode 100644
index 0000000..5d559a1
--- /dev/null
+++ b/jDttSP/digitalagc.c
@@ -0,0 +1,127 @@
+/* digitalagc.c
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+We appreciate the contributions to this subroutine by Gerald Youngblood,
+AC5OG and Phil Harman, VK6APH.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <common.h>
+
+/*
+ * Mode is gross agc mode: off, slow, med, fast; just info
+ * Hang is basic hang time
+ * Size is max hang time
+ * Over is recover period after TRX switch
+ * Rcov is hang value used during recovery period
+ * BufSize is length of sample buffer
+ */
+
+DIGITALAGC
+newDigitalAgc(int Mode,
+	      int Hang,
+	      int Size,
+	      int Over,
+	      int Rcov,
+	      int Ramp,
+	      int BufSize,
+	      REAL MaxGain,
+	      REAL Limit,
+	      REAL CurGain,
+	      COMPLEX *Vec) {
+  DIGITALAGC a = (DIGITALAGC) safealloc(1,
+					sizeof(digital_agc_state),
+					"new digital agc state");
+  assert((Ramp >= 2) && (Ramp < BufSize));
+  a->mode = Mode;
+  a->hang = Hang;
+  a->size = Size;
+  a->over = Over;
+  a->rcov = Rcov;
+  a->ramp = Ramp;
+  a->gain.top = MaxGain;
+  a->gain.lim = Limit;
+  a->gain.old = a->gain.now = CurGain;
+  a->buff = newCXB(BufSize, Vec, "agc buffer");
+  memset((void *) a->hist, 0, sizeof(a->hist));
+  a->indx = 0;
+  a->gain.fix = 1000.0;
+  return a;
+}
+
+void
+delDigitalAgc(DIGITALAGC a) {
+  if (a) {
+    delCXB(a->buff);
+    safefree((void *) a);
+  }
+}
+
+void
+DigitalAgc(DIGITALAGC a, int tick) {
+  
+  if (a->mode == agcOFF) {
+    int i;
+    for (i = 0; i < CXBsize(a->buff); i++)
+      CXBdata(a->buff, i) = Cscl(CXBdata(a->buff, i), a->gain.fix);
+    
+  } else {
+    int i,
+        k = a->indx,
+        hang = tick < a->over ? a->rcov : a->hang;
+    REAL peak = 0.0;
+    
+    for (i = 0; i < CXBsize(a->buff); i++)
+      peak = max(peak, Cmag(CXBdata(a->buff, i)));
+    
+    if (peak != 0) {
+      a->size = hang;
+      a->hist[k] = a->gain.lim / peak;
+      for (i = 1, a->gain.now = a->hist[0]; i < hang; i++)
+	a->gain.now = min(a->hist[i], a->gain.now);
+    }
+    a->gain.now = min(a->gain.now, a->gain.top);
+    
+    if (a->gain.now != a->gain.old) {
+      REAL step = (a->gain.now - a->gain.old) / (a->ramp - 1);
+      for (i = 0; i < a->ramp; i++)
+	CXBdata(a->buff, i) = Cscl(CXBdata(a->buff, i), a->gain.old + i * step);
+      for (; i < CXBsize(a->buff); i++)
+	CXBdata(a->buff, i) = Cscl(CXBdata(a->buff, i), a->gain.now);
+      a->gain.old = a->gain.now;
+      
+    } else
+      for (i = 0; i < CXBsize(a->buff); i++)
+	CXBdata(a->buff, i) = Cscl(CXBdata(a->buff, i), a->gain.now);
+    
+    a->indx = ++k % a->size;
+  }
+}
diff --git a/jDttSP/digitalagc.h b/jDttSP/digitalagc.h
new file mode 100644
index 0000000..ae886a7
--- /dev/null
+++ b/jDttSP/digitalagc.h
@@ -0,0 +1,74 @@
+/* digitalagc.h
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _digitalagc_h
+#define _digitalagc_h
+
+#include <datatypes.h>
+#include <bufvec.h>
+#include <cxops.h>
+#include <banal.h>
+
+typedef enum _agcmode { agcOFF, agcLONG, agcSLOW, agcMED, agcFAST } AGCMODE;
+
+#define AGCHIST (24)
+
+typedef
+struct _digitalagc {
+  AGCMODE mode;
+  int hang, indx, over, ramp, rcov, size;
+  struct {
+    REAL fix, lim, now, old, top;
+  } gain;
+  REAL hist[AGCHIST];
+  CXB buff;
+} digital_agc_state, *DIGITALAGC;
+
+extern void delDigitalAgc(DIGITALAGC agc);
+
+extern DIGITALAGC 
+newDigitalAgc(int Mode,
+	      int Hang,
+	      int Size,
+	      int Ramp,
+	      int Over,
+	      int Rcov,
+	      int BufSize,
+	      REAL MaxGain,
+	      REAL Limit,
+	      REAL CurGain,
+	      COMPLEX *Vec);
+
+extern void DigitalAgc(DIGITALAGC agc, int tick);
+
+#endif
diff --git a/jDttSP/enums.m4 b/jDttSP/enums.m4
new file mode 100644
index 0000000..f9669f7
--- /dev/null
+++ b/jDttSP/enums.m4
@@ -0,0 +1,64 @@
+define(OFF,0)dnl
+define(ON,1)dnl
+define(FALSE,0)dnl
+define(TRUE,1)dnl
+define(F,0)dnl
+define(T,1)dnl
+define(FIR_Undef,0)dnl
+define(FIR_Lowpass,1)dnl
+define(FIR_Bandpass,2)dnl
+define(FIR_Highpass,3)dnl
+define(FIR_Hilbert,4)dnl
+define(FIR_Bandstop,5)dnl
+dnl
+define(FIR_Even,0)dnl
+define(FIR_Odd,1)dnl
+dnl
+define(MAG,0)dnl
+define(DB,1)dnl
+dnl
+define(SIGNAL_STRENGTH,0)dnl
+define(AVG_SIGNAL_STRENGTH,1)dnl
+define(ADC_REAL,2)dnl
+define(ADC_IMAG,3)dnl
+define(AGC_GAIN,4)dnl
+dnl
+define(agcOFF,0)dnl
+define(agcLONG,1)dnl
+define(agcSLOW,2)dnl
+define(agcMED,3)dnl
+define(agcFAST,4)dnl
+dnl
+define(LSB,0)dnl
+define(USB,1)dnl
+define(DSB,2)dnl
+define(CWL,3)dnl
+define(CWU,4)dnl
+define(FM,5)dnl
+define(FMN,5)dnl
+define(AM,6)dnl
+define(PSK,7)dnl
+define(SPEC,8)dnl
+define(RTTY,9)dnl
+define(SAM,10)dnl
+define(DRM,11)dnl
+dnl
+define(RX,0)dnl
+define(TX,1)dnl
+dnl
+define(RECTANGULAR_WINDOW,0)dnl
+define(HANNING_WINDOW,1)dnl
+define(WELCH_WINDOW,2)dnl
+define(PARZEN_WINDOW,3)dnl
+define(BARTLETT_WINDOW,4)dnl
+define(HAMMING_WINDOW,5)dnl
+define(BLACKMAN2_WINDOW,6)dnl
+define(BLACKMAN3_WINDOW,7)dnl
+define(BLACKMAN4_WINDOW,8)dnl
+define(EXPONENTIAL_WINDOW,9)dnl
+define(RIEMANN_WINDOW,10)dnl
+dnl
+define(RUN_MUTE,0)dnl
+define(RUN_PASS,1)dnl
+define(RUN_PLAY,2)dnl
+define(RUN_SWCH,3)dnl
diff --git a/jDttSP/fastrig.c b/jDttSP/fastrig.c
new file mode 100644
index 0000000..5c4d8ff
--- /dev/null
+++ b/jDttSP/fastrig.c
@@ -0,0 +1,259 @@
+
+/****************************************************************
+ *   Fast Trigonometric Routines Used for Imbedded Systems      *
+ *   Programmer:  Bob McGwier, IDA CCR-P, June, 2000            *
+ ***************************************************************/
+/* This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The author can be reached by email at
+
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+Robert W McGwier, N4HY
+64 Brooktree Road
+East Windsor, NJ 08520
+*/
+
+#include <fastrig.h>
+
+REAL
+phasemod(REAL angle) {
+   while (angle >= TWOPI) angle -= TWOPI;
+   while (angle < 0.0) angle += TWOPI;
+   return angle;
+}
+
+//REAL phasemod(REAL angle)
+//{
+ // return (angle - floor(angle/TWOPI)*TWOPI);
+//}
+
+#if (TRIG_SPEED != 0)
+
+static REAL TABLE_FACTOR;
+static REAL *sinT, *cosT;
+
+/***************************************************************************/
+/* Constant definitions                                                    */
+/***************************************************************************/
+#define TAN_MAP_RES     0.003921569	/* (smallest non-zero value in table) */
+#define RAD_PER_DEG     0.017453293
+#define TAN_MAP_SIZE    256
+
+/* arctangents from 0 to pi/4 radians */
+static REAL fast_atan_table[257] = {
+  0.000000e+00, 3.921549e-03, 7.842976e-03, 1.176416e-02,
+  1.568499e-02, 1.960533e-02, 2.352507e-02, 2.744409e-02,
+  3.136226e-02, 3.527947e-02, 3.919560e-02, 4.311053e-02,
+  4.702413e-02, 5.093629e-02, 5.484690e-02, 5.875582e-02,
+  6.266295e-02, 6.656816e-02, 7.047134e-02, 7.437238e-02,
+  7.827114e-02, 8.216752e-02, 8.606141e-02, 8.995267e-02,
+  9.384121e-02, 9.772691e-02, 1.016096e-01, 1.054893e-01,
+  1.093658e-01, 1.132390e-01, 1.171087e-01, 1.209750e-01,
+  1.248376e-01, 1.286965e-01, 1.325515e-01, 1.364026e-01,
+  1.402496e-01, 1.440924e-01, 1.479310e-01, 1.517652e-01,
+  1.555948e-01, 1.594199e-01, 1.632403e-01, 1.670559e-01,
+  1.708665e-01, 1.746722e-01, 1.784728e-01, 1.822681e-01,
+  1.860582e-01, 1.898428e-01, 1.936220e-01, 1.973956e-01,
+  2.011634e-01, 2.049255e-01, 2.086818e-01, 2.124320e-01,
+  2.161762e-01, 2.199143e-01, 2.236461e-01, 2.273716e-01,
+  2.310907e-01, 2.348033e-01, 2.385093e-01, 2.422086e-01,
+  2.459012e-01, 2.495869e-01, 2.532658e-01, 2.569376e-01,
+  2.606024e-01, 2.642600e-01, 2.679104e-01, 2.715535e-01,
+  2.751892e-01, 2.788175e-01, 2.824383e-01, 2.860514e-01,
+  2.896569e-01, 2.932547e-01, 2.968447e-01, 3.004268e-01,
+  3.040009e-01, 3.075671e-01, 3.111252e-01, 3.146752e-01,
+  3.182170e-01, 3.217506e-01, 3.252758e-01, 3.287927e-01,
+  3.323012e-01, 3.358012e-01, 3.392926e-01, 3.427755e-01,
+  3.462497e-01, 3.497153e-01, 3.531721e-01, 3.566201e-01,
+  3.600593e-01, 3.634896e-01, 3.669110e-01, 3.703234e-01,
+  3.737268e-01, 3.771211e-01, 3.805064e-01, 3.838825e-01,
+  3.872494e-01, 3.906070e-01, 3.939555e-01, 3.972946e-01,
+  4.006244e-01, 4.039448e-01, 4.072558e-01, 4.105574e-01,
+  4.138496e-01, 4.171322e-01, 4.204054e-01, 4.236689e-01,
+  4.269229e-01, 4.301673e-01, 4.334021e-01, 4.366272e-01,
+  4.398426e-01, 4.430483e-01, 4.462443e-01, 4.494306e-01,
+  4.526070e-01, 4.557738e-01, 4.589307e-01, 4.620778e-01,
+  4.652150e-01, 4.683424e-01, 4.714600e-01, 4.745676e-01,
+  4.776654e-01, 4.807532e-01, 4.838312e-01, 4.868992e-01,
+  4.899573e-01, 4.930055e-01, 4.960437e-01, 4.990719e-01,
+  5.020902e-01, 5.050985e-01, 5.080968e-01, 5.110852e-01,
+  5.140636e-01, 5.170320e-01, 5.199904e-01, 5.229388e-01,
+  5.258772e-01, 5.288056e-01, 5.317241e-01, 5.346325e-01,
+  5.375310e-01, 5.404195e-01, 5.432980e-01, 5.461666e-01,
+  5.490251e-01, 5.518738e-01, 5.547124e-01, 5.575411e-01,
+  5.603599e-01, 5.631687e-01, 5.659676e-01, 5.687566e-01,
+  5.715357e-01, 5.743048e-01, 5.770641e-01, 5.798135e-01,
+  5.825531e-01, 5.852828e-01, 5.880026e-01, 5.907126e-01,
+  5.934128e-01, 5.961032e-01, 5.987839e-01, 6.014547e-01,
+  6.041158e-01, 6.067672e-01, 6.094088e-01, 6.120407e-01,
+  6.146630e-01, 6.172755e-01, 6.198784e-01, 6.224717e-01,
+  6.250554e-01, 6.276294e-01, 6.301939e-01, 6.327488e-01,
+  6.352942e-01, 6.378301e-01, 6.403565e-01, 6.428734e-01,
+  6.453808e-01, 6.478788e-01, 6.503674e-01, 6.528466e-01,
+  6.553165e-01, 6.577770e-01, 6.602282e-01, 6.626701e-01,
+  6.651027e-01, 6.675261e-01, 6.699402e-01, 6.723452e-01,
+  6.747409e-01, 6.771276e-01, 6.795051e-01, 6.818735e-01,
+  6.842328e-01, 6.865831e-01, 6.889244e-01, 6.912567e-01,
+  6.935800e-01, 6.958943e-01, 6.981998e-01, 7.004964e-01,
+  7.027841e-01, 7.050630e-01, 7.073330e-01, 7.095943e-01,
+  7.118469e-01, 7.140907e-01, 7.163258e-01, 7.185523e-01,
+  7.207701e-01, 7.229794e-01, 7.251800e-01, 7.273721e-01,
+  7.295557e-01, 7.317307e-01, 7.338974e-01, 7.360555e-01,
+  7.382053e-01, 7.403467e-01, 7.424797e-01, 7.446045e-01,
+  7.467209e-01, 7.488291e-01, 7.509291e-01, 7.530208e-01,
+  7.551044e-01, 7.571798e-01, 7.592472e-01, 7.613064e-01,
+  7.633576e-01, 7.654008e-01, 7.674360e-01, 7.694633e-01,
+  7.714826e-01, 7.734940e-01, 7.754975e-01, 7.774932e-01,
+  7.794811e-01, 7.814612e-01, 7.834335e-01, 7.853983e-01,
+  7.853983e-01
+};
+
+void
+InitSPEEDTRIG(void) {
+  int i, SIZE;
+  TABLE_FACTOR = ONE_OVER_TWOPI * SIN_TABLE_SIZE;
+  SIZE = sizeof(REAL) * (SIN_TABLE_SIZE + 1);
+  sinT = (REAL *) malloc(SIZE + (SIZE >> 2) + 1);
+  /*  cosT=(REAL *)malloc(SIZE); */
+  for (i = 0; i < SIN_TABLE_SIZE + (SIN_TABLE_SIZE >> 2) + 1; i++) {
+    sinT[i] = (REAL) sin((REAL) i * TWOPI / (REAL) SIN_TABLE_SIZE);
+    /*    cosT[i] = (REAL)cos((REAL)i * TWOPI/(REAL)SIN_TABLE_SIZE); */
+  }
+  cosT = sinT + (SIN_TABLE_SIZE >> 2);
+}
+
+REAL
+fast_sin(REAL x) {
+#if (TRIG_SPEED==2)
+  x = (x * TABLE_FACTOR) + 0.5;
+  return sinT[((int) x) & (SIN_TABLE_SIZE_M1)];
+#else
+  int i, ip1;
+  REAL frac;
+  x = (x * TABLE_FACTOR);
+  i = (int)(frac = floor(x));
+  ip1 = i + 1;
+  frac = x - frac;
+  return (1.0 - frac) * sinT[i] + frac * sinT[ip1];
+#endif
+}
+
+REAL
+fast_cos(REAL x) {
+#if (TRIG_SPEED==2)
+  x = (x * TABLE_FACTOR) + 0.5;
+  return cosT[((int) x) & (SIN_TABLE_SIZE - 1)];
+#else
+  int i, ip1;
+  REAL frac;
+  x = (x * TABLE_FACTOR);
+  i = (int)(frac = floor(x));
+  ip1 = i + 1;
+  frac = x - frac;
+  return (1.0 - frac) * cosT[i] + frac * cosT[ip1];
+#endif
+}
+
+/*****************************************************************************
+ Function:      Arc tangent
+
+ Syntax:        angle = fast_atan2(y, x);
+                    REAL   y       y component of input vector
+                    REAL   x       x component of input vector
+                    REAL   angle   angle of vector (x, y) in radians
+              
+ Description:   This function calculates the angle of the vector (x,y) based
+                on a table lookup and linear interpolation. The table uses
+                a 256 point table covering -45 to +45 degrees and uses
+                symetry to determine the final angle value in the range of
+                -180 to 180 degrees. Note that this function uses the small
+                angle approximation for values close to zero. This routine
+                calculates the arc tangent with an average  error of
+                +/- 0.045 degrees.
+*****************************************************************************/
+
+REAL
+fast_atan2(REAL y, REAL x) {
+  REAL x_abs, y_abs, z;
+  REAL alpha, angle, base_angle;
+  int index;
+
+  /* don't divide by zero! */
+  if ((y == 0.0) && (x == 0.0)) angle = 0.0;
+  else {
+    /* normalize to +/- 45 degree range */
+    y_abs = fabs(y);
+    x_abs = fabs(x);
+    z = (y_abs < x_abs ? y_abs / x_abs : x_abs / y_abs);
+    /* when ratio approaches the table resolution, the angle is */
+    /*      best approximated with the argument itself...       */
+    if (z < TAN_MAP_RES)  base_angle = z;
+    else {
+      /* find index and interpolation value */
+      alpha = z * (REAL) TAN_MAP_SIZE - .5;
+      index = (int) alpha;
+      alpha -= (REAL) index;
+      /* determine base angle based on quadrant and */
+      /* add or subtract table value from base angle based on quadrant */
+      base_angle = fast_atan_table[index];
+      base_angle +=
+	(fast_atan_table[index + 1] - fast_atan_table[index]) * alpha;
+    }
+
+    if (x_abs > y_abs) {	/* -45 -> 45 or 135 -> 225 */
+      if (x >= 0.0) {		/* -45 -> 45 */
+	if (y >= 0.0)
+	  angle = base_angle;	/* 0 -> 45, angle OK */
+	else
+	  angle = -base_angle;	/* -45 -> 0, angle = -angle */
+      } else {			/* 135 -> 180 or 180 -> -135 */
+	angle = 3.14159265358979323846;
+	if (y >= 0.0)
+	  angle -= base_angle;	/* 135 -> 180, angle = 180 - angle */
+	else
+	  angle = base_angle - angle;	/* 180 -> -135, angle = angle - 180 */
+      }
+    } else {			/* 45 -> 135 or -135 -> -45 */
+      if (y >= 0.0) {		/* 45 -> 135 */
+	angle = 1.57079632679489661923;
+	if (x >= 0.0)
+	  angle -= base_angle;	/* 45 -> 90, angle = 90 - angle */
+	else
+	  angle += base_angle;	/* 90 -> 135, angle = 90 + angle */
+      } else {			/* -135 -> -45 */
+	angle = -1.57079632679489661923;
+	if (x >= 0.0)
+	  angle += base_angle;	/* -90 -> -45, angle = -90 + angle */
+	else
+	  angle -= base_angle;	/* -135 -> -90, angle = -90 - angle */
+      }
+    }
+  }
+#ifdef ZERO_TO_TWOPI
+  if (angle < 0) return (angle + TWOPI);
+  else return (angle);
+#else
+  return (angle);
+#endif
+}
+
+#endif
diff --git a/jDttSP/fastrig.h b/jDttSP/fastrig.h
new file mode 100644
index 0000000..ae8485b
--- /dev/null
+++ b/jDttSP/fastrig.h
@@ -0,0 +1,99 @@
+/* fastrig.h
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _fastrig_h
+#define _fastrig_h
+
+#include <fromsys.h>
+#include <banal.h>
+#include <splitfields.h>
+#include <datatypes.h>
+#include <bufvec.h>
+#include <cxops.h>
+
+#define SIN_TABLE_SIZE 4096
+#define SIN_TABLE_SIZE_M1 4095
+
+/* ********************************************** 
+ * TRIG_SPEED: 
+ * 0 = normal (slow); 
+ * 1 = table look up with interpolation (medium);
+ * 2 = table look up (fast) 
+ * ***********************************************/
+
+/* Interpolation is ALWAYS done on atan2.  The setting
+   only applies to sin and cos */
+
+#ifndef TRIG_SPEED
+#define TRIG_SPEED 0
+#endif
+
+#if (TRIG_SPEED == 2)
+#define SIN(x)     fast_sin(x)
+#define COS(x)     fast_cos(x)
+#define ATAN2(x,y) fast_atan2((x),(y))
+
+#elif (TRIG_SPEED == 1)
+
+#define SIN(x)     fast_sin(x)
+#define COS(x)     fast_cos(x)
+#define ATAN2(x,y) fast_atan2((x),(y))
+
+#elif (TRIG_SPEED == 0)
+
+#define SIN(x)     (REAL)sin((REAL)x)
+#define COS(x)     (REAL)cos((REAL)x)
+#define ATAN2(x,y) (REAL)atan2((REAL)(x),(REAL)(y))
+
+#endif
+
+#ifndef PI
+#define PI M_PI
+#endif /* PI */
+
+#ifndef TWOPI
+#define TWOPI    (2.0 * PI)
+#endif
+
+#ifndef ONE_OVER_TWOPI
+#define ONE_OVER_TWOPI (0.159154943091895)
+#endif
+
+#if (TRIG_SPEED != 0)
+
+extern void InitSPEEDTRIG(void);
+extern REAL fast_sin(REAL);
+extern REAL fast_cos(REAL);
+extern REAL fast_atan2(REAL, REAL);
+
+#endif
+#endif
diff --git a/jDttSP/fftw.h b/jDttSP/fftw.h
new file mode 100644
index 0000000..9384082
--- /dev/null
+++ b/jDttSP/fftw.h
@@ -0,0 +1,426 @@
+/* -*- C -*- */
+/*
+ * Copyright (c) 1997-1999, 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+/* fftw.h -- system-wide definitions */
+/* $Id$ */
+
+#ifndef FFTW_H
+#define FFTW_H
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif				/* __cplusplus */
+
+/* Define for using single precision */
+/*
+ * If you can, use configure --enable-float instead of changing this
+ * flag directly 
+ */
+/* #undef FFTW_ENABLE_FLOAT */
+
+/* our real numbers */
+#ifdef FFTW_ENABLE_FLOAT
+typedef float fftw_real;
+#else
+typedef double fftw_real;
+#endif
+
+/*********************************************
+ * Complex numbers and operations 
+ *********************************************/
+typedef struct {
+     fftw_real re, im;
+} fftw_complex;
+
+#ifndef c_re
+#define c_re(c)  ((c).re)
+#endif
+#ifndef c_im
+#define c_im(c)  ((c).im)
+#endif
+
+typedef enum {
+     FFTW_FORWARD = -1, FFTW_BACKWARD = 1
+} fftw_direction;
+
+/* backward compatibility with FFTW-1.3 */
+typedef fftw_complex FFTW_COMPLEX;
+typedef fftw_real FFTW_REAL;
+
+#ifndef FFTW_1_0_COMPATIBILITY
+#define FFTW_1_0_COMPATIBILITY 0
+#endif
+
+#if FFTW_1_0_COMPATIBILITY
+/* backward compatibility with FFTW-1.0 */
+#define REAL fftw_real
+#define COMPLEX fftw_complex
+#endif
+
+/*********************************************
+ * Success or failure status
+ *********************************************/
+
+typedef enum {
+     FFTW_SUCCESS = 0, FFTW_FAILURE = -1
+} fftw_status;
+
+/*********************************************
+ *              Codelets
+ *********************************************/
+typedef void (fftw_notw_codelet) 
+     (const fftw_complex *, fftw_complex *, int, int);
+typedef void (fftw_twiddle_codelet)
+     (fftw_complex *, const fftw_complex *, int,
+      int, int);
+typedef void (fftw_generic_codelet) 
+     (fftw_complex *, const fftw_complex *, int,
+      int, int, int);
+typedef void (fftw_real2hc_codelet)
+     (const fftw_real *, fftw_real *, fftw_real *,
+      int, int, int);
+typedef void (fftw_hc2real_codelet)
+     (const fftw_real *, const fftw_real *,
+      fftw_real *, int, int, int);
+typedef void (fftw_hc2hc_codelet)
+     (fftw_real *, const fftw_complex *,
+      int, int, int);
+typedef void (fftw_rgeneric_codelet)
+     (fftw_real *, const fftw_complex *, int,
+      int, int, int);
+
+/*********************************************
+ *     Configurations
+ *********************************************/
+/*
+ * A configuration is a database of all known codelets
+ */
+
+enum fftw_node_type {
+     FFTW_NOTW, FFTW_TWIDDLE, FFTW_GENERIC, FFTW_RADER,
+     FFTW_REAL2HC, FFTW_HC2REAL, FFTW_HC2HC, FFTW_RGENERIC
+};
+
+/* description of a codelet */
+typedef struct {
+     const char *name;		/* name of the codelet */
+     void (*codelet) ();	/* pointer to the codelet itself */
+     int size;			/* size of the codelet */
+     fftw_direction dir;	/* direction */
+     enum fftw_node_type type;	/* TWIDDLE or NO_TWIDDLE */
+     int signature;		/* unique id */
+     int ntwiddle;		/* number of twiddle factors */
+     const int *twiddle_order;	/* 
+				 * array that determines the order 
+				 * in which the codelet expects
+				 * the twiddle factors
+				 */
+} fftw_codelet_desc;
+
+/* On Win32, you need to do funny things to access global variables
+   in shared libraries.  Thanks to Andrew Sterian for this hack. */
+#ifdef HAVE_WIN32
+#  if defined(BUILD_FFTW_DLL)
+#    define DL_IMPORT(type) __declspec(dllexport) type
+#  elif defined(USE_FFTW_DLL)
+#    define DL_IMPORT(type) __declspec(dllimport) type
+#  else
+#    define DL_IMPORT(type) type
+#  endif
+#else
+#  define DL_IMPORT(type) type
+#endif
+
+extern DL_IMPORT(const char *) fftw_version;
+
+/*****************************
+ *        Plans
+ *****************************/
+/*
+ * A plan is a sequence of reductions to compute a FFT of
+ * a given size.  At each step, the FFT algorithm can:
+ *
+ * 1) apply a notw codelet, or
+ * 2) recurse and apply a twiddle codelet, or
+ * 3) apply the generic codelet.
+ */
+
+/* structure that contains twiddle factors */
+typedef struct fftw_twiddle_struct {
+     int n;
+     const fftw_codelet_desc *cdesc;
+     fftw_complex *twarray;
+     struct fftw_twiddle_struct *next;
+     int refcnt;
+} fftw_twiddle;
+
+typedef struct fftw_rader_data_struct {
+     struct fftw_plan_struct *plan;
+     fftw_complex *omega;
+     int g, ginv;
+     int p, flags, refcount;
+     struct fftw_rader_data_struct *next;
+     fftw_codelet_desc *cdesc;
+} fftw_rader_data;
+
+typedef void (fftw_rader_codelet) 
+     (fftw_complex *, const fftw_complex *, int,
+      int, int, fftw_rader_data *);
+
+/* structure that holds all the data needed for a given step */
+typedef struct fftw_plan_node_struct {
+     enum fftw_node_type type;
+
+     union {
+	  /* nodes of type FFTW_NOTW */
+	  struct {
+	       int size;
+	       fftw_notw_codelet *codelet;
+	       const fftw_codelet_desc *codelet_desc;
+	  } notw;
+
+	  /* nodes of type FFTW_TWIDDLE */
+	  struct {
+	       int size;
+	       fftw_twiddle_codelet *codelet;
+	       fftw_twiddle *tw;
+	       struct fftw_plan_node_struct *recurse;
+	       const fftw_codelet_desc *codelet_desc;
+	  } twiddle;
+
+	  /* nodes of type FFTW_GENERIC */
+	  struct {
+	       int size;
+	       fftw_generic_codelet *codelet;
+	       fftw_twiddle *tw;
+	       struct fftw_plan_node_struct *recurse;
+	  } generic;
+
+	  /* nodes of type FFTW_RADER */
+	  struct {
+	       int size;
+	       fftw_rader_codelet *codelet;
+	       fftw_rader_data *rader_data;
+	       fftw_twiddle *tw;
+	       struct fftw_plan_node_struct *recurse;
+	  } rader;
+
+	  /* nodes of type FFTW_REAL2HC */
+	  struct {
+	       int size;
+	       fftw_real2hc_codelet *codelet;
+	       const fftw_codelet_desc *codelet_desc;
+	  } real2hc;
+
+	  /* nodes of type FFTW_HC2REAL */
+	  struct {
+	       int size;
+	       fftw_hc2real_codelet *codelet;
+	       const fftw_codelet_desc *codelet_desc;
+	  } hc2real;
+
+	  /* nodes of type FFTW_HC2HC */
+	  struct {
+	       int size;
+	       fftw_direction dir;
+	       fftw_hc2hc_codelet *codelet;
+	       fftw_twiddle *tw;
+	       struct fftw_plan_node_struct *recurse;
+	       const fftw_codelet_desc *codelet_desc;
+	  } hc2hc;
+
+	  /* nodes of type FFTW_RGENERIC */
+	  struct {
+	       int size;
+	       fftw_direction dir;
+	       fftw_rgeneric_codelet *codelet;
+	       fftw_twiddle *tw;
+	       struct fftw_plan_node_struct *recurse;
+	  } rgeneric;
+     } nodeu;
+
+     int refcnt;
+} fftw_plan_node;
+
+typedef enum {
+     FFTW_NORMAL_RECURSE = 0,
+     FFTW_VECTOR_RECURSE = 1
+} fftw_recurse_kind;
+
+struct fftw_plan_struct {
+     int n;
+     int refcnt;
+     fftw_direction dir;
+     int flags;
+     int wisdom_signature;
+     enum fftw_node_type wisdom_type;
+     struct fftw_plan_struct *next;
+     fftw_plan_node *root;
+     double cost;
+     fftw_recurse_kind recurse_kind;
+     int vector_size;
+};
+
+typedef struct fftw_plan_struct *fftw_plan;
+
+/* flags for the planner */
+#define  FFTW_ESTIMATE (0)
+#define  FFTW_MEASURE  (1)
+
+#define FFTW_OUT_OF_PLACE (0)
+#define FFTW_IN_PLACE (8)
+#define FFTW_USE_WISDOM (16)
+
+#define FFTW_THREADSAFE (128)  /* guarantee plan is read-only so that the
+				  same plan can be used in parallel by
+				  multiple threads */
+
+#define FFTWND_FORCE_BUFFERED (256)     /* internal flag, forces buffering
+                                           in fftwnd transforms */
+
+#define FFTW_NO_VECTOR_RECURSE (512)    /* internal flag, prevents use
+                                           of vector recursion */
+
+extern fftw_plan fftw_create_plan_specific(int n, fftw_direction dir,
+					   int flags,
+					   fftw_complex *in, int istride,
+					 fftw_complex *out, int ostride);
+#define FFTW_HAS_PLAN_SPECIFIC
+extern fftw_plan fftw_create_plan(int n, fftw_direction dir, int flags);
+extern void fftw_print_plan(fftw_plan plan);
+extern void fftw_destroy_plan(fftw_plan plan);
+extern void fftw(fftw_plan plan, int howmany, fftw_complex *in, int istride,
+		 int idist, fftw_complex *out, int ostride, int odist);
+extern void fftw_one(fftw_plan plan, fftw_complex *in, fftw_complex *out);
+extern void fftw_die(const char *s);
+extern void *fftw_malloc(size_t n);
+extern void fftw_free(void *p);
+extern void fftw_check_memory_leaks(void);
+extern void fftw_print_max_memory_usage(void);
+
+typedef void *(*fftw_malloc_type_function) (size_t n);
+typedef void  (*fftw_free_type_function) (void *p);
+typedef void  (*fftw_die_type_function) (const char *errString);
+extern DL_IMPORT(fftw_malloc_type_function) fftw_malloc_hook;
+extern DL_IMPORT(fftw_free_type_function) fftw_free_hook;
+extern DL_IMPORT(fftw_die_type_function) fftw_die_hook;
+
+extern size_t fftw_sizeof_fftw_real(void);
+
+/* Wisdom: */
+/*
+ * define this symbol so that users know we are using a version of FFTW
+ * with wisdom
+ */
+#define FFTW_HAS_WISDOM
+extern void fftw_forget_wisdom(void);
+extern void fftw_export_wisdom(void (*emitter) (char c, void *), void *data);
+extern fftw_status fftw_import_wisdom(int (*g) (void *), void *data);
+extern void fftw_export_wisdom_to_file(FILE *output_file);
+extern fftw_status fftw_import_wisdom_from_file(FILE *input_file);
+extern char *fftw_export_wisdom_to_string(void);
+extern fftw_status fftw_import_wisdom_from_string(const char *input_string);
+
+/*
+ * define symbol so we know this function is available (it is not in
+ * older FFTWs)
+ */
+#define FFTW_HAS_FPRINT_PLAN
+extern void fftw_fprint_plan(FILE *f, fftw_plan plan);
+
+/*****************************
+ *    N-dimensional code
+ *****************************/
+typedef struct {
+     int is_in_place;		/* 1 if for in-place FFTs, 0 otherwise */
+
+     int rank;			/* 
+				 * the rank (number of dimensions) of the
+				 * array to be FFTed 
+				 */
+     int *n;			/*
+				 * the dimensions of the array to the
+				 * FFTed 
+				 */
+     fftw_direction dir;
+
+     int *n_before;		/*
+				 * n_before[i] = product of n[j] for j < i 
+				 */
+     int *n_after;		/* n_after[i] = product of n[j] for j > i */
+
+     fftw_plan *plans;		/* 1d fftw plans for each dimension */
+
+     int nbuffers, nwork;
+     fftw_complex *work;	/* 
+				 * work array big enough to hold
+				 * nbuffers+1 of the largest dimension 
+				 * (has nwork elements)
+				 */
+} fftwnd_data;
+
+typedef fftwnd_data *fftwnd_plan;
+
+/* Initializing the FFTWND plan: */
+extern fftwnd_plan fftw2d_create_plan(int nx, int ny, fftw_direction dir,
+				      int flags);
+extern fftwnd_plan fftw3d_create_plan(int nx, int ny, int nz,
+				      fftw_direction dir, int flags);
+extern fftwnd_plan fftwnd_create_plan(int rank, const int *n,
+				      fftw_direction dir,
+				      int flags);
+
+extern fftwnd_plan fftw2d_create_plan_specific(int nx, int ny,
+					       fftw_direction dir,
+					       int flags,
+					   fftw_complex *in, int istride,
+					 fftw_complex *out, int ostride);
+extern fftwnd_plan fftw3d_create_plan_specific(int nx, int ny, int nz,
+					   fftw_direction dir, int flags,
+					   fftw_complex *in, int istride,
+					 fftw_complex *out, int ostride);
+extern fftwnd_plan fftwnd_create_plan_specific(int rank, const int *n,
+					       fftw_direction dir,
+					       int flags,
+					   fftw_complex *in, int istride,
+					 fftw_complex *out, int ostride);
+
+/* Freeing the FFTWND plan: */
+extern void fftwnd_destroy_plan(fftwnd_plan plan);
+
+/* Printing the plan: */
+extern void fftwnd_fprint_plan(FILE *f, fftwnd_plan p);
+extern void fftwnd_print_plan(fftwnd_plan p);
+#define FFTWND_HAS_PRINT_PLAN
+
+/* Computing the N-Dimensional FFT */
+extern void fftwnd(fftwnd_plan plan, int howmany,
+		   fftw_complex *in, int istride, int idist,
+		   fftw_complex *out, int ostride, int odist);
+extern void fftwnd_one(fftwnd_plan p, fftw_complex *in, fftw_complex *out);
+
+#ifdef __cplusplus
+}                               /* extern "C" */
+
+#endif				/* __cplusplus */
+#endif				/* FFTW_H */
diff --git a/jDttSP/filter.c b/jDttSP/filter.c
new file mode 100644
index 0000000..a9bca9c
--- /dev/null
+++ b/jDttSP/filter.c
@@ -0,0 +1,504 @@
+/* filter.c
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <filter.h>
+
+static REAL onepi = 3.141592653589793;
+
+#define twopi TWOPI
+
+RealFIR
+newFIR_REAL(int size, char *tag) {
+  RealFIR p = (RealFIRDesc *) safealloc(1, sizeof(RealFIRDesc), tag);
+  FIRcoef(p) = (REAL *) safealloc(size, sizeof(REAL), tag);
+  FIRsize(p) = size;
+  FIRtype(p) = FIR_Undef;
+  FIRiscomplex(p) = FALSE;
+  FIRfqlo(p) = FIRfqhi(p) = -1.0;
+  return p;
+}
+
+ComplexFIR
+newFIR_COMPLEX(int size, char *tag) {
+  ComplexFIR p = (ComplexFIRDesc *) safealloc(1, sizeof(ComplexFIRDesc), tag);
+  FIRcoef(p) = (COMPLEX *) safealloc(size, sizeof(COMPLEX), tag);
+  FIRsize(p) = size;
+  FIRtype(p) = FIR_Undef;
+  FIRiscomplex(p) = TRUE;
+  FIRfqlo(p) = FIRfqhi(p) = -1.0;
+  return p;
+}
+
+void
+delFIR_REAL(RealFIR p) {
+  if (p) {
+    delvec_REAL(FIRcoef(p));
+    free((void *) p);
+  }
+}
+
+void
+delFIR_COMPLEX(ComplexFIR p) {
+  if (p) {
+    delvec_COMPLEX(FIRcoef(p));
+    free((void *) p);
+  }
+}
+
+RealFIR
+newFIR_Lowpass_REAL(REAL cutoff, REAL sr, int size) {
+  if ((cutoff < 0.0) || (cutoff > (sr / 2.0))) return 0;
+  else if (size < 1) return 0;
+  else {
+    RealFIR p;
+    REAL *h, *w, fc = cutoff / sr;
+    int i, midpoint;
+    
+    if (!(size & 01)) size++;
+    midpoint = (size >> 01) | 01;
+    p = newFIR_REAL(size, "newFIR_Lowpass_REAL");
+    h = FIRcoef(p);
+    w = newvec_REAL(size, "newFIR_Lowpass_REAL window");
+    (void) makewindow(BLACKMANHARRIS_WINDOW, size, w);
+    
+    for (i = 1; i <= size; i++) {
+      int j = i - 1;
+      if (i != midpoint)
+	h[j] = (sin(twopi * (i - midpoint) * fc) / (onepi * (i - midpoint))) * w[j];
+      else
+	h[midpoint - 1] = 2.0 * fc;
+    }
+    
+    delvec_REAL(w);
+    FIRtype(p) = FIR_Lowpass;
+    return p;
+  }
+}
+
+ComplexFIR
+newFIR_Lowpass_COMPLEX(REAL cutoff, REAL sr, int size) {
+  if ((cutoff < 0.0) || (cutoff > (sr / 2.0))) return 0;
+  else if (size < 1) return 0;
+  else {
+    ComplexFIR p;
+    COMPLEX *h;
+    REAL *w, fc = cutoff / sr;
+    int i, midpoint;
+    
+    if (!(size & 01)) size++;
+    midpoint = (size >> 01) | 01;
+    p = newFIR_COMPLEX(size, "newFIR_Lowpass_COMPLEX");
+    h = FIRcoef(p);
+    w = newvec_REAL(size, "newFIR_Lowpass_REAL window");
+    (void) makewindow(BLACKMANHARRIS_WINDOW, size, w);
+    
+    for (i = 1; i <= size; i++) {
+      int j = i - 1;
+      if (i != midpoint)
+	h[j].re = (sin(twopi * (i - midpoint) * fc) / (onepi * (i - midpoint))) * w[j];
+      else
+	h[midpoint - 1].re = 2.0 * fc;
+    }
+
+    delvec_REAL(w);
+    FIRtype(p) = FIR_Lowpass;
+    return p;
+  }
+}
+
+RealFIR
+newFIR_Bandpass_REAL(REAL lo, REAL hi, REAL sr, int size) {
+  if ((lo < 0.0) || (hi > (sr / 2.0)) || (hi <= lo)) return 0;
+  else if (size < 1) return 0;
+  else {
+    RealFIR p;
+    REAL *h, *w, fc, ff;
+    int i, midpoint;
+
+    if (!(size & 01)) size++;
+    midpoint = (size >> 01) | 01;
+    p = newFIR_REAL(size, "newFIR_Bandpass_REAL");
+    h = FIRcoef(p);
+    w = newvec_REAL(size, "newFIR_Bandpass_REAL window");
+    (void) makewindow(BLACKMANHARRIS_WINDOW, size, w);
+
+    lo /= sr, hi /= sr;
+    fc = (hi - lo) / 2.0;
+    ff = (lo + hi) * onepi;
+
+    for (i = 1; i <= size; i++) {
+      int j = i - 1;
+      if (i != midpoint)
+	h[j] = (sin(twopi * (i - midpoint) * fc) / (onepi * (i - midpoint))) * w[j];
+      else
+	h[midpoint - 1] = 2.0 * fc;
+      h[j] *= 2.0 * cos(ff * (i - midpoint));
+    }
+
+    delvec_REAL(w);
+    FIRtype(p) = FIR_Bandpass;
+    return p;
+  }
+}
+
+ComplexFIR
+newFIR_Bandpass_COMPLEX(REAL lo, REAL hi, REAL sr, int size) {
+  if ((lo < -(sr/2.0)) || (hi > (sr / 2.0)) || (hi <= lo)) return 0;
+  else if (size < 1) return 0;
+  else {
+    ComplexFIR p;
+    COMPLEX *h;
+    REAL *w, fc, ff;
+    int i, midpoint;
+
+    if (!(size & 01)) size++;
+    midpoint = (size >> 01) | 01;
+    p = newFIR_COMPLEX(size, "newFIR_Bandpass_COMPLEX");
+    h = FIRcoef(p);
+    w = newvec_REAL(size, "newFIR_Bandpass_COMPLEX window");
+    (void) makewindow(BLACKMANHARRIS_WINDOW, size, w);
+
+    lo /= sr, hi /= sr;
+    fc = (hi - lo) / 2.0;
+    ff = (lo + hi) * onepi;
+
+    for (i = 1; i <= size; i++) {
+      int j = i - 1, k = i - midpoint;
+      REAL tmp, phs = ff * k;
+      if (i != midpoint)
+	tmp = (sin(twopi * k * fc) / (onepi * k)) * w[j];
+      else
+	tmp = 2.0 * fc;
+      tmp *= 2.0;
+      h[j].re = tmp * cos(phs);
+      h[j].im = tmp * sin(phs);
+    }
+
+    delvec_REAL(w);
+    FIRtype(p) = FIR_Bandpass;
+    return p;
+  }
+}
+
+RealFIR
+newFIR_Highpass_REAL(REAL cutoff, REAL sr, int size) {
+  if ((cutoff < 0.0) || (cutoff > (sr / 2.0))) return 0;
+  else if (size < 1) return 0;
+  else {
+    RealFIR p;
+    REAL *h, *w, fc = cutoff / sr;
+    int i, midpoint;
+
+    if (!(size & 01)) size++;
+    midpoint = (size >> 01) | 01;
+    p = newFIR_REAL(size, "newFIR_Highpass_REAL");
+    h = FIRcoef(p);
+    w = newvec_REAL(size, "newFIR_Highpass_REAL window");
+    (void) makewindow(BLACKMANHARRIS_WINDOW, size, w);
+
+    for (i = 1; i <= size; i++) {
+      int j = i - 1;
+      if (i != midpoint)
+	h[j] = (sin(twopi * (i - midpoint) * fc) / (onepi * (i - midpoint))) * w[j];
+      else
+	h[midpoint - 1] = 2.0 * fc;
+    }
+
+    for (i = 1; i <= size; i++) {
+      int j = i - 1;
+      if (i != midpoint) h[j] = -h[j];
+      else h[midpoint - 1] = 1.0 - h[midpoint - 1];
+    }
+
+    delvec_REAL(w);
+    FIRtype(p) = FIR_Highpass;
+    return p;
+  }
+}
+
+ComplexFIR
+newFIR_Highpass_COMPLEX(REAL cutoff, REAL sr, int size) {
+  if ((cutoff < 0.0) || (cutoff > (sr / 2.0))) return 0;
+  else if (size < 1) return 0;
+  else {
+    ComplexFIR p;
+    COMPLEX *h;
+    REAL *w, fc = cutoff / sr;
+    int i, midpoint;
+
+    if (!(size & 01)) size++;
+    midpoint = (size >> 01) | 01;
+    p = newFIR_COMPLEX(size, "newFIR_Highpass_REAL");
+    h = FIRcoef(p);
+    w = newvec_REAL(size, "newFIR_Highpass_REAL window");
+    (void) makewindow(BLACKMANHARRIS_WINDOW, size, w);
+
+    for (i = 1; i <= size; i++) {
+      int j = i - 1;
+      if (i != midpoint)
+	h[j].re = (sin(twopi * (i - midpoint) * fc) / (onepi * (i - midpoint))) * w[j];
+      else
+	h[midpoint - 1].re = 2.0 * fc;
+    }
+
+    for (i = 1; i <= size; i++) {
+      int j = i - 1;
+      if (i != midpoint) h[j].re = -h[j].re;
+      else h[midpoint - 1].re = 1.0 - h[midpoint - 1].re;
+    }
+
+    delvec_REAL(w);
+    FIRtype(p) = FIR_Highpass;
+    return p;
+  }
+}
+
+RealFIR
+newFIR_Hilbert_REAL(REAL lo, REAL hi, REAL sr, int size) {
+  if ((lo < 0.0) || (hi > (sr / 2.0)) || (hi <= lo)) return 0;
+  else if (size < 1) return 0;
+  else {
+    RealFIR p;
+    REAL *h, *w, fc, ff;
+    int i, midpoint;
+
+    if (!(size & 01)) size++;
+    midpoint = (size >> 01) | 01;
+    p = newFIR_REAL(size, "newFIR_Hilbert_REAL");
+    h = FIRcoef(p);
+    w = newvec_REAL(size, "newFIR_Hilbert_REAL window");
+    (void) makewindow(BLACKMANHARRIS_WINDOW, size, w);
+
+    lo /= sr, hi /= sr;
+    fc = (hi - lo) / 2.0;
+    ff = (lo + hi) * onepi;
+
+    for (i = 1; i <= size; i++) {
+      int j = i - 1;
+      if (i != midpoint)
+	h[j] = (sin(twopi * (i - midpoint) * fc) / (onepi * (i - midpoint))) * w[j];
+      else
+	h[midpoint - 1] = 2.0 * fc;
+      h[j] *= 2.0 * sin(ff * (i - midpoint));
+    }
+
+    delvec_REAL(w);
+    FIRtype(p) = FIR_Hilbert;
+    return p;
+  }
+}
+
+ComplexFIR
+newFIR_Hilbert_COMPLEX(REAL lo, REAL hi, REAL sr, int size) {
+  if ((lo < 0.0) || (hi > (sr / 2.0)) || (hi <= lo)) return 0;
+  else if (size < 1) return 0;
+  else {
+    ComplexFIR p;
+    COMPLEX *h;
+    REAL *w, fc, ff;
+    int i, midpoint;
+
+    if (!(size & 01)) size++;
+    midpoint = (size >> 01) | 01;
+    p = newFIR_COMPLEX(size, "newFIR_Hilbert_COMPLEX");
+    h = FIRcoef(p);
+    w = newvec_REAL(size, "newFIR_Hilbert_COMPLEX window");
+    (void) makewindow(BLACKMANHARRIS_WINDOW, size, w);
+
+    lo /= sr, hi /= sr;
+    fc = (hi - lo) / 2.0;
+    ff = (lo + hi) * onepi;
+
+    for (i = 1; i <= size; i++) {
+      int j = i - 1;
+      REAL tmp, phs = ff * (i - midpoint);
+      if (i != midpoint)
+	tmp = (sin(twopi * (i - midpoint) * fc) / (onepi * (i - midpoint))) * w[j];
+      else
+	tmp = 2.0 * fc;
+      tmp *= 2.0;
+      /* h[j].re *= tmp * cos(phs); */
+      h[j].im *= tmp * sin(phs);
+    }
+
+    delvec_REAL(w);
+    FIRtype(p) = FIR_Hilbert;
+    return p;
+  }
+}
+
+RealFIR
+newFIR_Bandstop_REAL(REAL lo, REAL hi, REAL sr, int size) {
+  if ((lo < 0.0) || (hi > (sr / 2.0)) || (hi <= lo)) return 0;
+  else if (size < 1) return 0;
+  else {
+    RealFIR p;
+    REAL *h, *w, fc, ff;
+    int i, midpoint;
+
+    if (!(size & 01)) size++;
+    midpoint = (size >> 01) | 01;
+    p = newFIR_REAL(size, "newFIR_Bandstop_REAL");
+    h = FIRcoef(p);
+    w = newvec_REAL(size, "newFIR_Bandstop_REAL window");
+    (void) makewindow(BLACKMANHARRIS_WINDOW, size, w);
+
+    lo /= sr, hi /= sr;
+    fc = (hi - lo) / 2.0;
+    ff = (lo + hi) * onepi;
+
+    for (i = 1; i <= size; i++) {
+      int j = i - 1;
+      if (i != midpoint)
+	h[j] = (sin(twopi * (i - midpoint) * fc) / (onepi * (i - midpoint))) * w[j];
+      else
+	h[midpoint - 1] = 2.0 * fc;
+      h[j] *= 2.0 * cos(ff * (i - midpoint));
+    }
+
+    for (i = 1; i <= size; i++) {
+      int j = i - 1;
+      if (i != midpoint) h[j] = -h[j];
+      else h[midpoint - 1] = 1.0 - h[midpoint - 1];
+    }
+
+    delvec_REAL(w);
+    FIRtype(p) = FIR_Bandstop;
+    return p;
+  }
+}
+
+ComplexFIR
+newFIR_Bandstop_COMPLEX(REAL lo, REAL hi, REAL sr, int size) {
+  if ((lo < 0.0) || (hi > (sr / 2.0)) || (hi <= lo)) return 0;
+  else if (size < 1) return 0;
+  else {
+    ComplexFIR p;
+    COMPLEX *h;
+    REAL *w, fc, ff;
+    int i, midpoint;
+
+    if (!(size & 01)) size++;
+    midpoint = (size >> 01) | 01;
+    p = newFIR_COMPLEX(size, "newFIR_Bandstop_REAL");
+    h = FIRcoef(p);
+    w = newvec_REAL(size, "newFIR_Bandstop_REAL window");
+    (void) makewindow(BLACKMANHARRIS_WINDOW, size, w);
+
+    lo /= sr, hi /= sr;
+    fc = (hi - lo) / 2.0;
+    ff = (lo + hi) * onepi;
+
+    for (i = 1; i <= size; i++) {
+      int j = i - 1;
+      REAL tmp, phs = ff * (i - midpoint);
+      if (i != midpoint)
+	tmp = (sin(twopi * (i - midpoint) * fc) / (onepi * (i - midpoint))) * w[j];
+      else
+	tmp = 2.0 * fc;
+      tmp *= 2.0;
+      h[j].re *= tmp * cos(phs);
+      h[j].im *= tmp * sin(phs);
+    }
+
+    for (i = 1; i <= size; i++) {
+      int j = i - 1;
+      if (i != midpoint) h[j] = Cmul(h[j], cxminusone);
+      else h[midpoint - 1] = Csub(cxone, h[midpoint - 1]);
+    }
+
+    delvec_REAL(w);
+    FIRtype(p) = FIR_Bandstop;
+    return p;
+  }
+}
+
+#ifdef notdef
+int
+main(int argc, char **argv) {
+  int i, size = 101;
+  RealFIR filt;
+#ifdef notdef
+  filt = newFIR_Lowpass_REAL(1000.0, 48000.0, size);
+  for (i = 0; i < FIRsize(filt); i++)
+    printf("%d %f\n", i, FIRtap(filt, i));
+  delFIR_REAL(filt);
+#endif
+
+#ifdef notdef
+  filt = newFIR_Bandstop_REAL(1000.0, 2000.0, 48000.0, size);
+  for (i = 0; i < FIRsize(filt); i++)
+    printf("%d %f\n", i, FIRtap(filt, i));
+  delFIR_REAL(filt);
+#endif
+
+  filt = newFIR_Bandpass_REAL(1000.0, 2000.0, 48000.0, size);
+  for (i = 0; i < FIRsize(filt); i++)
+    printf("%d %f\n", i, FIRtap(filt, i));
+  delFIR_REAL(filt);
+
+#ifdef notdef
+  filt = newFIR_Highpass_REAL(1000.0, 48000.0, size);
+  for (i = 0; i < FIRsize(filt); i++)
+    printf("%d %f\n", i, FIRtap(filt, i));
+  delFIR_REAL(filt);
+#endif
+
+#ifdef notdef
+  filt = newFIR_Hilbert_REAL(1000.0, 2000.0, 48000.0, size);
+  for (i = 0; i < FIRsize(filt); i++)
+    printf("%d %f\n", i, FIRtap(filt, i));
+  delFIR_REAL(filt);
+#endif
+
+#ifdef notdef
+  {
+    COMPLEX *z;
+    REAL *ttbl;
+    int fftlen;
+    fftlen = nblock2(size) * 2;
+    z = newvec_COMPLEX(fftlen, "z");
+    ttbl = newvec_REAL(fftlen, "ttbl");
+    cfftm(FFT_INIT, fftlen, (float *) z, (float *) z, ttbl);
+    for (i = 0; i < FIRsize(filt); i++)
+      z[i].re = FIRtap(filt, i);
+    cfftm(FFT_FORWARD, fftlen, (float *) z, (float *) z, ttbl);
+    for (i = 0; i < size; i++) {
+      printf("%d %f\n", i, Cabs(z[i]));
+      delvec_COMPLEX(z);
+      delvec_REAL(ttbl);
+    }
+  }
+#endif
+  exit(0);
+}
+#endif
diff --git a/jDttSP/filter.h b/jDttSP/filter.h
new file mode 100644
index 0000000..47eb97e
--- /dev/null
+++ b/jDttSP/filter.h
@@ -0,0 +1,108 @@
+/* filter.h
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _filter_h
+
+#define _filter_h
+
+#include <fromsys.h>
+#include <banal.h>
+#include <splitfields.h>
+#include <datatypes.h>
+#include <bufvec.h>
+#include <cxops.h>
+#include <fastrig.h>
+#include <update.h>
+#include <lmadf.h>
+#include <fftw.h>
+#include <window.h>
+
+typedef enum {
+  FIR_Undef, FIR_Lowpass, FIR_Bandpass, FIR_Highpass, FIR_Hilbert, FIR_Bandstop
+} FIR_response_type;
+
+typedef enum { FIR_Even, FIR_Odd } FIR_parity_type;
+
+typedef
+struct _real_FIR {
+  REAL *coef;
+  int size;
+  FIR_response_type type;
+  BOOLEAN cplx;
+  struct { REAL lo, hi; } freq;
+} RealFIRDesc, *RealFIR;
+
+typedef
+struct _complex_FIR {
+  COMPLEX *coef;
+  int size;
+  FIR_response_type type;
+  BOOLEAN cplx;
+  struct { REAL lo, hi; } freq;
+} ComplexFIRDesc, *ComplexFIR;
+
+#define FIRcoef(p) ((p)->coef)
+#define FIRtap(p, i) (FIRcoef(p)[(i)])
+#define FIRsize(p) ((p)->size)
+#define FIRtype(p) ((p)->type)
+#define FIRiscomplex(p) ((p)->cplx)
+#define FIRisreal(p) (!FIRiscomplex(p))
+#define FIRfqlo(p) ((p)->freq.lo)
+#define FIRfqhi(p) ((p)->freq.hi)
+
+#define delFIR_Lowpass_REAL(p) delFIR_REAL(p)
+#define delFIR_Lowpass_COMPLEX(p) delFIR_COMPLEX(p)
+#define delFIR_Bandpass_REAL(p) delFIR_REAL(p)
+#define delFIR_Bandpass_COMPLEX(p) delFIR_COMPLEX(p)
+#define delFIR_Highpass_REAL(p) delFIR_REAL(p)
+#define delFIR_Highpass_COMPLEX(p) delFIR_COMPLEX(p)
+#define delFIR_Hilbert_REAL(p) delFIR_REAL(p)
+#define delFIR_Hilbert_COMPLEX(p) delFIR_COMPLEX(p)
+#define delFIR_Bandstop_REAL(p) delFIR_REAL(p)
+#define delFIR_Bandstop_COMPLEX(p) delFIR_COMPLEX(p)
+
+extern RealFIR newFIR_REAL(int size, char *tag);
+extern ComplexFIR newFIR_COMPLEX(int size, char *tag);
+extern void delFIR_REAL(RealFIR p);
+extern void delFIR_COMPLEX(ComplexFIR p);
+extern RealFIR newFIR_Lowpass_REAL(REAL cutoff, REAL sr, int size);
+extern ComplexFIR newFIR_Lowpass_COMPLEX(REAL cutoff, REAL sr, int size);
+extern RealFIR newFIR_Bandpass_REAL(REAL lo, REAL hi, REAL sr, int size);
+extern ComplexFIR newFIR_Bandpass_COMPLEX(REAL lo, REAL hi, REAL sr, int size);
+extern RealFIR newFIR_Highpass_REAL(REAL cutoff, REAL sr, int size);
+extern ComplexFIR newFIR_Highpass_COMPLEX(REAL cutoff, REAL sr, int size);
+extern RealFIR newFIR_Hilbert_REAL(REAL lo, REAL hi, REAL sr, int size);
+extern ComplexFIR newFIR_Hilbert_COMPLEX(REAL lo, REAL hi, REAL sr, int size);
+extern RealFIR newFIR_Bandstop_REAL(REAL lo, REAL hi, REAL sr, int size);
+extern ComplexFIR newFIR_Bandstop_COMPLEX(REAL lo, REAL hi, REAL sr, int size);
+
+#endif
diff --git a/jDttSP/fm_demod.c b/jDttSP/fm_demod.c
new file mode 100644
index 0000000..1735eaf
--- /dev/null
+++ b/jDttSP/fm_demod.c
@@ -0,0 +1,103 @@
+/* fm_demod.c */
+
+#include <fm_demod.h>
+
+/*------------------------------------------------------------------------------*/
+/* private to FM */
+/*------------------------------------------------------------------------------*/
+
+PRIVATE void
+init_pll(FMD fm,
+	 REAL samprate,
+	 REAL freq,
+	 REAL lofreq,
+	 REAL hifreq,
+	 REAL bandwidth) {
+  REAL fac = TWOPI / samprate;
+
+  fm->pll.freq.f = freq * fac;
+  fm->pll.freq.l = lofreq * fac;
+  fm->pll.freq.h = hifreq * fac;
+  fm->pll.phs = 0.0;
+  fm->pll.delay = cxJ;
+
+  fm->pll.iir.alpha = bandwidth * fac; /* arm filter */
+  fm->pll.alpha = fm->pll.iir.alpha * 0.3; /* pll bandwidth */
+  fm->pll.beta = fm->pll.alpha * fm->pll.alpha * 0.25; /* second order term */
+}
+
+PRIVATE void
+pll(FMD fm, COMPLEX sig) {
+  COMPLEX z = Cmplx(cos(fm->pll.phs), sin(fm->pll.phs));
+  REAL diff;
+
+  fm->pll.delay.re =  z.re * sig.re + z.im * sig.im;
+  fm->pll.delay.im = -z.im * sig.re + z.re * sig.im;
+  diff = ATAN2(fm->pll.delay.im, fm->pll.delay.re);
+
+  fm->pll.freq.f += fm->pll.beta * diff;
+
+  if (fm->pll.freq.f < fm->pll.freq.l)
+    fm->pll.freq.f = fm->pll.freq.l;
+  if (fm->pll.freq.f > fm->pll.freq.h)
+    fm->pll.freq.f = fm->pll.freq.h;
+
+  fm->pll.phs += fm->pll.freq.f + fm->pll.alpha * diff;
+
+  while (fm->pll.phs >= TWOPI) fm->pll.phs -= TWOPI;
+  while (fm->pll.phs < 0) fm->pll.phs += TWOPI;
+}
+
+/*------------------------------------------------------------------------------*/
+/* public */
+/*------------------------------------------------------------------------------*/
+
+void
+FMDemod(FMD fm) {
+  int i;
+  for (i = 0; i < CXBsize(fm->ibuf); i++) {
+    pll(fm, CXBdata(fm->ibuf, i));
+    fm->afc = 0.9999 * fm->afc + 0.0001 * fm->pll.freq.f;
+    CXBreal(fm->obuf, i) =
+      CXBimag(fm->obuf, i) = (fm->pll.freq.f - fm->afc) * fm->cvt;
+  }
+}
+
+FMD
+newFMD(REAL samprate,
+       REAL f_initial,
+       REAL f_lobound,
+       REAL f_hibound,
+       REAL f_bandwid,
+       int size,
+       COMPLEX *ivec,
+       COMPLEX *ovec,
+       char *tag) {
+  FMD fm = (FMD) safealloc(1, sizeof(FMDDesc), tag);
+
+  fm->size = size;
+  fm->ibuf = newCXB(size, ivec, tag);
+  fm->obuf = newCXB(size, ovec, tag);
+
+  init_pll(fm,
+	   samprate,
+	   f_initial,
+	   f_lobound,
+	   f_hibound,
+	   f_bandwid);
+
+  fm->lock = 0.5;
+  fm->afc = 0.0;
+  fm->cvt = 0.45*samprate/(M_PI*f_bandwid);
+
+  return fm;
+}
+
+void
+delFMD(FMD fm) {
+  if (fm) {
+    delCXB(fm->ibuf);
+    delCXB(fm->obuf);
+    safefree((char *) fm);
+  }
+}
diff --git a/jDttSP/fm_demod.h b/jDttSP/fm_demod.h
new file mode 100644
index 0000000..136ba78
--- /dev/null
+++ b/jDttSP/fm_demod.h
@@ -0,0 +1,55 @@
+/* fm_demod.h */
+
+#ifndef _fm_demod_h
+#define _fm_demod_h
+
+#include <fromsys.h>
+#include <banal.h>
+#include <splitfields.h>
+#include <datatypes.h>
+#include <bufvec.h>
+#include <cxops.h>
+#include <fastrig.h>
+#include <update.h>
+#include <lmadf.h>
+#include <fftw.h>
+#include <ovsv.h>
+#include <filter.h>
+#include <oscillator.h>
+#include <chap.h>
+
+typedef
+struct _fm_demod {
+  int size;
+  CXB ibuf, obuf;
+  struct {
+    REAL alpha, beta;
+    struct { REAL f, l, h; } freq;
+    REAL phs;
+    struct { REAL alpha; } iir;
+    COMPLEX delay;
+  } pll;
+
+  REAL lock, afc, cvt;
+} FMDDesc, *FMD;
+
+extern void FMDemod(FMD fm);
+extern FMD newFMD(REAL samprate,
+		  REAL f_initial,
+		  REAL f_lobound,
+		  REAL f_hibound,
+		  REAL f_bandwid,
+		  int size,
+		  COMPLEX *ivec,
+		  COMPLEX *ovec,
+		  char *tag);
+extern void delFMD(FMD fm);
+
+#ifndef TWOPI
+#define TWOPI (2.0*M_PI)
+#endif
+#ifndef CvtMod2Freq
+#define CvtMod2Freq 0.25
+#endif
+
+#endif
diff --git a/jDttSP/fromsys.h b/jDttSP/fromsys.h
new file mode 100644
index 0000000..56e6a8f
--- /dev/null
+++ b/jDttSP/fromsys.h
@@ -0,0 +1,65 @@
+/* fromsys.h
+   stuff we need to import everywhere 
+ This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _fromsys_h
+#define _fromsys_h
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/wait.h>  
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>  
+#include <signal.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <setjmp.h>
+
+#include <stdlib.h>
+#include <values.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <math.h>
+#include <assert.h>
+#include <libgen.h>
+
+#include <pthread.h>
+#include <semaphore.h>
+
+#include <jack/jack.h>
+#include <jack/ringbuffer.h>
+
+#endif
diff --git a/jDttSP/lmadf.c b/jDttSP/lmadf.c
new file mode 100644
index 0000000..c472ec4
--- /dev/null
+++ b/jDttSP/lmadf.c
@@ -0,0 +1,286 @@
+/* lmadf.c 
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <lmadf.h>
+
+#ifdef REALLMS
+
+LMSR 
+new_lmsr(CXB signal,
+	 int delay,
+	 REAL adaptation_rate,
+	 REAL leakage,
+	 int adaptive_filter_size,
+	 int filter_type) {
+  LMSR lms = (LMSR) safealloc(1, sizeof(_lmsstate), "new_lmsr state");
+
+  lms->signal = signal;
+  CXBsize(lms->signal);
+  lms->delay = delay;
+  lms->size = 512;
+  lms->mask = lms->size - 1;
+  lms->delay_line = newvec_REAL(lms->size, "lmsr delay");
+  lms->adaptation_rate = adaptation_rate;
+  lms->leakage = leakage;
+  lms->adaptive_filter_size = adaptive_filter_size;
+  lms->adaptive_filter = newvec_REAL(128, "lmsr filter");
+  lms->filter_type = filter_type;
+  lms->delay_line_ptr = 0;
+
+  return lms;
+}
+
+void
+del_lmsr(LMSR lms) {
+  if (lms) {
+    delvec_REAL(lms->delay_line);
+    delvec_REAL(lms->adaptive_filter);
+    safefree((char *) lms);
+  }
+}
+
+// just to make the algorithm itself a little clearer,
+// get the admin stuff out of the way
+
+#define ssiz (lms->signal_size)
+#define asiz (lms->adaptive_filter_size)
+#define dptr (lms->delay_line_ptr)
+#define rate (lms->adaptation_rate)
+#define leak (lms->leakage)
+
+#define ssig(n) (CXBreal(lms->signal,(n)))
+
+#define dlay(n) (lms->delay_line[(n)])
+
+#define afil(n) (lms->adaptive_filter[(n)])
+#define wrap(n) (((n) + (lms->delay) + (lms->delay_line_ptr)) & (lms->mask))
+#define bump(n) (((n) + (lms->mask)) & (lms->mask))
+
+static void
+lmsr_adapt_i(LMSR lms) {
+  int i, j, k;
+  REAL sum_sq, scl1, scl2;
+  REAL accum, error;
+
+  scl1 = 1.0 - rate * leak;
+
+  for (i = 0; i < ssiz; i++) {
+
+    dlay(dptr) = ssig(i);
+    accum = 0.0;
+    sum_sq = 0.0;
+
+    for (j = 0; j < asiz; j++) {
+      k = wrap(j);
+      sum_sq += sqr(dlay(k));
+      accum += afil(j) * dlay(k);
+    }
+
+    error = ssig(i) - accum;
+    ssig(i) = error;
+
+    scl2 = rate / (sum_sq + 1e-10);
+    error *= scl2;
+    for (j = 0; j < asiz; j++) {
+      k = wrap(j);
+      afil(j) = afil(j) * scl1 + error * dlay(k);
+    }
+
+    dptr = bump(dptr);
+  }
+}
+
+static void
+lmsr_adapt_n(LMSR lms) {
+  int i, j, k;
+  REAL sum_sq, scl1, scl2;
+  REAL accum, error;
+
+  scl1 = 1.0 - rate * leak;
+
+  for (i = 0; i < ssiz; i++) {
+
+    dlay(dptr) = ssig(i);
+    accum = 0.0;
+    sum_sq = 0.0;
+
+    for (j = 0; j < asiz; j++) {
+      k = wrap(j);
+      sum_sq += sqr(dlay(k));
+      accum += afil(j) * dlay(k);
+    }
+
+    error = ssig(i) - accum;
+    ssig(i) = accum;
+
+    scl2 = rate / (sum_sq + 1e-10);
+    error *= scl2;
+    for (j = 0; j < asiz; j++) {
+      k = wrap(j);
+      afil(j) = afil(j) * scl1 + error * dlay(k);
+    }
+
+    dptr = bump(dptr);
+  }
+}
+
+#else
+
+LMSR 
+new_lmsr(CXB signal,
+	 int delay,
+	 REAL adaptation_rate,
+	 REAL leakage,
+	 int adaptive_filter_size,
+	 int filter_type) {
+  LMSR lms = (LMSR) safealloc(1, sizeof(_lmsstate), "new_lmsr state");
+
+  lms->signal = signal;
+  CXBsize(lms->signal);
+  lms->delay = delay;
+  lms->size = 512;
+  lms->mask = lms->size - 1;
+  lms->delay_line = newvec_COMPLEX(lms->size, "lmsr delay");
+  lms->adaptation_rate = adaptation_rate;
+  lms->leakage = leakage;
+  lms->adaptive_filter_size = adaptive_filter_size;
+  lms->adaptive_filter = newvec_COMPLEX(128, "lmsr filter");
+  lms->filter_type = filter_type;
+  lms->delay_line_ptr = 0;
+
+  return lms;
+}
+
+void
+del_lmsr(LMSR lms) {
+  if (lms) {
+    delvec_COMPLEX(lms->delay_line);
+    delvec_COMPLEX(lms->adaptive_filter);
+    safefree((char *) lms);
+  }
+}
+
+// just to make the algorithm itself a little clearer,
+// get the admin stuff out of the way
+
+#define ssiz (lms->signal_size)
+#define asiz (lms->adaptive_filter_size)
+#define dptr (lms->delay_line_ptr)
+#define rate (lms->adaptation_rate)
+#define leak (lms->leakage)
+
+#define ssig(n) (CXBdata(lms->signal,(n)))
+
+#define dlay(n) (lms->delay_line[(n)])
+
+#define afil(n) (lms->adaptive_filter[(n)])
+#define wrap(n) (((n) + (lms->delay) + (lms->delay_line_ptr)) & (lms->mask))
+#define bump(n) (((n) + (lms->mask)) & (lms->mask))
+
+static void
+lmsr_adapt_i(LMSR lms) {
+  int i, j, k;
+  REAL sum_sq, scl1, scl2;
+  COMPLEX accum, error;
+  scl1 = 1.0 - rate * leak;
+  for (i = 0; i < ssiz; i++) {
+
+    dlay(dptr) = ssig(i);
+    accum = cxzero;
+    sum_sq = 0.0;
+
+    for (j = 0; j < asiz; j++) {
+      k = wrap(j);
+      sum_sq += Csqrmag(dlay(k));
+      accum = Cadd(accum, Cmul(Conjg(afil(j)), dlay(k)));
+    }
+
+    error = Csub(ssig(i), accum);
+    ssig(i) = error;
+
+    scl2 = rate / (sum_sq + 1e-10);
+	error = Cscl(Conjg(error),scl2);
+    for (j = 0; j < asiz; j++) {
+      k = wrap(j);
+      afil(j) =	Cadd(Cscl(afil(j), scl1),Cmul(error, dlay(k)));
+    }
+
+    dptr = bump(dptr);
+  }
+}
+
+static void
+lmsr_adapt_n(LMSR lms) {
+  int i, j, k;
+  REAL sum_sq, scl1, scl2;
+  COMPLEX accum, error;
+  scl1 = 1.0 - rate * leak;
+  for (i = 0; i < ssiz; i++) {
+
+    dlay(dptr) = ssig(i);
+    accum = cxzero;
+    sum_sq = 0.0;
+
+    for (j = 0; j < asiz; j++) {
+      k = wrap(j);
+      sum_sq += Csqrmag(dlay(k));
+      accum = Cadd(accum, Cmul(Conjg(afil(j)), dlay(k)));
+    }
+
+    error = Csub(ssig(i), accum);
+    ssig(i) = accum;
+
+    scl2 = rate / (sum_sq + 1e-10);
+	error = Cscl(Conjg(error),scl2);
+    for (j = 0; j < asiz; j++) {
+      k = wrap(j);
+      afil(j) =	Cadd(Cscl(afil(j), scl1),Cmul(error, dlay(k)));
+    }
+
+    dptr = bump(dptr);
+  }
+}
+
+#endif
+
+extern void
+lmsr_adapt(LMSR lms) {
+  switch(lms->filter_type) {
+  case LMADF_NOISE:
+    lmsr_adapt_n(lms);
+    break;        
+  case LMADF_INTERFERENCE:
+   lmsr_adapt_i(lms);
+    break;
+  }
+}  
diff --git a/jDttSP/lmadf.h b/jDttSP/lmadf.h
new file mode 100644
index 0000000..a3566a9
--- /dev/null
+++ b/jDttSP/lmadf.h
@@ -0,0 +1,101 @@
+/* lmadf.h 
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _lmadf_h
+
+#define _lmadf_h
+
+#include <fromsys.h>
+#include <banal.h>
+#include <datatypes.h>
+#include <bufvec.h>
+#include <cxops.h>
+
+#define LMADF_INTERFERENCE 0
+#define LMADF_NOISE 1
+#define LMADF_NOSIG (-1)
+#define LMADF_NOLINE (-2)
+#define LMADF_NOFILT (-3)
+
+extern int lmadf_err;
+
+#define REALLMS
+
+#ifdef REALLMS
+
+typedef struct _LMSR {
+  CXB signal;              /* Signal Buffer */
+  int signal_size;          /* Number of samples in signal buffer */
+  REAL *delay_line;      /* Delay Line circular buffer for holding samples */
+  REAL *adaptive_filter; /* Filter coefficients */
+  REAL adaptation_rate;     /* Adaptation rate for the LMS stochastic gradient */
+  REAL leakage;             /* Exponential decay constant for filter coefficients */
+  int adaptive_filter_size; /* number taps in adaptive filter */
+  int filter_type;          /* Filter type */
+  int delay;                /* Total delay between current sample and filter */
+  int delay_line_ptr;       /* Pointer for next sample into the delay line */
+  int size;		    /* Delay line size */
+  int mask;                 /* Mask for circular buffer */
+} *LMSR, _lmsstate;
+
+#else
+
+typedef struct _LMSR {
+  CXB signal;              /* Signal Buffer */
+  int signal_size;          /* Number of samples in signal buffer */
+  COMPLEX *delay_line;      /* Delay Line circular buffer for holding samples */
+  COMPLEX *adaptive_filter; /* Filter coefficients */
+  REAL adaptation_rate;     /* Adaptation rate for the LMS stochastic gradient */
+  REAL leakage;             /* Exponential decay constant for filter coefficients */
+  int adaptive_filter_size; /* number taps in adaptive filter */
+  int filter_type;          /* Filter type */
+  int delay;                /* Total delay between current sample and filter */
+  int delay_line_ptr;       /* Pointer for next sample into the delay line */
+  int size;		    /* Delay line size */
+  int mask;                 /* Mask for circular buffer */
+} *LMSR, _lmsstate;
+
+#endif
+
+extern LMSR new_lmsr(CXB signal,
+			  int delay,
+			  REAL adaptation_rate,
+			  REAL leakage,
+			  int adaptive_filter_size,
+			  int filter_type);
+
+extern void del_lmsr(LMSR lms);
+
+extern void lmsr_adapt(LMSR lms);
+
+#endif
diff --git a/jDttSP/local.h b/jDttSP/local.h
new file mode 100644
index 0000000..942fc2b
--- /dev/null
+++ b/jDttSP/local.h
@@ -0,0 +1,77 @@
+/* local.h
+
+Some manifest constants for the particular implementation
+   
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+/* #include <fromsys.h> */
+/* #include <datatypes.h> */
+/* #include <banal.h> */
+/* #include <fftw.h> */
+/* #include <sdrexport.h> */
+
+#include <common.h>
+
+#ifndef _local_h
+#define _local_h
+
+#define RCBASE ".DttSPrc"
+#define PARMPATH "./IPC/SDR-1000-0-commands.fifo"
+#define METERPATH "./IPC/SDR-1000-0-meter.chan"
+#define WISDOMPATH "./wisdom"
+#define RINGMULT (4)
+#define METERMULT (2)
+#define DEFRATE (48000.0)
+#define DEFSIZE (2048)
+#define DEFMODE (SAM)
+
+#ifndef MAXPATHLEN
+#define MAXPATHLEN 2048
+#endif  
+
+extern struct _loc {
+  char name[MAXPATHLEN];
+  struct {
+    char rcfile[MAXPATHLEN],
+         parm[MAXPATHLEN],
+         meter[MAXPATHLEN],
+         wisdom[MAXPATHLEN];
+  } path;
+  struct {
+    REAL rate;
+    int size;
+    SDRMODE mode;
+  } def;
+  struct { int ring, meter; } mult;
+} loc;
+
+#endif
diff --git a/jDttSP/main.c b/jDttSP/main.c
new file mode 100644
index 0000000..a4611e3
--- /dev/null
+++ b/jDttSP/main.c
@@ -0,0 +1,528 @@
+/* main.c
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/  
+  
+#include <common.h>
+  
+/////////////////////////////////////////////////////////////////////////
+// elementary defaults
+
+struct _loc loc;  
+
+/////////////////////////////////////////////////////////////////////////
+// most of what little we know here about the inner loop,
+// functionally speaking
+
+extern void process_samples(float *, float *, int);
+extern void setup_workspace(void);
+extern void destroy_workspace(void);
+
+//========================================================================
+
+PRIVATE void
+monitor_thread(void) {
+  while (top.running) {
+    sem_wait(&top.sync.mon.sem);
+    fprintf(stderr,
+	    "@@@ mon [%d]: cb = %d rbi = %d rbo = %d xr = %d\n",
+	    uni.tick,
+	    top.jack.blow.cb,
+	    top.jack.blow.rb.i,
+	    top.jack.blow.rb.o,
+	    top.jack.blow.xr);
+    memset((char *) &top.jack.blow, 0, sizeof(top.jack.blow));
+  }
+  pthread_exit(0);
+}
+
+//========================================================================
+
+PRIVATE void 
+process_updates_thread(void) {
+  while (top.running) {
+    pthread_testcancel();
+    while (fgets(top.parm.buff, sizeof(top.parm.buff), top.parm.fp))
+      do_update(top.parm.buff, top.verbose ? stderr : 0);
+  }
+  pthread_exit(0);
+}
+
+PRIVATE void 
+gethold(void) {
+  if (jack_ringbuffer_write_space(top.jack.ring.o.l)
+      < top.hold.size.bytes) {
+    // pathology
+    jack_ringbuffer_reset(top.jack.ring.o.l);
+    jack_ringbuffer_reset(top.jack.ring.o.r);
+    top.jack.blow.rb.o++;
+  }
+  jack_ringbuffer_write(top.jack.ring.o.l,
+			(char *) top.hold.buf.l,
+			top.hold.size.bytes);
+  jack_ringbuffer_write(top.jack.ring.o.r,
+			(char *) top.hold.buf.r,
+			top.hold.size.bytes);
+  if (jack_ringbuffer_read_space(top.jack.ring.i.l)
+      < top.hold.size.bytes) {
+    // pathology
+    jack_ringbuffer_reset(top.jack.ring.i.l);
+    jack_ringbuffer_reset(top.jack.ring.i.r);
+    memset((char *) top.hold.buf.l, 0, top.hold.size.bytes);
+    memset((char *) top.hold.buf.r, 0, top.hold.size.bytes);
+    top.jack.blow.rb.i++;
+  } else {
+    jack_ringbuffer_read(top.jack.ring.i.l,
+			 (char *) top.hold.buf.l,
+			 top.hold.size.bytes);
+    jack_ringbuffer_read(top.jack.ring.i.r,
+			 (char *) top.hold.buf.r,
+			 top.hold.size.bytes);
+  }
+}
+
+PRIVATE BOOLEAN
+canhold(void) {
+  return
+    jack_ringbuffer_read_space(top.jack.ring.i.l)
+    >= top.hold.size.bytes;
+}
+
+PRIVATE void 
+run_mute(void) {
+  memset((char *) top.hold.buf.l, 0, top.hold.size.bytes);
+  memset((char *) top.hold.buf.r, 0, top.hold.size.bytes);
+  uni.tick++;
+}
+
+PRIVATE void 
+run_pass(void) { uni.tick++; }
+
+PRIVATE void 
+run_play(void) {
+  process_samples(top.hold.buf.l, top.hold.buf.r, top.hold.size.frames);
+} 
+
+// NB do not set RUN_SWCH directly via setRunState;
+// use setSWCH instead
+
+PRIVATE void 
+run_swch(void) {
+  if (top.swch.bfct.have == 0) {
+    // first time
+    // apply ramp down
+    int i, m = top.swch.fade, n = top.swch.tail;
+    for (i = 0; i < m; i++) {
+      float w = (float) 1.0 - (float) i / m;
+      top.hold.buf.l[i] *= w, top.hold.buf.r[i] *= w;
+    }
+    memset((char *) (top.hold.buf.l + m), 0, n);
+    memset((char *) (top.hold.buf.r + m), 0, n);
+    top.swch.bfct.have++;
+  } else if (top.swch.bfct.have < top.swch.bfct.want) {
+    // in medias res
+    memset((char *) top.hold.buf.l, 0, top.hold.size.bytes);
+    memset((char *) top.hold.buf.r, 0, top.hold.size.bytes);
+    top.swch.bfct.have++;
+  } else {
+    // last time
+    // apply ramp up
+    int i, m = top.swch.fade, n = top.swch.tail;
+    for (i = 0; i < m; i++) {
+      float w = (float) i / m;
+      top.hold.buf.l[i] *= w, top.hold.buf.r[i] *= w;
+    }
+    uni.mode.trx = top.swch.trx.next;
+    rx.tick = tx.tick = 0;
+    top.state = top.swch.run.last;
+    top.swch.bfct.want = top.swch.bfct.have = 0;
+  }
+
+  process_samples(top.hold.buf.l, top.hold.buf.r, top.hold.size.frames);
+} 
+
+//========================================================================
+
+void
+clear_jack_ringbuffer(jack_ringbuffer_t *rb, int nbytes) {
+  int i;
+  char zero = 0;
+  for (i = 0; i < nbytes; i++)
+    jack_ringbuffer_write(rb, &zero, 1);
+}
+
+PRIVATE void 
+audio_callback(jack_nframes_t nframes, void *arg) {
+  float *lp, *rp;
+  int nbytes = nframes * sizeof(float);
+
+  if (nframes == top.jack.size) {
+
+    // output: copy from ring to port
+    lp = (float *) jack_port_get_buffer(top.jack.port.o.l, nframes);
+    rp = (float *) jack_port_get_buffer(top.jack.port.o.r, nframes);
+
+    if (jack_ringbuffer_read_space(top.jack.ring.o.l) >= nbytes) {
+      jack_ringbuffer_read(top.jack.ring.o.l, (char *) lp, nbytes);
+      jack_ringbuffer_read(top.jack.ring.o.r, (char *) rp, nbytes);
+    } else { // rb pathology
+      memset((char *) lp, 0, nbytes);
+      memset((char *) rp, 0, nbytes);
+      jack_ringbuffer_reset(top.jack.ring.o.l);
+      jack_ringbuffer_reset(top.jack.ring.o.r);
+      clear_jack_ringbuffer(top.jack.ring.o.l, nbytes);
+      clear_jack_ringbuffer(top.jack.ring.o.r, nbytes);
+      top.jack.blow.rb.o++;
+    }
+    
+    // input: copy from port to ring
+    if (jack_ringbuffer_write_space(top.jack.ring.i.l) >= nbytes) {
+      lp = (float *) jack_port_get_buffer(top.jack.port.i.l, nframes);
+      rp = (float *) jack_port_get_buffer(top.jack.port.i.r, nframes);
+      jack_ringbuffer_write(top.jack.ring.i.l, (char *) lp, nbytes);
+      jack_ringbuffer_write(top.jack.ring.i.r, (char *) rp, nbytes);
+    } else { // rb pathology
+      jack_ringbuffer_reset(top.jack.ring.i.l);
+      jack_ringbuffer_reset(top.jack.ring.i.r);
+      clear_jack_ringbuffer(top.jack.ring.i.l, nbytes);
+      clear_jack_ringbuffer(top.jack.ring.i.r, nbytes);
+      top.jack.blow.rb.i++;
+    }
+
+  } else { // callback pathology
+    jack_ringbuffer_reset(top.jack.ring.i.l);
+    jack_ringbuffer_reset(top.jack.ring.i.r);
+    jack_ringbuffer_reset(top.jack.ring.o.l);
+    jack_ringbuffer_reset(top.jack.ring.o.r);
+    clear_jack_ringbuffer(top.jack.ring.o.l, top.hold.size.bytes);
+    clear_jack_ringbuffer(top.jack.ring.o.r, top.hold.size.bytes);
+    top.jack.blow.cb++;
+  }
+
+  // if enough accumulated in ring, fire dsp
+  if (jack_ringbuffer_read_space(top.jack.ring.i.l) >= top.hold.size.bytes)
+    sem_post(&top.sync.buf.sem);
+
+  // check for blowups
+  if ((top.jack.blow.cb > 0) ||
+      (top.jack.blow.rb.i > 0) ||
+      (top.jack.blow.rb.o > 0))
+    sem_post(&top.sync.mon.sem);
+}
+
+PRIVATE void 
+process_samples_thread(void) {
+  while (top.running) {
+    sem_wait(&top.sync.buf.sem);
+    do {
+      gethold();
+      sem_wait(&top.sync.upd.sem);
+      switch (top.state) {
+      case RUN_MUTE: run_mute(); break;
+      case RUN_PASS: run_pass(); break;
+      case RUN_PLAY: run_play(); break;
+      case RUN_SWCH: run_swch(); break;
+      }
+      sem_post(&top.sync.upd.sem);
+    } while (canhold());
+  }
+  pthread_exit(0);
+}
+
+//========================================================================
+
+PRIVATE void 
+execute(void) {
+  // let updates run
+  sem_post(&top.sync.upd.sem);
+  
+  // rcfile
+  {
+    FILE *frc = find_rcfile(loc.path.rcfile);
+    if (frc) {
+      while (fgets(top.parm.buff, sizeof(top.parm.buff), frc))
+	do_update(top.parm.buff, top.verbose ? stderr : 0);
+      fclose(frc);
+    }
+  }
+
+  // start audio processing
+  if (jack_activate(top.jack.client))
+    perror("cannot activate jack client"), exit(1);
+  
+  // wait for threads to terminate
+  pthread_join(top.thrd.trx.id, 0);
+  pthread_join(top.thrd.upd.id, 0);
+  pthread_join(top.thrd.mon.id, 0);
+  
+  // stop audio processing
+  jack_client_close(top.jack.client);
+}
+
+PRIVATE void 
+closeup(void) {
+  jack_ringbuffer_free(top.jack.ring.o.r);
+  jack_ringbuffer_free(top.jack.ring.o.l);
+  jack_ringbuffer_free(top.jack.ring.i.r);
+  jack_ringbuffer_free(top.jack.ring.i.l);
+
+  safefree((char *) top.hold.buf.r);
+  safefree((char *) top.hold.buf.l);
+
+  destroy_workspace();
+
+  exit(0);
+}
+
+PRIVATE void 
+usage(void) {
+  fprintf(stderr, "usage:\n");
+  fprintf(stderr, "jsdr [-flag [arg]] [file]\n");
+  fprintf(stderr, "flags:\n");
+  fprintf(stderr, "	-v		verbose commentary\n");
+  fprintf(stderr, "	-m		do metering\n");
+  fprintf(stderr, "	-l file		execute update commands in file at startup\n");
+  fprintf(stderr, "	-P cmdpath	path to command/update pipe\n");
+  fprintf(stderr, "	-S s-mtrpath	path to S-meter output channel\n");
+  fprintf(stderr, "	-W wispath	path to FFTW wisdom file\n");
+  fprintf(stderr, "	-R rate		sampling rate\n");
+  fprintf(stderr, "	-B bufsize	internal DSP buffer size\n");
+  fprintf(stderr, "	-M mode		start up in mode (SAM, USB, LCW, etc.)\n");
+  fprintf(stderr, "	-G num		use num as ringbuffer mult\n");
+  fprintf(stderr, "	-E num		use num as meter chan mult\n");
+  fprintf(stderr, "'file' arg unused, but available\n");
+  exit(1);
+}
+
+PRIVATE void 
+nonblock(int fd) {
+  long arg;
+  arg = fcntl(fd, F_GETFL);
+  arg |= O_NONBLOCK;
+/*  if (fcntl(fd, F_GETFL, &arg) >= 0)
+    fcntl(fd, F_SETFL, arg | O_NONBLOCK); */ 
+  fcntl(fd, F_SETFL, arg);
+} 
+
+//........................................................................
+
+PRIVATE void 
+setup_switching(void) {
+  top.swch.fade = (int) (0.1 * uni.buflen + 0.5);
+  top.swch.tail = (top.hold.size.frames - top.swch.fade) * sizeof(float);
+}
+
+PRIVATE void 
+setup_local_audio(void) {
+  top.hold.size.frames = uni.buflen;
+  top.hold.size.bytes = top.hold.size.frames * sizeof(float);
+  top.hold.buf.l = (float *) safealloc(top.hold.size.frames, sizeof(float),
+				       "main hold buffer left");
+  top.hold.buf.r = (float *) safealloc(top.hold.size.frames, sizeof(float),
+				       "main hold buffer right");
+} 
+
+PRIVATE void 
+setup_updates(void) {
+  top.parm.path = loc.path.parm;
+  if ((top.parm.fd = open(top.parm.path, O_RDWR)) == -1)
+    perror(top.parm.path), exit(1);
+  if (!(top.parm.fp = fdopen(top.parm.fd, "r+"))) {
+    fprintf(stderr, "can't fdopen parm pipe %s\n", loc.path.parm);
+    exit(1);
+  }
+}
+
+PRIVATE void
+jack_xrun(void *arg) {
+  top.jack.blow.xr++;
+  sem_post(&top.sync.mon.sem);
+}
+
+PRIVATE void
+jack_shutdown(void *arg) {}
+
+PRIVATE void 
+setup_system_audio(void) {
+  if (loc.name[0]) strcpy(top.jack.name, loc.name);
+  else sprintf(top.jack.name, "sdr-%d", top.pid);
+  if (!(top.jack.client = jack_client_new(top.jack.name)))
+    perror("can't make client -- jack not running?"), exit(1);
+
+  jack_set_process_callback(top.jack.client, (void *) audio_callback, 0);
+  jack_on_shutdown(top.jack.client, (void *) jack_shutdown, 0);
+  jack_set_xrun_callback(top.jack.client, (void *) jack_xrun, 0);
+  top.jack.size = jack_get_buffer_size(top.jack.client);
+  memset((char *) &top.jack.blow, 0, sizeof(top.jack.blow));
+
+  top.jack.port.i.l = jack_port_register(top.jack.client,
+					 "il",
+					 JACK_DEFAULT_AUDIO_TYPE,
+					 JackPortIsInput,
+					 0);
+  top.jack.port.i.r = jack_port_register(top.jack.client,
+					 "ir",
+					 JACK_DEFAULT_AUDIO_TYPE,
+					 JackPortIsInput,
+					 0);
+  top.jack.port.o.l = jack_port_register(top.jack.client,
+					 "ol",
+					 JACK_DEFAULT_AUDIO_TYPE,
+					 JackPortIsOutput,
+					 0);
+  top.jack.port.o.r = jack_port_register(top.jack.client,
+					 "or",
+					 JACK_DEFAULT_AUDIO_TYPE,
+					 JackPortIsOutput,
+					 0);
+  top.jack.ring.i.l = jack_ringbuffer_create(top.hold.size.bytes * loc.mult.ring);
+  top.jack.ring.i.r = jack_ringbuffer_create(top.hold.size.bytes * loc.mult.ring);
+  top.jack.ring.o.l = jack_ringbuffer_create(top.hold.size.bytes * loc.mult.ring);
+  top.jack.ring.o.r = jack_ringbuffer_create(top.hold.size.bytes * loc.mult.ring);
+  clear_jack_ringbuffer(top.jack.ring.o.l, top.hold.size.bytes);
+  clear_jack_ringbuffer(top.jack.ring.o.r, top.hold.size.bytes);
+}
+
+PRIVATE void 
+setup_threading(void) {
+  sem_init(&top.sync.upd.sem, 0, 0);
+  pthread_create(&top.thrd.upd.id, NULL, (void *) process_updates_thread, NULL);
+  sem_init(&top.sync.buf.sem, 0, 0);
+  pthread_create(&top.thrd.trx.id, NULL, (void *) process_samples_thread, NULL);
+  sem_init(&top.sync.mon.sem, 0, 0);
+  pthread_create(&top.thrd.mon.id, NULL, (void *) monitor_thread, NULL);
+} 
+
+//========================================================================
+// hard defaults, then environment
+
+PRIVATE void
+setup_defaults(void) {
+  loc.name[0] = 0; // no default name for jack client
+  strcpy(loc.path.rcfile, RCBASE);
+  strcpy(loc.path.parm, PARMPATH);
+  strcpy(loc.path.meter, METERPATH);
+  strcpy(loc.path.wisdom, WISDOMPATH);
+  loc.def.rate = DEFRATE;
+  loc.def.size = DEFSIZE;
+  loc.def.mode = DEFMODE;
+  loc.mult.ring = RINGMULT;
+  loc.mult.meter = METERMULT;
+
+  {
+    char *ep;
+    if ((ep = getenv("SDR_NAME"))) strcpy(loc.name, ep);
+    if ((ep = getenv("SDR_RCBASE"))) strcpy(loc.path.rcfile, ep);
+    if ((ep = getenv("SDR_PARMPATH"))) strcpy(loc.path.parm, ep);
+    if ((ep = getenv("SDR_METERPATH"))) strcpy(loc.path.meter, ep);
+    if ((ep = getenv("SDR_WISDOMPATH"))) strcpy(loc.path.wisdom, ep);
+    if ((ep = getenv("SDR_RINGMULT"))) loc.mult.ring = atoi(ep);
+    if ((ep = getenv("SDR_METERMULT"))) loc.mult.meter = atoi(ep);
+    if ((ep = getenv("SDR_DEFRATE"))) loc.def.rate = atof(ep);
+    if ((ep = getenv("SDR_DEFSIZE"))) loc.def.size = atoi(ep);
+    if ((ep = getenv("SDR_DEFMODE"))) loc.def.mode = atoi(ep);
+  }
+}
+
+//========================================================================
+PRIVATE void 
+setup(int argc, char **argv) {
+  int i;
+
+  top.uid = getuid();
+  top.pid = getpid();
+  top.start_tv = now_tv();
+  top.running = TRUE;
+  top.verbose = FALSE;
+  top.state = RUN_PLAY;
+
+  setup_defaults();
+  
+  for (i = 1; i < argc; i++)
+    if (argv[i][0] == '-')
+      switch (argv[i][1]) {
+      case 'v':
+	top.verbose = TRUE;
+	break;
+      case 'l':
+	strcpy(loc.path.rcfile, argv[++i]);
+	break;
+      case 'm':
+	uni.meter.flag = TRUE;
+	break;
+      case 'P':
+	strcpy(loc.path.parm, argv[++i]);
+	break;
+      case 'S':
+	strcpy(loc.path.meter, argv[++i]);
+	break;
+      case 'W':
+	strcpy(loc.path.wisdom, argv[++i]);
+	break;
+      case 'R':
+	loc.def.rate = atof(argv[++i]);
+	break;
+      case 'B':
+	loc.def.size = atoi(argv[++i]);
+	break;
+      case 'M':
+	loc.def.mode = atoi(argv[++i]);
+	break;
+      case 'G':
+	loc.mult.ring = atoi(argv[++i]);
+	break;
+      case 'E':
+	loc.mult.meter = atoi(argv[++i]);
+	break;
+      default:
+	usage();
+      }
+    else break;
+  if (i < argc) {
+    if (!freopen(argv[i], "r", stdin))
+      perror(argv[i]), exit(1);
+    i++;
+  }
+
+  setup_workspace();
+  setup_updates();
+
+  setup_local_audio();
+  setup_system_audio();
+
+  setup_threading();
+  setup_switching();
+}
+
+//========================================================================
+
+int 
+main(int argc, char **argv) { setup(argc, argv), execute(), closeup(); } 
diff --git a/jDttSP/meter.h b/jDttSP/meter.h
new file mode 100644
index 0000000..57e7b71
--- /dev/null
+++ b/jDttSP/meter.h
@@ -0,0 +1,12 @@
+#ifndef _meter_h
+#define _meter_h
+
+typedef enum {
+  SIGNAL_STRENGTH, 
+  AVG_SIGNAL_STRENGTH, 
+  ADC_REAL, 
+  ADC_IMAG,
+  AGC_GAIN
+} METERTYPE;
+
+#endif
diff --git a/jDttSP/metermon.c b/jDttSP/metermon.c
new file mode 100644
index 0000000..1bd875b
--- /dev/null
+++ b/jDttSP/metermon.c
@@ -0,0 +1,44 @@
+/* metermon.c */
+
+#include <chan.h>
+
+#define METERPATH "./IPC/SDR-1000-0-meter.chan"
+#define METERMULT (24)
+#define SLEEP (500000)
+
+jmp_buf here;
+
+void
+onsig(int sig) {
+  signal(SIGHUP, SIG_IGN);
+  signal(SIGINT, SIG_IGN);
+  signal(SIGQUIT, SIG_IGN);
+  longjmp(here, TRUE);
+}
+
+int
+main(int argc, char **argv) {
+  Chan ch = 0;
+  int i = 0;
+  REAL val = 0.0;
+
+  signal(SIGHUP, onsig);
+  signal(SIGINT, onsig);
+  signal(SIGQUIT, onsig);
+
+  if (!(ch = openChan(METERPATH, METERMULT * sizeof(REAL))))
+    perror("openChan"), exit(1);
+
+  while (!setjmp(here)) {
+    if (getChan_nowait(ch, (char *) &val, sizeof(REAL))) {
+      printf("(%d)", i++);
+      do
+	printf(" %f", val);
+      while (getChan_nowait(ch, (char *) &val, sizeof(REAL)));
+      putchar('\n');
+    }
+    usleep(SLEEP);
+  }
+
+  closeChan(ch);
+}
diff --git a/jDttSP/mkchan.c b/jDttSP/mkchan.c
new file mode 100644
index 0000000..2855980
--- /dev/null
+++ b/jDttSP/mkchan.c
@@ -0,0 +1,84 @@
+/* mkchan.c */
+/* create a file big enough to accommodate
+   a header + a ringbuffer of a given size */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <stdlib.h>
+#include <values.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <math.h>
+#include <assert.h>
+#include <libgen.h>
+
+#include <datatypes.h>
+#include <banal.h>
+#include <ringb.h>
+
+char *rng_name = 0,
+     *buf_asks = 0;
+FILE *rng_file = 0;
+size_t rng_size = 0,
+       buf_size = 0,
+       blk_size = 0,
+       tot_size = 0;
+
+BOOLEAN verbose = FALSE;
+
+void
+execute(void) {
+  int i;
+  rng_size = sizeof(ringb_t);
+  if ((buf_size = atoi(buf_asks)) <= 0) {
+    fprintf(stderr, "buffer size %s?\n", buf_asks);
+    exit(1);
+  }
+  if (!(rng_file = fopen(rng_name, "w"))) {
+    perror(rng_name);
+    exit(1);
+  }
+  blk_size = nblock2(buf_size);
+  tot_size = rng_size + blk_size;
+  for (i = 0; i < tot_size; i++) putc(0, rng_file);
+  fclose(rng_file);
+  if (verbose)
+    fprintf(stderr,
+	    "created chan file %s (%d + [%d -> %d] = %d)\n",
+	    rng_name, rng_size, buf_size, blk_size, tot_size);
+}
+
+void
+closeup(void) { exit(0); }
+
+static void
+usage(void) {
+  fprintf(stderr, "usage:\n");
+  fprintf(stderr, "mkchan [-v] name size\n");
+  exit(1);
+}
+
+static void
+setup(int argc, char **argv) {
+  int i;
+
+  for (i = 1; i < argc; i++)
+    if (argv[i][0] == '-')
+      switch (argv[i][1]) {
+      case 'v': verbose = TRUE; break;
+      default: usage();
+      }
+    else break;
+  if (i < (argc - 2)) usage();
+  rng_name = argv[i++];
+  buf_asks = argv[i++];
+}
+
+int
+main(int argc, char **argv) { setup(argc, argv), execute(), closeup(); }
diff --git a/jDttSP/noiseblanker.c b/jDttSP/noiseblanker.c
new file mode 100644
index 0000000..406ebaa
--- /dev/null
+++ b/jDttSP/noiseblanker.c
@@ -0,0 +1,72 @@
+/* noiseblanker.c
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <common.h>
+
+NB
+new_noiseblanker(CXB sigbuf, REAL threshold) {
+  NB nb = (NB) safealloc(1, sizeof(nbstate), "new nbstate");
+  nb->sigbuf = sigbuf;
+  nb->threshold = threshold;
+  nb->average_mag = 1.0;
+  return nb;
+}
+
+void
+del_nb(NB nb) {
+  if (nb) { safefree((char *) nb); }
+}
+
+void
+noiseblanker(NB nb) {
+  int i;
+  for (i = 0; i < CXBsize(nb->sigbuf); i++) {
+    REAL cmag = Cmag(CXBdata(nb->sigbuf, i));
+    nb->average_mag = 0.999 * (nb->average_mag) + 0.001 * cmag;
+    if (cmag > (nb->threshold * nb->average_mag))
+      CXBdata(nb->sigbuf, i) = Cmplx(0.0, 0.0);
+  }
+}
+
+void
+SDROMnoiseblanker(NB nb) {
+  int i;
+  for (i = 0; i < CXBsize(nb->sigbuf); i++) {
+    REAL cmag = Cmag(CXBdata(nb->sigbuf, i));
+    nb->average_sig = Cadd(Cscl(nb->average_sig, 0.75),
+			   Cscl(CXBdata(nb->sigbuf, i), 0.25));
+    nb->average_mag = 0.999 * (nb->average_mag) + 0.001 * cmag;
+    if (cmag > (nb->threshold * nb->average_mag))
+      CXBdata(nb->sigbuf, i) = nb->average_sig;
+  }
+}
diff --git a/jDttSP/noiseblanker.h b/jDttSP/noiseblanker.h
new file mode 100644
index 0000000..8270ed2
--- /dev/null
+++ b/jDttSP/noiseblanker.h
@@ -0,0 +1,51 @@
+/* update.h
+   
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _noiseblanker_h
+#define _noiseblanker_h
+
+#include <cxops.h>
+#include <bufvec.h>
+
+typedef struct _nbstate {
+  CXB sigbuf;			/* Signal Buffer */
+  REAL threshold;		/* Noise Blanker Threshold */
+  COMPLEX average_sig;
+  REAL average_mag;
+} *NB, nbstate;
+
+extern NB new_noiseblanker(CXB sigbuf, REAL threshold);
+extern void del_nb(NB nb);
+extern void noiseblanker(NB nb);
+extern void SDROMnoiseblanker(NB nb);
+#endif
diff --git a/jDttSP/oscillator.c b/jDttSP/oscillator.c
new file mode 100644
index 0000000..04c0b03
--- /dev/null
+++ b/jDttSP/oscillator.c
@@ -0,0 +1,117 @@
+/* oscillator.c 
+
+This routine implements a common fixed-frequency oscillator
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <common.h>
+
+#define HUGE_PHASE 1256637061.43593
+
+void
+ComplexOSC(OSC p) {
+  int i;
+  COMPLEX z, delta_z;
+
+  if (OSCphase(p) > HUGE_PHASE) OSCphase(p) -= HUGE_PHASE;
+
+  z = Cmplx(cos(OSCphase(p)), sin(OSCphase(p))),
+  delta_z = Cmplx(cos(OSCfreq(p)), sin(OSCfreq(p)));	
+
+  for (i = 0; i < OSCsize(p); i++)
+    z = CXBdata((CXB) OSCbase(p), i)
+      = Cmul(z, delta_z),
+    OSCphase(p) += OSCfreq(p);
+}
+
+#ifdef notdef
+void
+ComplexOSC(OSC p) {
+  int i;
+  if (OSCphase(p) > 1256637061.43593)
+    OSCphase(p) -= 1256637061.43593;
+  for (i = 0; i < OSCsize(p); i++) {
+    OSCreal(p, i) = cos(OSCphase(p));
+    OSCimag(p, i) = sin(OSCphase(p));
+    OSCphase(p) += OSCfreq(p);
+  }
+}
+#endif
+
+PRIVATE REAL
+_phasemod(REAL angle) {
+  while (angle >= TWOPI) angle -= TWOPI;
+  while (angle < 0.0) angle += TWOPI;
+  return angle;
+}
+
+void
+RealOSC(OSC p) {
+  int i;
+  for (i = 0; i < OSCsize(p); i++) {
+    OSCRdata(p, i) = sin(OSCphase(p));
+    OSCphase(p) = _phasemod(OSCfreq(p) + OSCphase(p));
+  }
+}
+
+OSC
+newOSC(int size,
+       OscType TypeOsc,
+       REAL Frequency,
+       REAL Phase,
+       REAL SampleRate,
+       char *tag) {
+  OSC p = (OSC) safealloc(1, sizeof(oscillator), tag);
+  if ((OSCtype(p) = TypeOsc) == ComplexTone)
+    OSCbase(p) = (void *) newCXB(size,
+				 NULL,
+				 "complex buffer for oscillator output");
+  else
+    OSCbase(p) = (void *) newRLB(size,
+				 NULL,
+				 "real buffer for oscillator output");
+  OSCsize(p) = size;
+  OSCfreq(p) = 2.0 * M_PI * Frequency / SampleRate;
+  OSCphase(p) = Phase;
+  return p;
+}
+
+void
+delOSC(OSC p) {
+  if (p->OscillatorType == ComplexTone)
+    delCXB((CXB) p->signalpoints);
+  else
+    delRLB((RLB) p->signalpoints);
+  if (p)
+    safefree((char *) p);
+}
+
diff --git a/jDttSP/oscillator.h b/jDttSP/oscillator.h
new file mode 100644
index 0000000..7f45233
--- /dev/null
+++ b/jDttSP/oscillator.h
@@ -0,0 +1,72 @@
+/* oscillator.h
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+
+#ifndef _oscillator_h
+#define _oscillator_h
+
+#define ComplexTone 1
+#define RealTone 0
+typedef int OscType;
+
+typedef struct _oscillator {
+  int size;
+  void *signalpoints;
+  REAL Phase;
+  REAL Frequency;
+  OscType OscillatorType;
+} oscillator, *OSC;
+
+
+#define OSCbase(p)     ((p)->signalpoints)
+#define OSCCbase(p)    (CXBbase((CXB)((p)->signalpoints)))
+#define OSCCdata(p, i) (CXBbase((CXB)((p)->signalpoints))[(i)])
+#define OSCreal(p, i)  (CXBbase((CXB)((p)->signalpoints))[(i)].re)
+#define OSCimag(p, i)  (CXBbase((CXB)((p)->signalpoints))[(i)].im)
+
+#define OSCRbase(p)    (RLBbase((RLB)((p)->signalpoints)))
+#define OSCRdata(p, i) (RLBbase((RLB)((p)->signalpoints))[(i)])
+
+#define OSCsize(p)     ((p)->size)
+#define OSCphase(p)    ((p)->Phase)
+#define OSCfreq(p)     ((p)->Frequency)
+#define OSCtype(p)     ((p)->OscillatorType)
+
+extern void ComplexOSC(OSC);
+extern void RealOSC(OSC);
+extern OSC newOSC(int size, OscType TypeOsc, REAL Frequency, REAL Phase,
+		  REAL SampleRate, char *tag);
+extern void delOSC(OSC);
+extern void fixOSC(OSC p, REAL Frequency, REAL Phase, REAL SampleRate);
+
+#endif
diff --git a/jDttSP/ovsv.c b/jDttSP/ovsv.c
new file mode 100644
index 0000000..3575ff4
--- /dev/null
+++ b/jDttSP/ovsv.c
@@ -0,0 +1,220 @@
+/* ovsv.c
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <common.h>
+
+/*------------------------------------------------------------*/
+/* run the filter */
+
+void
+filter_OvSv(FiltOvSv pflt) {
+  int i,
+      j,
+      m = pflt->fftlen,
+      n = pflt->buflen;
+  COMPLEX *zfvec = pflt->zfvec,
+          *zivec = pflt->zivec,
+          *zovec = pflt->zovec,
+          *zrvec = pflt->zrvec;
+  REAL scl = pflt->scale;
+
+  /* input sig -> z */
+  fftw_one(pflt->pfwd, (fftw_complex *) zrvec, (fftw_complex *) zivec);
+
+  /* convolve in z */
+  for (i = 0; i < m; i++) zivec[i] = Cmul(zivec[i], zfvec[i]);
+
+  /* z convolved sig -> time output sig */
+  fftw_one(pflt->pinv, (fftw_complex *) zivec, (fftw_complex *) zovec);
+
+  /* scale */
+  for (i = 0; i < n; i++) zovec[i].re *= scl, zovec[i].im *= scl;
+
+  /* prepare input sig vec for next fill */
+  for (i = 0, j = n; i < n; i++, j++) zrvec[i] = zrvec[j];
+}
+
+void 
+filter_OvSv_par(FiltOvSv pflt) {
+  int i,
+      j,
+      m = pflt->fftlen,
+      n = pflt->buflen;
+  COMPLEX *zfvec = pflt->zfvec,
+          *zivec = pflt->zivec,
+          *zovec = pflt->zovec,
+          *zrvec = pflt->zrvec;
+  REAL scl = pflt->scale;
+
+  /* input sig -> z */
+  fftw_one(pflt->pfwd,(fftw_complex *) zrvec, (fftw_complex *) zivec);
+
+  /* convolve in z */
+  for (i = 0; i < m; i++) zivec[i] = Cmul(zivec[i], zfvec[i]);
+
+  /* z convolved sig -> time output sig */
+  fftw_one(pflt->pinv, (fftw_complex *) zivec, (fftw_complex *) zovec);
+
+  /* scale */
+  for (i = 0; i < n; i++) zovec[i].re *= scl, zovec[i].im *= scl;
+
+  /* prepare input sig vec for next fill */
+  for (i = 0, j = n; i < n; i++, j++) zrvec[i] = zrvec[j];
+}
+
+/*------------------------------------------------------------*/
+/* info: */
+/* NB strategy. This is the address we pass to newCXB as
+   the place to read samples into. It's the right half of
+   the true buffer. Old samples get slid from here to
+   left half after each go-around. */
+COMPLEX *
+FiltOvSv_initpoint(FiltOvSv pflt) { return &(pflt->zrvec[pflt->buflen]); }
+
+/* how many to put there */
+int
+FiltOvSv_initsize(FiltOvSv pflt) { return (pflt->fftlen - pflt->buflen); }
+
+/* where to put next batch of samples to filter */
+COMPLEX *
+FiltOvSv_fetchpoint(FiltOvSv pflt) { return &(pflt->zrvec[pflt->buflen]); }
+
+/* how many samples to put there */
+
+int
+FiltOvSv_fetchsize(FiltOvSv pflt) { return (pflt->fftlen - pflt->buflen); }
+
+/* where samples should be taken from after filtering */
+#ifdef LHS
+COMPLEX *
+FiltOvSv_storepoint(FiltOvSv plft) { return ((pflt->zovec) + buflen); }
+#else
+COMPLEX *
+FiltOvSv_storepoint(FiltOvSv pflt) { return ((pflt->zovec)); }
+#endif
+
+/* alternating parity fetch/store */
+
+COMPLEX *
+FiltOvSv_fetchpt_par(FiltOvSv pflt, int parity) {
+  if (parity & 01)
+    return pflt->zovec + pflt->buflen;
+  else
+    return pflt->zovec;
+}
+
+COMPLEX *
+FiltOvSv_storept_par(FiltOvSv pflt, int parity) {
+  if (parity & 01)
+    return pflt->zovec;
+  else
+    return pflt->zovec + pflt->buflen;
+}
+
+/* how many samples to take */
+/* NB strategy. This is the number of good samples in the
+   left half of the true buffer. Samples in right half
+   are circular artifacts and are ignored. */
+int
+FiltOvSv_storesize(FiltOvSv pflt) { return (pflt->fftlen - pflt->buflen); }
+
+/*------------------------------------------------------------*/
+/* create a new overlap/save filter from complex coefficients */
+
+FiltOvSv
+newFiltOvSv(COMPLEX *coefs, int ncoef, int pbits) {
+  int buflen, fftlen;
+  FiltOvSv p;
+  fftw_plan pfwd,pinv;
+  COMPLEX *zrvec, *zfvec, *zivec, *zovec;
+  p = (FiltOvSv) safealloc(1, sizeof(filt_ov_sv), "new overlap/save filter");
+  buflen = nblock2(ncoef-1), fftlen = 2 * buflen;
+  zrvec = newvec_COMPLEX(fftlen, "raw signal vec in newFiltOvSv");
+  zfvec = newvec_COMPLEX(fftlen, "filter z vec in newFiltOvSv");
+  zivec = newvec_COMPLEX(fftlen, "signal in z vec in newFiltOvSv");
+  zovec = newvec_COMPLEX(fftlen, "signal out z vec in newFiltOvSv");
+
+  /* prepare frequency response from filter coefs */
+  {
+    int i;
+    COMPLEX *zcvec;
+    fftw_plan ptmp;
+    
+    zcvec = newvec_COMPLEX(fftlen, "temp filter z vec in newFiltOvSv");
+    ptmp = fftw_create_plan(fftlen, FFTW_FORWARD, pbits);
+
+#ifdef LHS
+    for (i = 0; i < ncoef; i++) zcvec[i] = coefs[i];
+#else
+    for (i = 0; i < ncoef; i++) zcvec[fftlen - ncoef - 1 + i] = coefs[i];
+#endif
+
+    fftw_one(ptmp, (fftw_complex *) zcvec, (fftw_complex *) zfvec);
+    fftw_destroy_plan(ptmp);
+    delvec_COMPLEX(zcvec);
+  }
+
+  /* prepare transforms for signal */
+  pfwd = fftw_create_plan(fftlen, FFTW_FORWARD, pbits);
+  pinv = fftw_create_plan(fftlen, FFTW_BACKWARD, pbits);
+  /* stuff values */
+  p->buflen = buflen;
+  p->fftlen = fftlen;
+  p->zfvec = zfvec;
+  p->zivec = zivec;
+  p->zovec = zovec;
+  p->zrvec = zrvec;
+  p->pfwd = pfwd;
+  p->pinv = pinv;
+  p->scale = 1.0 / fftlen;
+
+  return p;
+}
+
+/* deep-six the filter */
+void
+delFiltOvSv(FiltOvSv p) {
+  if (p) {
+    delvec_COMPLEX(p->zfvec);
+    delvec_COMPLEX(p->zivec);
+    delvec_COMPLEX(p->zovec);
+    delvec_COMPLEX(p->zrvec);
+    fftw_destroy_plan(p->pfwd);
+    fftw_destroy_plan(p->pinv);
+    safefree((char *) p);
+  }
+}
+
+/*------------------------------------------------------------*/
+
+
diff --git a/jDttSP/ovsv.h b/jDttSP/ovsv.h
new file mode 100644
index 0000000..f4baa16
--- /dev/null
+++ b/jDttSP/ovsv.h
@@ -0,0 +1,74 @@
+/* ovsv.h
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _ovsv_h
+#define _ovsv_h
+
+#include <fromsys.h>
+#include <banal.h>
+#include <splitfields.h>
+#include <datatypes.h>
+#include <bufvec.h>
+#include <cxops.h>
+#include <update.h>
+#include <lmadf.h>
+#include <fftw.h>
+
+typedef
+struct _filt_ov_sav {
+  int buflen, fftlen;
+  COMPLEX *zfvec, *zivec, *zovec, *zrvec;
+  fftw_plan pfwd, pinv;
+  REAL scale;
+} filt_ov_sv, *FiltOvSv;
+
+extern FiltOvSv newFiltOvSv(COMPLEX *coefs,
+			    int ncoef,
+			    int pbits);
+extern void delFiltOvSv(FiltOvSv p);
+
+extern COMPLEX *FiltOvSv_initpoint(FiltOvSv pflt);
+extern int FiltOvSv_initsize(FiltOvSv pflt);
+
+extern COMPLEX *FiltOvSv_fetchpoint(FiltOvSv pflt);
+extern int FiltOvSv_fetchsize(FiltOvSv pflt);
+
+extern COMPLEX *FiltOvSv_storepoint(FiltOvSv pflt);
+extern int FiltOvSv_storesize(FiltOvSv pflt);
+
+extern COMPLEX *FiltOvSv_fetchpt_par(FiltOvSv pflt, int parity);
+extern COMPLEX *FiltOvSv_storept_par(FiltOvSv pflt, int parity);
+
+extern void filter_OvSv(FiltOvSv pflt);
+extern void filter_OvSv_par(FiltOvSv pflt);
+#endif
diff --git a/jDttSP/ringb.c b/jDttSP/ringb.c
new file mode 100644
index 0000000..1e6c31e
--- /dev/null
+++ b/jDttSP/ringb.c
@@ -0,0 +1,155 @@
+/*
+  Memory-mapped ringbuffer
+  Derived from jack/ringbuffer.h
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+    
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program; if not, write to the Free Software 
+    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+    Original
+    Copyright (C) 2000 Paul Davis
+    Copyright (C) 2003 Rohan Drape
+
+    Derived
+    Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <ringb.h>
+
+ringb_t *
+ringb_create(char *usemem, size_t sz2) {
+  ringb_t *rb = (ringb_t *) usemem;
+  rb->buf = usemem + sizeof(ringb_t);
+  rb->size = sz2;	// power-of-2-sized
+  rb->mask = rb->size - 1;
+  rb->wptr = rb->rptr = 0;
+  return rb;
+}
+
+void
+ringb_reset(ringb_t *rb) {
+  // NB not thread-safe
+  rb->rptr = 0;
+  rb->wptr = 0;
+}
+
+size_t
+ringb_read_space(const ringb_t *rb) {
+  size_t w = rb->wptr, r = rb->rptr;
+  if (w > r) return w - r;
+  else return (w - r + rb->size) & rb->mask;
+}
+
+size_t
+ringb_write_space(const ringb_t *rb) {
+  size_t w = rb->wptr, r = rb->rptr;
+  if (w > r) return ((r - w + rb->size) & rb->mask) - 1;
+  else if (w < r) return r - w - 1;
+  else return rb->size - 1;
+}
+
+size_t
+ringb_read(ringb_t *rb, char *dest, size_t cnt) {
+  size_t free_cnt, cnt2, to_read, n1, n2;
+  if ((free_cnt = ringb_read_space(rb)) == 0) return 0;
+  to_read = cnt > free_cnt ? free_cnt : cnt;
+  if ((cnt2 = rb->rptr + to_read) > rb->size)
+    n1 = rb->size - rb->rptr, n2 = cnt2 & rb->mask;
+  else
+    n1 = to_read, n2 = 0;
+  memcpy(dest, &(rb->buf[rb->rptr]), n1);
+  rb->rptr = (rb->rptr + n1) & rb->mask;
+  if (n2) {
+    memcpy(dest + n1, &(rb->buf[rb->rptr]), n2);
+    rb->rptr = (rb->rptr + n2) & rb->mask;
+  }
+  return to_read;
+}
+
+size_t
+ringb_peek(ringb_t *rb, char *dest, size_t cnt) {
+  size_t free_cnt, cnt2, to_read, n1, n2, tmp_rptr;
+  tmp_rptr = rb->rptr;
+  if ((free_cnt = ringb_read_space(rb)) == 0) return 0;
+  to_read = cnt > free_cnt ? free_cnt : cnt;
+  if ((cnt2 = tmp_rptr + to_read) > rb->size)
+    n1 = rb->size - tmp_rptr, n2 = cnt2 & rb->mask;
+  else
+    n1 = to_read, n2 = 0;
+  memcpy(dest, &(rb->buf[tmp_rptr]), n1);
+  tmp_rptr = (tmp_rptr + n1) & rb->mask;
+  if (n2)
+    memcpy(dest + n1, &(rb->buf[tmp_rptr]), n2);
+  return to_read;
+}
+
+size_t
+ringb_write(ringb_t *rb, const char *src, size_t cnt) {
+  size_t free_cnt, cnt2, to_write, n1, n2;
+  if ((free_cnt = ringb_write_space(rb)) == 0) return 0;
+  to_write = cnt > free_cnt ? free_cnt : cnt;
+  if ((cnt2 = rb->wptr + to_write) > rb->size)
+    n1 = rb->size - rb->wptr, n2 = cnt2 & rb->mask;
+  else
+    n1 = to_write, n2 = 0;
+  memcpy(&(rb->buf[rb->wptr]), src, n1);
+  rb->wptr = (rb->wptr + n1) & rb->mask;
+  if (n2) {
+    memcpy(&(rb->buf[rb->wptr]), src + n1, n2);
+    rb->wptr = (rb->wptr + n2) & rb->mask;
+  }
+  return to_write;
+}
+
+void
+ringb_read_advance(ringb_t *rb, size_t cnt) {
+  rb->rptr = (rb->rptr + cnt) & rb->mask;
+}
+
+void
+ringb_write_advance(ringb_t *rb, size_t cnt) {
+  rb->wptr = (rb->wptr + cnt) & rb->mask;
+}
+
+void
+ringb_get_read_vector(const ringb_t *rb, ringb_data_t *vec) {
+  size_t free_cnt, cnt2,
+         w = rb->wptr, r = rb->rptr;
+  if (w > r) free_cnt = w - r;
+  else free_cnt = (w - r + rb->size) & rb->mask;
+  if ((cnt2 = r + free_cnt) > rb->size) {
+    vec[0].buf = &(rb->buf[r]), vec[0].len = rb->size - r;
+    vec[1].buf = rb->buf, vec[1].len = cnt2 & rb->mask;
+  } else {
+    vec[0].buf = &(rb->buf[r]), vec[0].len = free_cnt;
+    vec[1].len = 0;
+  }
+}
+
+void
+ringb_get_write_vector(const ringb_t *rb, ringb_data_t *vec) {
+  size_t free_cnt, cnt2,
+         w = rb->wptr, r = rb->rptr;
+  if (w > r) free_cnt = ((r - w + rb->size) & rb->mask) - 1;
+  else if (w < r) free_cnt = r - w - 1;
+  else free_cnt = rb->size - 1;
+  if ((cnt2 = w + free_cnt) > rb->size) {
+    vec[0].buf = &(rb->buf[w]), vec[0].len = rb->size - w;
+    vec[1].buf = rb->buf, vec[1].len = cnt2 & rb->mask;
+  } else {
+    vec[0].buf = &(rb->buf[w]), vec[0].len = free_cnt;
+    vec[1].len = 0;
+  }
+}
diff --git a/jDttSP/ringb.h b/jDttSP/ringb.h
new file mode 100644
index 0000000..c92fd3c
--- /dev/null
+++ b/jDttSP/ringb.h
@@ -0,0 +1,172 @@
+/*
+  Memory-mapped ringbuffer
+  Derived from jack/ringbuffer.h
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+    
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program; if not, write to the Free Software 
+    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+    Original
+    Copyright (C) 2000 Paul Davis
+    Copyright (C) 2003 Rohan Drape
+
+    Derived
+    Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+*/
+
+#ifndef _ringb_h
+#define _ringb_h
+
+#include <sys/types.h>
+
+typedef struct {
+  char *buf;
+  size_t len;
+} ringb_data_t;
+
+typedef struct {
+  char *buf;
+  size_t wptr,
+         rptr,
+         size,
+         mask;
+} ringb_t;
+
+/* Sets up a ringbuffer data structure of a specified size
+ * in pre-allocated memory.
+ * sz is requested ringbuffer size in bytes,
+ * MUST be a power of 2.
+ * pre-allocated memory must be large enough to
+ * accommodate (ringb header + stipulated memory size).
+ * return a pointer to a new ringb_t, if successful,
+ * 0 otherwise. */
+
+extern ringb_t *ringb_create(char *usemem, size_t sz2);
+
+/*
+ * There is no corresponding 'free' function
+ * since memory is all pre-allocated
+ */
+
+//void ringb_free(ringb_t *rb);
+
+/* Fill a data structure with a description of the current readable
+ * data held in the ringbuffer.  This description is returned in a two
+ * element array of ringb_data_t.  Two elements are needed
+ * because the data to be read may be split across the end of the
+ * ringbuffer.
+ *
+ * The first element will always contain a valid len field, which
+ * may be zero or greater.  If the len field is non-zero, then data
+ * can be read in a contiguous fashion using the address given in the
+ * corresponding @a buf field.
+ *
+ * If the second element has a non-zero len field, then a second
+ * contiguous stretch of data can be read from the address given in
+ * its corresponding buf field.
+ *
+ * rb a pointer to the ringbuffer structure.
+ * vec a pointer to a 2 element array of ringb_data_t. */
+
+extern void ringb_get_read_vector(const ringb_t *rb, ringb_data_t *vec);
+
+/* Fill a data structure with a description of the current writable
+ * space in the ringbuffer.  The description is returned in a two
+ * element array of ringb_data_t.  Two elements are needed
+ * because the space available for writing may be split across the end
+ * of the ringbuffer.
+ * The first element will always contain a valid len field, which
+ * may be zero or greater.  If the @a len field is non-zero, then data
+ * can be written in a contiguous fashion using the address given in
+ * the corresponding buf field.
+ * If the second element has a non-zero len field, then a second
+ * contiguous stretch of data can be written to the address given in
+ * the corresponding buf field.
+ * rb a pointer to the ringbuffer structure.
+ * vec a pointer to a 2 element array of ringb_data_t. */
+
+extern void ringb_get_write_vector(const ringb_t *rb, ringb_data_t *vec);
+
+/*
+ * Read data from the ringbuffer.
+ * rb a pointer to the ringbuffer structure.
+ * dest a pointer to a buffer where data read from the
+ * ringbuffer will go.
+ * cnt the number of bytes to read.
+ *
+ * return the number of bytes read, which may range from 0 to cnt. */
+
+extern size_t ringb_read(ringb_t *rb, char *dest, size_t cnt);
+
+/* Read data from the ringbuffer. Opposed to ringb_read()
+ * this function does not move the read pointer. Thus it's
+ * a convenient way to inspect data in the ringbuffer in a
+ * continous fashion. The price is that the data is copied
+ * into a user provided buffer. For "raw" non-copy inspection
+ * of the data in the ringbuffer use ringb_get_read_vector().
+ * rb a pointer to the ringbuffer structure.
+ * dest a pointer to a buffer where data read from the
+ *   ringbuffer will go.
+ * cnt the number of bytes to read.
+ * return the number of bytes read, which may range from 0 to cnt.
+ */
+
+extern size_t ringb_peek(ringb_t *rb, char *dest, size_t cnt);
+
+/* Advance the read pointer.
+ * After data have been read from the ringbuffer using the pointers
+ * returned by ringb_get_read_vector(), use this function to
+ * advance the buffer pointers, making that space available for future
+ * write operations.
+ *
+ * rb a pointer to the ringbuffer structure.
+ * cnt the number of bytes read. */
+
+extern void ringb_read_advance(ringb_t *rb, size_t cnt);
+
+/* Return the number of bytes available for reading.
+ * rb a pointer to the ringbuffer structure.
+ * return the number of bytes available to read. */
+
+extern size_t ringb_read_space(const ringb_t *rb);
+
+/* Reset the read and write pointers, making an empty buffer.
+ * This is not thread safe. */
+
+extern void ringb_reset(ringb_t *rb);
+
+/* Write data into the ringbuffer.
+ * rb a pointer to the ringbuffer structure.
+ * src a pointer to the data to be written to the ringbuffer.
+ * cnt the number of bytes to write.
+ * return the number of bytes write, which may range from 0 to cnt */
+
+extern size_t ringb_write(ringb_t *rb, const char *src, size_t cnt);
+
+/* Advance the write pointer.
+ * After data have been written the ringbuffer using the pointers
+ * returned by ringb_get_write_vector(), use this function
+ * to advance the buffer pointer, making the data available for future
+ * read operations.
+ * rb a pointer to the ringbuffer structure.
+ * cnt the number of bytes written. */
+
+extern void ringb_write_advance(ringb_t *rb, size_t cnt);
+
+/* Return the number of bytes available for writing.
+ * rb a pointer to the ringbuffer structure.
+ * return the amount of free space (in bytes) available for writing. */
+
+extern size_t ringb_write_space(const ringb_t *rb);
+
+#endif
diff --git a/jDttSP/sdr.c b/jDttSP/sdr.c
new file mode 100644
index 0000000..f04d641
--- /dev/null
+++ b/jDttSP/sdr.c
@@ -0,0 +1,676 @@
+/* sdr.c
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <common.h>
+
+//========================================================================
+/* initialization and termination */
+
+/* global and general info,
+   not specifically attached to
+   tx, rx, or scheduling */
+
+PRIVATE void
+setup_all(void) {
+
+  uni.samplerate = loc.def.rate;
+  uni.buflen = loc.def.size;
+  uni.mode.sdr = loc.def.mode;
+  uni.mode.trx = RX;
+
+  if (uni.meter.flag) {
+    uni.meter.chan.path = loc.path.meter;
+    uni.meter.chan.size = loc.mult.ring * sizeof(REAL);
+    uni.meter.val = -200.0;
+    uni.meter.chan.c = openChan(uni.meter.chan.path, uni.meter.chan.size);
+  }
+
+  uni.wisdom.path = loc.path.wisdom;
+  uni.wisdom.bits = FFTW_OUT_OF_PLACE | FFTW_ESTIMATE;
+  {
+    FILE *f = fopen(uni.wisdom.path, "r");
+    if (f) {
+#define WBUFLEN 2048
+#define WSTRLEN 64      
+      char *line = alloca(WBUFLEN);
+      fgets(line, WBUFLEN, f);
+      if ((strlen(line) > WSTRLEN) &&
+	  (fftw_import_wisdom_from_string(line) != FFTW_FAILURE))
+	uni.wisdom.bits = FFTW_OUT_OF_PLACE | FFTW_MEASURE | FFTW_USE_WISDOM;
+#undef WSTRLEN
+#undef WBUFLEN      
+      fclose(f);
+    }
+  }
+
+  uni.tick = 0;
+}
+
+/* purely rx */
+
+PRIVATE void
+setup_rx(void) {
+
+  /* conditioning */
+  rx.iqfix = newCorrectIQ(0.0, 1.0);
+  rx.filt.coef = newFIR_Bandpass_COMPLEX(-4800.0,
+					 4800.0,
+					 uni.samplerate,
+					 uni.buflen + 1);
+  rx.filt.ovsv = newFiltOvSv(FIRcoef(rx.filt.coef),
+			     FIRsize(rx.filt.coef),
+			     uni.wisdom.bits);
+  normalize_vec_COMPLEX(rx.filt.ovsv->zfvec,
+			rx.filt.ovsv->fftlen);
+
+  // hack for EQ
+  rx.filt.save = newvec_COMPLEX(rx.filt.ovsv->fftlen, "RX filter cache");
+  memcpy((char *) rx.filt.save,
+	 (char *) rx.filt.ovsv->zfvec,
+	 rx.filt.ovsv->fftlen * sizeof(COMPLEX));
+
+  /* buffers */
+  /* note we overload the internal filter buffers
+     we just created */
+  rx.buf.i = newCXB(FiltOvSv_fetchsize(rx.filt.ovsv),
+		    FiltOvSv_fetchpoint(rx.filt.ovsv),
+		    "init rx.buf.i");
+  rx.buf.o = newCXB(FiltOvSv_storesize(rx.filt.ovsv),
+		    FiltOvSv_storepoint(rx.filt.ovsv),
+		    "init rx.buf.o");
+  
+  /* conversion */
+  rx.osc.freq = -11025.0;
+  rx.osc.phase = 0.0;
+  rx.osc.gen = newOSC(uni.buflen,
+		      ComplexTone,
+		      rx.osc.freq,
+		      rx.osc.phase,
+		      uni.samplerate,
+		      "SDR RX Oscillator");
+
+  rx.agc.gen = newDigitalAgc(agcMED,	// Mode
+			     7,		// Hang
+			     7,		// Size
+			     48,	// Ramp
+			     3,		// Over
+			     3,		// Rcov
+			     CXBsize(rx.buf.o),	// BufSize
+			     100.0,	// MaxGain
+			     0.707,	// Limit
+			     1.0,	// CurGain
+			     CXBbase(rx.buf.o));
+  rx.agc.flag = TRUE;
+
+  /* demods */
+  rx.am.gen = newAMD(48000.0,	// REAL samprate
+		     0.0,	// REAL f_initial
+		     -500.0,	// REAL f_lobound,
+		     500.0,	// REAL f_hibound,
+		     400.0,	// REAL f_bandwid,
+		     CXBsize(rx.buf.o),	// int size,
+		     CXBbase(rx.buf.o),	// COMPLEX *ivec,
+		     CXBbase(rx.buf.o),	// COMPLEX *ovec,
+		     AMdet,	// AM Mode AMdet == rectifier,
+		                //         SAMdet == synchronous detector
+		             "AM detector blew");	// char *tag
+  rx.fm.gen = newFMD(48000,	// REAL samprate
+		     0.0,	// REAL f_initial
+		     -6000.0,	// REAL f_lobound
+		     6000.0,	// REAL f_hibound
+		     10000.0,	// REAL f_bandwid
+		     CXBsize(rx.buf.o),	// int size
+		     CXBbase(rx.buf.o),	// COMPLEX *ivec
+		     CXBbase(rx.buf.o),	// COMPLEX *ovec
+		     "New FM Demod structure");	// char *error message;
+
+  /* noise reduction */
+  rx.anf.gen = new_lmsr(rx.buf.o,	// CXB signal,
+			64,		// int delay,
+			0.01,		// REAL adaptation_rate,
+			0.00001,	// REAL leakage,
+			45,		// int adaptive_filter_size,
+			LMADF_INTERFERENCE);
+  rx.anf.flag = FALSE;
+  rx.anr.gen = new_lmsr(rx.buf.o,	// CXB signal,
+			64,		// int delay,
+			0.01,		// REAL adaptation_rate,
+			0.00001,	// REAL leakage,
+			45,		// int adaptive_filter_size,
+			LMADF_NOISE);
+  rx.anr.flag = FALSE;
+
+  rx.nb.thresh = 3.3;
+  rx.nb.gen = new_noiseblanker(rx.buf.i, rx.nb.thresh);
+  rx.nb.flag = FALSE;
+
+  rx.nb_sdrom.thresh = 2.5;
+  rx.nb_sdrom.gen = new_noiseblanker(rx.buf.i, rx.nb_sdrom.thresh);
+  rx.nb_sdrom.flag = FALSE;
+
+  rx.spot.gen = newSpotToneGen(-12.0,	// gain
+			       700.0,	// freq
+			       5.0,	// ms rise
+			       5.0,	// ms fall
+			       uni.buflen,
+			       uni.samplerate);
+
+  rx.scl.pre.val = 1.0;
+  rx.scl.pre.flag = FALSE;
+  rx.scl.post.val = 1.0;
+  rx.scl.post.flag = FALSE;
+
+  memset((char *) &rx.squelch, 0, sizeof(rx.squelch));
+  rx.squelch.thresh = -30.0;
+  rx.squelch.power = 0.0;
+  rx.squelch.flag = rx.squelch.running = rx.squelch.set = FALSE;
+  rx.squelch.num = (int) (0.0395 * uni.samplerate + 0.5);
+
+  rx.mode = uni.mode.sdr;
+  rx.bin.flag = FALSE;
+
+  rx.tick = 0;
+}
+
+/* purely tx */
+
+PRIVATE void
+setup_tx(void) {
+
+  /* conditioning */
+  tx.iqfix = newCorrectIQ(0.0, 1.0);
+  tx.filt.coef = newFIR_Bandpass_COMPLEX(300.0,
+					 3000.0,
+					 uni.samplerate,
+					 uni.buflen + 1);
+  tx.filt.ovsv = newFiltOvSv(FIRcoef(tx.filt.coef),
+			     FIRsize(tx.filt.coef),
+			     uni.wisdom.bits);
+  normalize_vec_COMPLEX(tx.filt.ovsv->zfvec,
+			tx.filt.ovsv->fftlen);
+
+  // hack for EQ
+  tx.filt.save = newvec_COMPLEX(tx.filt.ovsv->fftlen, "TX filter cache");
+  memcpy((char *) tx.filt.save,
+	 (char *) tx.filt.ovsv->zfvec,
+	 tx.filt.ovsv->fftlen * sizeof(COMPLEX));
+
+  /* buffers */
+  tx.buf.i = newCXB(FiltOvSv_fetchsize(tx.filt.ovsv),
+		    FiltOvSv_fetchpoint(tx.filt.ovsv),
+		    "init tx.buf.i");
+  tx.buf.o = newCXB(FiltOvSv_storesize(tx.filt.ovsv),
+		    FiltOvSv_storepoint(tx.filt.ovsv),
+		    "init tx.buf.o");
+  
+  /* conversion */
+  tx.osc.freq = 0.0;
+  tx.osc.phase = 0.0;
+  tx.osc.gen = newOSC(uni.buflen,
+		      ComplexTone,
+		      tx.osc.freq,
+		      tx.osc.phase,
+		      uni.samplerate,
+		      "SDR TX Oscillator");
+
+  tx.agc.gen = newDigitalAgc(agcFAST, 	// Mode
+			     3,		// Hang
+			     3,		// Size
+			     3,		// Over
+			     3,		// Rcov
+			     48,	// Ramp
+			     CXBsize(tx.buf.o),	// BufSize
+			     1.0,	// MaxGain
+			     0.900,	// Limit
+			     1.0,	// CurGain
+			     CXBbase(tx.buf.o));
+  tx.agc.flag = TRUE;
+
+  tx.spr.gen = newSpeechProc(0.4, 10.0, CXBbase(tx.buf.i), CXBsize(tx.buf.i));
+  tx.spr.flag = FALSE;
+
+  tx.scl.dc = cxzero;
+  tx.scl.pre.val = 1.0;
+  tx.scl.pre.flag = FALSE;
+  tx.scl.post.val = 1.0;
+  tx.scl.post.flag = FALSE;
+
+  tx.mode = uni.mode.sdr;
+
+  tx.tick = 0;
+  /* not much else to do for TX */
+}
+
+/* how the outside world sees it */
+
+void
+setup_workspace(void) {
+  setup_all(), setup_rx(), setup_tx();
+}
+
+void
+destroy_workspace(void) {
+
+  /* TX */
+  delSpeechProc(tx.spr.gen);
+  delDigitalAgc(tx.agc.gen);
+  delOSC(tx.osc.gen);
+  delvec_COMPLEX(tx.filt.save);
+  delFiltOvSv(tx.filt.ovsv);
+  delFIR_Bandpass_COMPLEX(tx.filt.coef);
+  delCorrectIQ(tx.iqfix);
+  delCXB(tx.buf.o);
+  delCXB(tx.buf.i);
+
+  /* RX */
+  delSpotToneGen(rx.spot.gen);
+  delDigitalAgc(rx.agc.gen);
+  del_nb(rx.nb_sdrom.gen);
+  del_nb(rx.nb.gen);
+  del_lmsr(rx.anf.gen);
+  del_lmsr(rx.anr.gen);
+  delAMD(rx.am.gen);
+  delFMD(rx.fm.gen);
+  delOSC(rx.osc.gen);
+  delvec_COMPLEX(rx.filt.save);
+  delFiltOvSv(rx.filt.ovsv);
+  delFIR_Bandpass_COMPLEX(rx.filt.coef);
+  delCorrectIQ(rx.iqfix);
+  delCXB(rx.buf.o);
+  delCXB(rx.buf.i);
+
+  /* all */
+  if (uni.meter.flag)
+    closeChan(uni.meter.chan.c);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// execution
+//////////////////////////////////////////////////////////////////////////
+
+//========================================================================
+/* all */
+
+/* tap off S-meter from some buf */
+
+PRIVATE void
+do_meter(COMPLEX *vec, int len) {
+  int i;
+  
+  uni.meter.val = 0;
+
+  switch (uni.meter.type) {
+  case AVG_SIGNAL_STRENGTH:
+    for (i = 0; i < len; i++)
+      uni.meter.val += Csqrmag(vec[i]);
+    uni.meter.val =
+      uni.meter.avgval = 0.9 * uni.meter.avgval + log10(uni.meter.val + 1e-20);
+    break;
+  case SIGNAL_STRENGTH:
+    for (i = 0; i < len; i++)
+      uni.meter.val += Csqrmag(vec[i]);
+    uni.meter.avgval = uni.meter.val = 10.0 * log10(uni.meter.val + 1e-20);
+    break;
+  case ADC_REAL:
+    for(i = 0; i < len; i++)
+      uni.meter.val = max(fabs(vec[i].re), uni.meter.val);
+    uni.meter.val = 20.0 * log10(uni.meter.val + 1e-10);
+    break;
+  case ADC_IMAG:
+    for(i = 0; i < len; i++)
+      uni.meter.val = max(fabs(vec[i].im), uni.meter.val);
+    uni.meter.val = 20.0 * log10(uni.meter.val + 1e-10);
+    break;
+  default:
+    break;
+  }
+
+  putChan_nowait(uni.meter.chan.c,
+		 (char *) &uni.meter.val,
+		 sizeof(uni.meter.val));
+}
+
+//========================================================================
+/* RX processing */ 
+
+PRIVATE BOOLEAN
+should_do_rx_squelch(void) {
+  if (rx.squelch.flag) {
+    int i, n = CXBhave(rx.buf.o);
+    REAL tst;
+    rx.squelch.power = 0.0;
+    for (i = 0; i < n; i++)
+      rx.squelch.power += Csqrmag(CXBdata(rx.buf.o, i));
+    tst = (10.0 * log10(rx.squelch.power)
+	    + rx.squelch.offset.meter
+	    + rx.squelch.offset.att
+	    + rx.squelch.offset.gain);
+    return rx.squelch.thresh > tst;
+  } else
+    return rx.squelch.set = FALSE;
+}
+
+// apply squelch
+// slew into silence first time
+
+PRIVATE void
+do_squelch(void) {
+  rx.squelch.set = TRUE;
+  if (!rx.squelch.running) {
+    int i, m = rx.squelch.num, n = CXBhave(rx.buf.o) - m;
+    for (i = 0; i < m; i++)
+      CXBdata(rx.buf.o, i) = Cscl(CXBdata(rx.buf.o, i), 1.0 - (REAL) i / m);
+    memset((void *) (CXBbase(rx.buf.o) + m), 0, n * sizeof(COMPLEX));
+    rx.squelch.running = TRUE;
+  } else
+    memset((void *) CXBbase(rx.buf.o), 0, CXBhave(rx.buf.o) * sizeof(COMPLEX));
+}
+
+// lift squelch
+// slew out from silence to full scale
+
+PRIVATE void
+no_squelch(void) {
+  if (rx.squelch.running) {
+    int i, m = rx.squelch.num;
+    for (i = 0; i < m; i++)
+      CXBdata(rx.buf.o, i) = Cscl(CXBdata(rx.buf.o, i), (REAL) i / m);
+    rx.squelch.running = FALSE;
+  }
+}
+
+/* pre-condition for (nearly) all RX modes */
+
+PRIVATE void
+do_rx_pre(void) {
+  int i, n = min(CXBhave(rx.buf.i), uni.buflen);
+
+  //
+  // do shrinkage here
+  //
+
+  if (rx.scl.pre.flag)
+    for (i = 0; i < n; i++)
+      CXBdata(rx.buf.i, i) = Cscl(CXBdata(rx.buf.i, i),
+				  rx.scl.pre.val); 
+
+  if (rx.nb.flag) noiseblanker(rx.nb.gen);
+  if (rx.nb_sdrom.flag) SDROMnoiseblanker(rx.nb_sdrom.gen);
+
+  correctIQ(rx.buf.i, rx.iqfix);
+
+  /* 2nd if conversion happens here */
+  if (rx.osc.gen->Frequency != 0.0) {
+    ComplexOSC(rx.osc.gen);
+    for (i = 0; i < n; i++)
+      CXBdata(rx.buf.i, i) = Cmul(CXBdata(rx.buf.i, i),
+				  OSCCdata(rx.osc.gen, i));
+  } 
+
+  /* filtering, metering, & AGC */
+  if (rx.mode != SPEC) {
+    filter_OvSv(rx.filt.ovsv);
+    CXBhave(rx.buf.o) = CXBhave(rx.buf.i);
+    if (uni.meter.flag)	do_meter(CXBbase(rx.buf.o), uni.buflen);
+    if (rx.agc.flag) DigitalAgc(rx.agc.gen, rx.tick);
+  } else if (uni.meter.flag)
+    do_meter(CXBbase(rx.buf.o), uni.buflen);
+}
+
+PRIVATE void
+do_rx_post(void) {
+  int i, n = CXBhave(rx.buf.o);;
+
+  if (!rx.squelch.set)  {
+    no_squelch();
+    // spotting tone
+    if (rx.spot.flag) {
+      // remember whether it's turned itself off during this pass
+      rx.spot.flag = SpotTone(rx.spot.gen);
+      for (i = 0; i < n; i++)
+	CXBdata(rx.buf.o, i) = Cadd(CXBdata(rx.buf.o, i),
+				    CXBdata(rx.spot.gen->buf, i));
+    }
+  }
+
+  //
+  // mix in sidetone here
+  //
+
+  if (rx.scl.post.flag)
+    for (i = 0; i < n; i++)
+      CXBdata(rx.buf.o, i) = Cscl(CXBdata(rx.buf.o, i),
+				  rx.scl.post.val);
+
+  // not binaural? collapse
+  if (!rx.bin.flag)
+    for (i = 0; i < n; i++)
+      CXBimag(rx.buf.o, i) = CXBreal(rx.buf.o, i);
+}
+
+/* demod processing */
+
+PRIVATE void
+do_rx_SBCW(void) {
+  if (rx.anr.flag) lmsr_adapt(rx.anr.gen);
+  if (rx.anf.flag) lmsr_adapt(rx.anf.gen);
+}
+
+PRIVATE void
+do_rx_AM(void) { AMDemod(rx.am.gen); }
+
+PRIVATE void
+do_rx_FM(void) { FMDemod(rx.fm.gen); }
+
+PRIVATE void
+do_rx_DRM(void) {}
+
+PRIVATE void
+do_rx_SPEC(void) {
+  memcpy(CXBbase(rx.buf.o),
+	 CXBbase(rx.buf.i),
+	 sizeof(COMPLEX) * CXBhave(rx.buf.i));
+  if (rx.agc.flag) DigitalAgc(rx.agc.gen, rx.tick);
+}
+
+PRIVATE void
+do_rx_NIL(void) {
+  int i, n = min(CXBhave(rx.buf.i), uni.buflen);
+  for (i = 0; i < n; i++) CXBdata(rx.buf.o, i) = cxzero;
+}
+
+/* overall dispatch for RX processing */
+
+PRIVATE void
+do_rx(void) {
+  do_rx_pre();
+  switch (rx.mode) {
+  case USB:
+  case LSB:
+  case CWU:
+  case CWL:
+  case DSB:  do_rx_SBCW(); break;
+  case AM:
+  case SAM:  do_rx_AM(); break;
+  case FMN:  do_rx_FM();   break;
+  case DRM:  do_rx_DRM();  break;
+  case SPEC:
+    default: do_rx_SPEC(); break;
+  }
+  do_rx_post();
+}  
+
+//==============================================================
+/* TX processing */
+
+/* pre-condition for (nearly) all TX modes */
+
+PRIVATE void
+do_tx_pre(void) {
+  if (tx.scl.pre.flag) {
+    int i, n = CXBhave(tx.buf.i);
+    for (i = 0; i < n; i++)
+      CXBdata(tx.buf.i, i) = Cmplx(CXBreal(tx.buf.i, i) * tx.scl.pre.val, 0.0);
+  }
+
+  //
+  // mix in CW tone here
+  //
+
+  correctIQ(tx.buf.i, tx.iqfix);
+
+  if (tx.spr.flag) SpeechProcessor(tx.spr.gen);
+  filter_OvSv(tx.filt.ovsv);
+}
+
+PRIVATE void
+do_tx_post(void) {
+  CXBhave(tx.buf.o) = CXBhave(tx.buf.i);
+
+  if (tx.agc.flag) DigitalAgc(tx.agc.gen, tx.tick);
+  if (tx.scl.post.flag) {
+    int i, n = CXBhave(tx.buf.o);
+    for (i = 0; i < n; i++)
+      CXBdata(tx.buf.o, i) = Cscl(CXBdata(tx.buf.o, i), tx.scl.post.val);
+  }
+  if (uni.meter.flag) do_meter(CXBbase(tx.buf.o), uni.buflen);
+  if (tx.osc.gen->Frequency != 0.0) {
+    int i;
+    ComplexOSC(tx.osc.gen);
+    for (i = 0; i < CXBhave(tx.buf.o); i++)
+      CXBdata(tx.buf.o, i) = Cmul(CXBdata(tx.buf.o, i), OSCCdata(tx.osc.gen, i));
+  }
+}
+
+/* modulator processing */
+
+PRIVATE void
+do_tx_SBCW(void) {
+  int i, n = min(CXBhave(tx.buf.i), uni.buflen); 
+  for (i = 0; i < n; i++) {
+    tx.scl.dc = Cadd(Cscl(tx.scl.dc, 0.99),
+		     Cscl(CXBdata(tx.buf.o,i), -0.01));
+    CXBdata(tx.buf.o, i) = Cadd(CXBdata(tx.buf.o,i), tx.scl.dc);
+  }
+}
+
+PRIVATE void
+do_tx_AM(void) {
+  int i, n = min(CXBhave(tx.buf.i), uni.buflen); 
+  for (i = 0; i < n; i++) { 
+    tx.scl.dc = Cadd(Cscl(tx.scl.dc, 0.999),
+		     Cscl(CXBdata(tx.buf.o,i), -0.001));
+    CXBreal(tx.buf.o, i) =
+      0.49995 + 0.49995 * (CXBreal(tx.buf.o,i) - tx.scl.dc.re);
+    CXBimag(tx.buf.o, i) = 0.0;
+  }
+}
+
+PRIVATE void
+do_tx_FM(void) {
+  int i, n = min(CXBhave(tx.buf.i), uni.buflen);
+  for (i = 0; i < n; i++) {
+    tx.scl.dc = Cadd(Cscl(tx.scl.dc,0.999),
+		     Cscl(CXBdata(tx.buf.o,i), 0.001));
+    tx.osc.phase += (CXBreal(tx.buf.o, i)- tx.scl.dc.re) * CvtMod2Freq;
+    if (tx.osc.phase >= TWOPI) tx.osc.phase -= TWOPI;
+    if (tx.osc.phase < 0.0) tx.osc.phase += TWOPI;
+    CXBdata(tx.buf.o, i) =
+      Cscl(Cmplx(cos(tx.osc.phase), sin(tx.osc.phase)), 0.99999);
+  }
+}
+
+PRIVATE void
+do_tx_NIL(void) {
+  int i, n = min(CXBhave(tx.buf.i), uni.buflen);
+  for (i = 0; i < n; i++) CXBdata(tx.buf.o, i) = cxzero;
+}
+
+/* general TX processing dispatch */
+
+PRIVATE void
+do_tx(void) {
+  do_tx_pre();
+  switch (tx.mode) {
+  case USB:
+  case LSB:
+  case CWU:
+  case CWL:
+  case DSB:  do_tx_SBCW(); break;
+  case AM:
+  case SAM:  do_tx_AM();   break;
+  case FMN:  do_tx_FM();   break;
+  case DRM:
+  case SPEC:
+    default: do_tx_NIL(); break;
+  }
+  do_tx_post();
+}
+
+//========================================================================
+/* overall buffer processing;
+   come here when there are buffers to work on */
+
+void
+process_samples(float *bufl, float *bufr, int n) {
+  int i;
+
+  switch (uni.mode.trx) {
+
+  case RX:
+    for (i = 0; i < n; i++)
+      CXBimag(rx.buf.i, i) = bufl[i], CXBreal(rx.buf.i, i) = bufr[i];
+    CXBhave(rx.buf.i) = n;
+
+    do_rx(), rx.tick++;
+
+    for (i = 0; i < n; i++)
+      bufl[i] = (float)CXBimag(rx.buf.o, i), bufr[i] = (float)CXBreal(rx.buf.o, i);
+    CXBhave(rx.buf.o) = n;
+    break;
+
+  case TX:
+    for (i = 0; i < n; i++)
+      CXBimag(tx.buf.i, i) = bufl[i], CXBreal(tx.buf.i, i) = bufr[i];
+    CXBhave(tx.buf.i) = n;
+
+    do_tx(), tx.tick++;
+
+    for (i = 0; i < n; i++)
+      bufl[i] = (float)CXBimag(tx.buf.o, i), bufr[i] = (float)CXBreal(tx.buf.o, i);
+    CXBhave(rx.buf.o) = n;
+    break;
+  }
+
+  uni.tick++;
+}
diff --git a/jDttSP/sdrexport.c b/jDttSP/sdrexport.c
new file mode 100644
index 0000000..1830bd5
--- /dev/null
+++ b/jDttSP/sdrexport.c
@@ -0,0 +1,39 @@
+/* sdrexport.c
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <common.h>
+
+struct _uni uni;
+struct _rx rx;
+struct _tx tx;
+struct _top top;
diff --git a/jDttSP/sdrexport.h b/jDttSP/sdrexport.h
new file mode 100644
index 0000000..b561bf7
--- /dev/null
+++ b/jDttSP/sdrexport.h
@@ -0,0 +1,284 @@
+/* sdrexport.h
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/  
+  
+#ifndef _sdrexport_h
+#define _sdrexport_h
+  
+#include <common.h>
+
+//------------------------------------------------------------------------
+/* modulation types, modes */ 
+typedef enum _sdrmode {
+  LSB,				//  0
+  USB,				//  1
+  DSB,				//  2
+  CWL,				//  3
+  CWU,				//  4
+  FMN,				//  5
+  AM,				//  6
+  PSK,				//  7
+  SPEC,				//  8
+  RTTY,				//  9
+  SAM,				// 10
+  DRM				// 11
+} SDRMODE;
+
+typedef enum _trxmode { RX, TX } TRXMODE;
+
+//========================================================================
+/* RX/TX both */ 
+//------------------------------------------------------------------------
+extern struct _uni {
+  REAL samplerate;
+  int buflen;
+
+  struct {
+    SDRMODE sdr;
+    TRXMODE trx;
+  } mode;
+
+  struct {
+    BOOLEAN flag;
+    struct {
+      char *path;
+      size_t size;
+      Chan c;
+    } chan;
+    REAL val, avgval;
+    METERTYPE type;
+  } meter;
+
+  struct {
+    BOOLEAN flag;
+    struct {
+      char *path;
+      size_t size;
+      Chan c;
+    } chan;
+    splitfld splt;
+  } update;
+
+  struct {
+    char *path;
+    int bits;
+  } wisdom;
+
+  long tick;
+  
+} uni;
+
+//------------------------------------------------------------------------
+/* RX */ 
+//------------------------------------------------------------------------
+
+extern struct _rx {
+  struct {
+    CXB i, o;
+  } buf;
+  IQ iqfix;
+  struct {
+    REAL freq, phase;
+    OSC gen;
+  } osc;
+  struct {
+    ComplexFIR coef;
+    FiltOvSv ovsv;
+    COMPLEX *save;
+  } filt;
+  struct {
+    REAL thresh;
+    NB gen;
+    BOOLEAN flag;
+  } nb;
+  struct {
+    REAL thresh;
+    NB gen;
+    BOOLEAN flag;
+  } nb_sdrom;
+  struct {
+    LMSR gen;
+    BOOLEAN flag;
+  } anr, anf;
+  struct {
+    DIGITALAGC gen;
+    BOOLEAN flag;
+  } agc;
+  struct { AMD gen; } am;
+  struct { FMD gen; } fm;
+  struct {
+    BOOLEAN flag;
+    SpotToneGen gen;
+  } spot;
+  struct {
+    struct {
+      REAL val;
+      BOOLEAN flag;
+    } pre, post;
+  } scl;
+  struct {
+    REAL thresh, power;
+    struct {
+      REAL meter, att, gain;
+    } offset;
+    BOOLEAN flag, running, set;
+    int num;
+  } squelch;
+  SDRMODE mode;
+  struct { BOOLEAN flag; } bin;
+  long tick;
+} rx;
+
+//------------------------------------------------------------------------
+/* TX */ 
+//------------------------------------------------------------------------
+extern struct _tx {
+  struct {
+    CXB i, o;
+  } buf;
+  IQ iqfix;
+  struct {
+    REAL freq, phase;
+    OSC gen;
+  } osc;
+  struct {
+    ComplexFIR coef;
+    FiltOvSv ovsv;
+    COMPLEX *save;
+  } filt;
+  struct {
+    ComplexFIR coef;
+    FiltOvSv ovsv;
+    CXB in, out;
+  } fm;
+  struct {
+    DIGITALAGC gen;
+    BOOLEAN flag;
+  } agc;
+  struct {
+    SpeechProc gen;
+    BOOLEAN flag;
+  } spr;
+  struct {
+    COMPLEX dc;
+    struct {
+      REAL val;
+      BOOLEAN flag;
+    } pre, post;
+  } scl;
+  SDRMODE mode;
+  long tick;
+} tx;
+
+//------------------------------------------------------------------------
+
+typedef enum _runmode {
+  RUN_MUTE, RUN_PASS, RUN_PLAY, RUN_SWCH 
+} RUNMODE;
+
+extern struct _top {
+  pid_t pid;
+  uid_t uid;
+  
+  struct timeval start_tv;
+
+  BOOLEAN running, verbose;
+  RUNMODE state;
+  
+  // audio io
+  struct {
+    struct {
+      float *l, *r;
+    } buf;
+    struct {
+      unsigned int frames, bytes;
+    } size;
+  } hold;
+  struct {
+    char *path;
+    int fd;
+    FILE *fp;
+    char buff[4096];
+  } parm;
+  
+  struct {
+    char name[256];
+    jack_client_t *client;
+    struct {
+      struct {
+	jack_port_t *l, *r;
+      } i, o;
+    } port;
+    struct {
+      struct {
+	jack_ringbuffer_t *l, *r;
+      } i, o;
+    } ring;
+    jack_nframes_t size;
+    struct {
+      int cb;
+      struct {
+	int i, o;
+      } rb;
+      int xr;
+    } blow;
+  } jack;
+
+  // update io
+  // multiprocessing & synchronization
+  struct {
+    struct {
+      pthread_t id;
+    } trx, upd, mon;
+  } thrd;
+  struct {
+    struct {
+      sem_t sem;
+    } buf, upd, mon;
+  } sync;
+  
+  // TRX switching
+  struct {
+    struct {
+      int want, have;
+    } bfct;
+    struct {
+      TRXMODE next;
+    } trx;
+    struct {
+      RUNMODE last;
+    } run;
+    int fade, tail;
+  } swch;
+} top;
+
+#endif
diff --git a/jDttSP/setup-ipc b/jDttSP/setup-ipc
new file mode 100755
index 0000000..3a58d31
--- /dev/null
+++ b/jDttSP/setup-ipc
@@ -0,0 +1,16 @@
+#!/bin/sh
+
+if [ ! -d ./IPC ]; then mkdir ./IPC; fi
+
+(cd ./IPC
+  if [ ! -p SDR-1000-0-commands.fifo ]; then
+    mkfifo SDR-1000-0-commands.fifo
+  fi
+
+  # 192 = METERMULT * sizeof(REAL)
+  if [ ! -f SDR-1000-0-meter.chan ]; then
+    ../mkchan SDR-1000-0-meter.chan 192
+  fi)
+
+ls -ld IPC
+ls -l IPC
diff --git a/jDttSP/speechproc.c b/jDttSP/speechproc.c
new file mode 100644
index 0000000..505304d
--- /dev/null
+++ b/jDttSP/speechproc.c
@@ -0,0 +1,83 @@
+/* speechproc.c
+   
+  This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <speechproc.h>
+
+SpeechProc
+newSpeechProc(REAL K, REAL MaxCompression, COMPLEX *spdat, int size) {
+  SpeechProc sp = (SpeechProc) safealloc(1, sizeof(speech_proc), "new speech processor");
+  sp->CG = newRLB(size, NULL, "CG buffer in Speech Processor");
+  sp->K = K;
+  sp->MaxGain = pow(10.0, MaxCompression * 0.05);
+  sp->LastCG = 1.0;
+  sp->SpeechProcessorBuffer = newCXB(size, spdat, "speech processor data");
+  sp->size = size;
+  return sp;
+}
+
+void
+delSpeechProc(SpeechProc sp) {
+  if (sp) {
+    delCXB(sp->SpeechProcessorBuffer);
+    safefree((char *) sp);
+  }
+}
+
+void
+SpeechProcessor(SpeechProc sp) {
+  int i;
+  REAL r = 0.0, Mag;
+  for (i = 0; i < sp->size; i++)
+    r = max(r, Cmag(CXBdata(sp->SpeechProcessorBuffer, i)));
+  Mag = Cmag(CXBdata(sp->SpeechProcessorBuffer, 0));
+  if (Mag > 0.0) {
+    RLBdata(sp->CG, 0) = sp->LastCG * (1.0 - sp->K) + (sp->K * r / Mag);
+    if (RLBdata(sp->CG, 0) > sp->MaxGain)
+      RLBdata(sp->CG, 0) = sp->MaxGain;
+  } else
+    RLBdata(sp->CG, 0) = 1.0;
+  for (i = 1; i < sp->size; i++) {
+    Mag = Cmag(CXBdata(sp->SpeechProcessorBuffer, i));
+    if (Mag > 0.0) {
+      RLBdata(sp->CG, i) =
+	RLBdata(sp->CG, i - 1) * (1 - sp->K) + (sp->K * r / Mag);
+      if (RLBdata(sp->CG, i) > sp->MaxGain)
+	RLBdata(sp->CG, i) = sp->MaxGain;
+    } else
+      RLBdata(sp->CG, i) = 1.0;
+  }
+  sp->LastCG = RLBdata(sp->CG, sp->size - 1);
+  for (i = 0; i < sp->size; i++)
+    CXBdata(sp->SpeechProcessorBuffer, i) =
+      Cscl(CXBdata(sp->SpeechProcessorBuffer, i), RLBdata(sp->CG, i));
+}
diff --git a/jDttSP/speechproc.h b/jDttSP/speechproc.h
new file mode 100644
index 0000000..cd69331
--- /dev/null
+++ b/jDttSP/speechproc.h
@@ -0,0 +1,54 @@
+/* speechproc.h
+   
+  This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _speechproc_h
+#define _speechproc_h
+
+#include <fromsys.h>
+#include <datatypes.h>
+#include <bufvec.h>
+#include <cxops.h>
+#include <banal.h>
+
+typedef struct _speechprocessor {
+  int size;
+  RLB CG;
+  CXB SpeechProcessorBuffer;
+  REAL LastCG, K, MaxGain;
+} speech_proc, *SpeechProc;
+
+extern SpeechProc newSpeechProc(REAL, REAL, COMPLEX *, int);
+extern void delSpeechProc(SpeechProc);
+extern void SpeechProcessor(SpeechProc);
+
+#endif
diff --git a/jDttSP/splitfields.c b/jDttSP/splitfields.c
new file mode 100644
index 0000000..3e5adaf
--- /dev/null
+++ b/jDttSP/splitfields.c
@@ -0,0 +1,73 @@
+/* splitfields.c
+   
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <splitfields.h>
+
+static char *_white = " \t\n";
+
+SPLIT
+newSPLIT(void) {
+  return (SPLIT) safealloc(1, sizeof(splitfld), "splitfield");
+}
+
+void
+delSPLIT(SPLIT s) { if (s) free((char *) s); }
+
+char *
+F(SPLIT s, int i) { return s->f[i]; }
+
+char **
+Fptr(SPLIT s, int i) { return &(s->f[i]); }
+
+int
+NF(SPLIT s) { return s->n; }
+
+int
+splitonto(SPLIT s, char *str, char *delim, char **fld, int fmx) {
+  int i = 0;
+  char *p = strtok(str, delim);
+  while (p) {
+    fld[i] = p;
+    if (++i >= fmx) break;
+    p = strtok(0, delim);
+  }
+  return i;
+}
+
+int
+spliton(SPLIT s, char *str, char *delim) {
+  return (s->n = splitonto(s, str, delim, s->f, MAXFLD));
+}
+
+void 
+split(SPLIT s, char *str) { spliton(s, str, _white); }
diff --git a/jDttSP/splitfields.h b/jDttSP/splitfields.h
new file mode 100644
index 0000000..dba31f7
--- /dev/null
+++ b/jDttSP/splitfields.h
@@ -0,0 +1,56 @@
+/* splitfields.h
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _splitfields_h
+#define _splitfields_h
+
+#include <fromsys.h>
+#include <bufvec.h>  
+#include <banal.h>
+
+#define MAXFLD 16384
+
+typedef struct _splitfld {
+  char *f[MAXFLD];
+  int n;
+} splitfld, *SPLIT;
+
+extern char *F(SPLIT, int);
+extern char **Fptr(SPLIT, int);
+extern int NF(SPLIT);
+
+extern int splitonto(SPLIT, char *, char *, char **, int);
+extern int spliton(SPLIT, char *, char *);
+extern void split(SPLIT, char *);
+
+#endif
diff --git a/jDttSP/spottone.c b/jDttSP/spottone.c
new file mode 100644
index 0000000..e4b2aa2
--- /dev/null
+++ b/jDttSP/spottone.c
@@ -0,0 +1,153 @@
+/* spottone.c */
+
+#include <spottone.h>
+
+//------------------------------------------------------------------------
+// An ASR envelope on a complex phasor,
+// with asynchronous trigger for R stage.
+// A/R use sine shaping.
+//------------------------------------------------------------------------
+
+BOOLEAN
+SpotTone(SpotToneGen st) {
+  int i, n = st->size;
+
+  ComplexOSC(st->osc.gen);
+
+  for (i = 0; i < n; i++) {
+
+    // in an envelope stage?
+
+    if (st->stage == SpotTone_RISE) {
+
+      // still going?
+      if (st->rise.have++ < st->rise.want) {
+	st->curr += st->rise.incr;
+	st->mul = st->scl * sin(st->curr * M_PI / 2.0);
+      } else {
+	// no, assert steady-state, force level
+	st->curr = 1.0;
+	st->mul = st->scl;
+	st->stage = SpotTone_STDY;
+	// won't come back into envelopes
+	// until FALL asserted from outside
+      }
+
+    } else if (st->stage == SpotTone_FALL) {
+
+      // still going?
+      if (st->fall.have++ < st->fall.want) {
+	st->curr -= st->fall.incr;
+	st->mul = st->scl * sin(st->curr * M_PI / 2.0);
+      } else {
+	// no, assert trailing, force level
+	st->curr = 0.0;
+	st->mul = 0.0;
+	st->stage = SpotTone_HOLD;
+	// won't come back into envelopes hereafter
+      }
+    }
+
+    // apply envelope
+    // (same base as osc.gen internal buf)
+    CXBdata(st->buf, i) = Cscl(CXBdata(st->buf, i), st->mul);
+  }
+
+  // indicate whether it's turned itself off
+  // sometime during this pass
+  
+  return st->stage != SpotTone_HOLD;
+}
+
+//------------------------------------------------------------------------
+// turn spotting on with current settings
+
+void
+SpotToneOn(SpotToneGen st) {
+
+  // gain is in dB
+
+  st->scl = pow(10.0, st->gain / 20.0);
+  st->curr = st->mul = 0.0;
+  
+  // A/R times are in msec
+
+  st->rise.want = (int) (0.5 + st->sr * (st->rise.dur / 1e3));
+  st->rise.have = 0;
+  if (st->rise.want <= 1)
+    st->rise.incr = 1.0;
+  else
+    st->rise.incr = 1.0 / (st->rise.want - 1);
+  
+  st->fall.want = (int) (0.5 + st->sr * (st->fall.dur / 1e3));
+  st->fall.have = 0;
+  if (st->fall.want <= 1)
+    st->fall.incr = 1.0;
+  else
+    st->fall.incr = 1.0 / (st->fall.want - 1);
+
+  // freq is in Hz
+
+  OSCfreq(st->osc.gen) = 2.0 * M_PI * st->osc.freq / st->sr;
+  OSCphase(st->osc.gen) = 0.0;
+
+  st->stage = SpotTone_RISE;
+}
+
+//------------------------------------------------------------------------
+// initiate turn-off
+
+void
+SpotToneOff(SpotToneGen st) { st->stage = SpotTone_FALL; }
+
+//------------------------------------------------------------------------
+
+void
+setSpotToneGenVals(SpotToneGen st,
+		   REAL gain,
+		   REAL freq,
+		   REAL rise,
+		   REAL fall) {
+  st->gain = gain;
+  st->osc.freq = freq;
+  st->rise.dur = rise;
+  st->fall.dur = fall;
+}
+
+SpotToneGen
+newSpotToneGen(REAL gain,	// dB
+	       REAL freq,
+	       REAL rise,	// ms
+	       REAL fall,	// ms
+	       int size,
+	       REAL samplerate) {
+
+  SpotToneGen st = (SpotToneGen) safealloc(1,
+					   sizeof(SpotToneGenDesc),
+					   "SpotToneGenDesc");
+
+  setSpotToneGenVals(st, gain, freq, rise, fall);
+  st->size = size;
+  st->sr = samplerate;
+
+  st->osc.gen = newOSC(st->size,
+		       ComplexTone,
+		       st->osc.freq,
+		       0.0,
+		       st->sr,
+		       "SpotTone osc");
+
+  // overload oscillator buf
+  st->buf = newCXB(st->size, OSCCbase(st->osc.gen), "SpotToneGen buf");
+
+  return st;
+}
+
+void
+delSpotToneGen(SpotToneGen st) {
+  if (st) {
+    delCXB(st->buf);
+    delOSC(st->osc.gen);
+    safefree((char *) st);
+  }
+}
diff --git a/jDttSP/spottone.h b/jDttSP/spottone.h
new file mode 100644
index 0000000..1b46240
--- /dev/null
+++ b/jDttSP/spottone.h
@@ -0,0 +1,50 @@
+/* spottone.h */
+
+#ifndef _spottone_h
+#define _spottone_h
+
+#include <fromsys.h>
+#include <banal.h>
+#include <datatypes.h>
+#include <bufvec.h>
+#include <cxops.h>
+#include <oscillator.h>
+
+#define SpotTone_IDLE (0)
+#define SpotTone_WAIT (1)
+#define SpotTone_RISE (2)
+#define SpotTone_STDY (3)
+#define SpotTone_FALL (4)
+#define SpotTone_HOLD (5)
+
+typedef struct _spot_tone_gen {
+  REAL curr, gain, mul, scl, sr;
+  struct {
+    REAL freq;
+    OSC gen;
+  } osc;
+  struct {
+    REAL dur, incr;
+    int want, have;
+  } rise, fall;
+  int size, stage;
+  CXB buf;
+} SpotToneGenDesc, *SpotToneGen;
+
+extern SpotToneGen newSpotToneGen(REAL gain,	// dB
+				  REAL freq,	// Hz
+				  REAL rise,	// msec
+				  REAL fall,	// msec
+				  int size,	// buflen
+				  REAL samplerate);
+extern void delSpotToneGen(SpotToneGen gen);
+extern void setSpotToneGenVals(SpotToneGen gen,
+			       REAL gain,
+			       REAL freq,
+			       REAL rise,
+			       REAL fall);
+extern void SpotToneOn(SpotToneGen gen);
+extern void SpotToneOff(SpotToneGen gen);
+extern BOOLEAN SpotTone(SpotToneGen gen);
+
+#endif
diff --git a/jDttSP/thunk.c b/jDttSP/thunk.c
new file mode 100644
index 0000000..e52d80a
--- /dev/null
+++ b/jDttSP/thunk.c
@@ -0,0 +1,23 @@
+/* thunk.c */
+
+#include <common.h>
+#include <thunk.h>
+
+PRIVATE BOOLEAN
+streq(char *p, char *q) { return !strcmp(p, q); }
+
+/* somewhere along the line
+   we'll kick this up a notch
+   with gperf */
+
+Thunk
+Thunk_lookup(CTB ctb, char *key) {
+  if (key && *key) {
+    for (;;) {
+      if (!ctb || !ctb->key || !ctb->thk) break;
+      if (streq(key, ctb->key)) return ctb->thk;
+      ctb++;
+    }
+  }
+  return (Thunk) 0;
+}
diff --git a/jDttSP/thunk.h b/jDttSP/thunk.h
new file mode 100644
index 0000000..9a16c32
--- /dev/null
+++ b/jDttSP/thunk.h
@@ -0,0 +1,12 @@
+/* thunk.c */
+
+#ifndef _thunk_h
+#define _thunk_h
+
+typedef int (*Thunk)(int n, char **p);
+
+typedef struct _cmd_tbl_entry { char *key; Thunk thk; } CTE, *CTB;
+
+extern Thunk Thunk_lookup(CTB ctb, char *key);
+
+#endif
diff --git a/jDttSP/update.c b/jDttSP/update.c
new file mode 100644
index 0000000..6d2594a
--- /dev/null
+++ b/jDttSP/update.c
@@ -0,0 +1,760 @@
+/* update.c
+
+common defs and code for parm update 
+   
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <common.h>
+
+////////////////////////////////////////////////////////////////////////////
+
+PRIVATE REAL
+dB2lin(REAL dB) { return pow(10.0, dB / 20.0); }
+
+PRIVATE int
+setRXFilter(int n, char **p) {
+  REAL low_frequency  = atof(p[0]),
+       high_frequency = atof(p[1]);
+  int ncoef = uni.buflen + 1;
+  int i, fftlen = 2 * uni.buflen;
+  fftw_plan ptmp;
+  COMPLEX *zcvec;
+
+  if (fabs(low_frequency) >= 0.5 * uni.samplerate) return -1;
+  if (fabs(high_frequency) >= 0.5 * uni.samplerate) return -2;
+  if ((low_frequency + 10) >= high_frequency) return -3;
+  delFIR_COMPLEX(rx.filt.coef);
+
+  rx.filt.coef = newFIR_Bandpass_COMPLEX(low_frequency,
+					 high_frequency,
+					 uni.samplerate,
+					 ncoef);
+
+  zcvec = newvec_COMPLEX(fftlen, "filter z vec in setFilter");
+  ptmp = fftw_create_plan(fftlen, FFTW_FORWARD, uni.wisdom.bits);
+#ifdef LHS
+  for (i = 0; i < ncoef; i++) zcvec[i] = rx.filt.coef->coef[i];
+#else
+  for (i = 0; i < ncoef; i++) zcvec[fftlen - ncoef + i] = rx.filt.coef->coef[i];
+#endif
+  fftw_one(ptmp, (fftw_complex *) zcvec, (fftw_complex *) rx.filt.ovsv->zfvec);
+  fftw_destroy_plan(ptmp);
+  delvec_COMPLEX(zcvec);
+  normalize_vec_COMPLEX(rx.filt.ovsv->zfvec,
+			rx.filt.ovsv->fftlen);
+  memcpy((char *) rx.filt.save,
+	 (char *) rx.filt.ovsv->zfvec,
+	 rx.filt.ovsv->fftlen * sizeof(COMPLEX));
+
+  return 0;
+}
+
+
+PRIVATE int
+setTXFilter(int n, char **p) {
+  REAL low_frequency  = atof(p[0]),
+       high_frequency = atof(p[1]);
+  int ncoef = uni.buflen + 1;
+  int i, fftlen = 2 * uni.buflen;
+  fftw_plan ptmp;
+  COMPLEX *zcvec;
+
+  if (fabs(low_frequency) >= 0.5 * uni.samplerate) return -1;
+  if (fabs(high_frequency) >= 0.5 * uni.samplerate) return -2;
+  if ((low_frequency + 10) >= high_frequency) return -3;
+  delFIR_COMPLEX(tx.filt.coef);
+  tx.filt.coef = newFIR_Bandpass_COMPLEX(low_frequency,
+					 high_frequency,
+					 uni.samplerate,
+					 ncoef);
+  
+  zcvec = newvec_COMPLEX(fftlen, "filter z vec in setFilter");
+  ptmp = fftw_create_plan(fftlen, FFTW_FORWARD, uni.wisdom.bits);
+#ifdef LHS
+  for (i = 0; i < ncoef; i++) zcvec[i] = tx.filt.coef->coef[i];
+#else
+  for (i = 0; i < ncoef; i++) zcvec[fftlen - ncoef + i] = tx.filt.coef->coef[i];
+#endif
+  fftw_one(ptmp, (fftw_complex *) zcvec, (fftw_complex *) tx.filt.ovsv->zfvec);
+  fftw_destroy_plan(ptmp);
+  delvec_COMPLEX(zcvec);
+  normalize_vec_COMPLEX(tx.filt.ovsv->zfvec,
+			tx.filt.ovsv->fftlen);
+  memcpy((char *) tx.filt.save,
+	 (char *) tx.filt.ovsv->zfvec,
+	 tx.filt.ovsv->fftlen * sizeof(COMPLEX));
+
+  return 0;
+}
+
+PRIVATE int
+setFilter(int n, char **p) {
+  if (n == 2) return setRXFilter(n, p);
+  else {
+    int trx = atoi(p[2]);
+    if      (trx == RX) return setRXFilter(n, p);
+    else if (trx == TX) return setTXFilter(n, p);
+    else                return -1;
+  }
+}
+
+// setMode <mode> [TRX]
+
+PRIVATE int
+setMode(int n, char **p) {
+  int mode = atoi(p[0]);
+  if (n > 1) {
+    int trx = atoi(p[1]);
+    switch (trx) {
+    case TX: tx.mode = mode; break;
+    case RX: 
+    default: rx.mode = mode; break;
+    }
+  } else
+    tx.mode = rx.mode = uni.mode.sdr = mode;
+  if (rx.mode == AM) rx.am.gen->mode = AMdet;
+  if (rx.mode == SAM) rx.am.gen->mode = SAMdet;
+  return 0;
+}
+
+// setOsc <freq> [TRX]
+PRIVATE int
+setOsc(int n, char **p) {
+  REAL newfreq = atof(p[0]);
+  if (fabs(newfreq) >= 0.5 * uni.samplerate) return -1;
+  newfreq *= 2.0 * M_PI / uni.samplerate;
+  if (n > 1) {
+    int trx = atoi(p[1]);
+    switch (trx) {
+    case TX: tx.osc.gen->Frequency = newfreq; break;
+    case RX:
+    default: rx.osc.gen->Frequency = newfreq; break;
+    }
+  } else
+    tx.osc.gen->Frequency = rx.osc.gen->Frequency = newfreq;
+  return 0;
+}
+
+PRIVATE int
+setSampleRate(int n, char **p) {
+  REAL samplerate = atof(p[0]);
+  uni.samplerate = samplerate;
+  return 0;
+}
+
+PRIVATE int
+setNR(int n, char **p) {
+  rx.anr.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setANF(int n, char **p) {
+  rx.anf.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setNB(int n, char **p) {
+  rx.nb.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setNBvals(int n, char **p) {
+ REAL threshold = atof(p[0]);
+  rx.nb.gen->threshold = rx.nb.thresh = threshold;
+  return 0;
+}
+
+PRIVATE int
+setSDROM(int n, char **p) {
+  rx.nb_sdrom.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setSDROMvals(int n, char **p) {
+ REAL threshold = atof(p[0]);
+  rx.nb_sdrom.gen->threshold = rx.nb_sdrom.thresh = threshold;
+  return 0;
+}
+
+PRIVATE int
+setBIN(int n, char **p) {
+  rx.bin.flag = atoi(p[0]);
+  return 0;
+}
+
+// setfixedAGC <gain> [TRX]
+PRIVATE int
+setfixedAGC(int n, char **p) {
+  REAL gain = atof(p[0]);
+  if (n > 1) {
+    int trx = atoi(p[1]);
+    switch(trx) {
+    case TX: tx.agc.gen->gain.now = gain; break;
+    case RX:
+    default: rx.agc.gen->gain.now = gain; break;
+    }
+  } else
+    tx.agc.gen->gain.now = rx.agc.gen->gain.now = gain;
+  return 0;
+}
+
+PRIVATE int
+setRXAGC(int n, char **p) {
+  int setit = atoi(p[0]);
+  switch (setit) {
+  case agcOFF:
+    rx.agc.gen->mode = agcOFF;
+    rx.agc.flag = TRUE;
+    break;
+  case agcSLOW:
+    rx.agc.gen->mode = agcSLOW;
+    rx.agc.gen->hang = 10;
+    rx.agc.flag = TRUE;
+    break;
+  case agcMED:
+    rx.agc.gen->mode = agcMED;
+    rx.agc.gen->hang = 6;
+    rx.agc.flag = TRUE;
+    break;
+  case agcFAST:
+    rx.agc.gen->mode = agcFAST;
+    rx.agc.gen->hang = 3;
+    rx.agc.flag = TRUE;
+    break;
+  case agcLONG:
+    rx.agc.gen->mode = agcLONG;
+    rx.agc.gen->hang = 23;
+    rx.agc.flag = TRUE;
+    break;
+  }
+  return 0;
+}
+
+PRIVATE int
+setRXAGCCompression(int n, char **p) {
+  REAL rxcompression = atof(p[0]);
+  rx.agc.gen->gain.top = pow(10.0 , rxcompression * 0.05);
+  return 0;
+}
+
+PRIVATE int
+setRXAGCHang(int n, char **p) {
+  int hang = atoi(p[0]);
+  rx.agc.gen->hang =
+    max(1,
+	min(23,
+	    hang * uni.samplerate / (1e3 * uni.buflen)));
+  return 0;
+}
+
+PRIVATE int
+setRXAGCLimit(int n, char **p) {
+  REAL limit = atof(p[0]);
+  rx.agc.gen->gain.lim = 0.001 * limit;
+  return 0;
+}
+
+PRIVATE int
+setTXAGC(int n, char **p) {
+  int setit = atoi(p[0]);
+  switch (setit) {
+  case agcOFF:
+    tx.agc.gen->mode = agcOFF;
+    tx.agc.flag = FALSE;
+    break;
+  case agcSLOW:
+    tx.agc.gen->mode = agcSLOW;
+    tx.agc.gen->hang = 10;
+    tx.agc.flag = TRUE;
+    break;
+  case agcMED:
+    tx.agc.gen->mode = agcMED;
+    tx.agc.gen->hang = 6;
+    tx.agc.flag = TRUE;
+    break;
+  case agcFAST:
+    tx.agc.gen->mode = agcFAST;
+    tx.agc.gen->hang = 3;
+    tx.agc.flag = TRUE;
+    break;
+  case agcLONG:
+    tx.agc.gen->mode = agcLONG;
+    tx.agc.gen->hang = 23;
+    tx.agc.flag = TRUE;
+    break;
+  }
+  return 0;
+}
+
+PRIVATE int
+setTXAGCCompression(int n, char **p) {
+  REAL txcompression = atof(p[0]);
+  tx.agc.gen->gain.top = pow(10.0 , txcompression * 0.05);
+  return 0;
+}
+
+PRIVATE int
+setTXAGCFF(int n, char **p) {
+  tx.spr.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setTXAGCFFCompression(int n, char **p) {
+  REAL txcompression = atof(p[0]);
+  tx.spr.gen->MaxGain = pow(10.0 , txcompression * 0.05);
+  return 0;
+}
+
+PRIVATE int
+setTXAGCHang(int n, char **p) {
+  int hang = atoi(p[0]);
+  tx.agc.gen->hang =
+    max(1,
+	min(23,
+	    hang * uni.samplerate / (1e3 * uni.buflen)));
+  return 0;
+}
+
+PRIVATE int
+setTXAGCLimit(int n, char **p) {
+  REAL limit = atof(p[0]);
+  tx.agc.gen->gain.lim = 0.001 * limit;
+  return 0;
+}
+
+PRIVATE int
+setTXSpeechCompression(int n, char **p) {
+  tx.spr.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setTXSpeechCompressionGain(int n, char **p) {
+  tx.spr.gen->MaxGain = dB2lin(atof(p[0]));
+  return 0;
+}
+
+//============================================================
+
+PRIVATE int
+f2x(REAL f) {
+  REAL fix = tx.filt.ovsv->fftlen * f / uni.samplerate;
+  return (int) (fix + 0.5);
+}
+
+//------------------------------------------------------------
+
+PRIVATE void
+apply_txeq_band(REAL lof, REAL dB, REAL hif) {
+  int i,
+      lox = f2x(lof),
+      hix = f2x(hif),
+      l = tx.filt.ovsv->fftlen;
+  REAL g = dB2lin(dB);
+  COMPLEX *src = tx.filt.save,
+          *trg = tx.filt.ovsv->zfvec;
+   for (i = lox; i < hix; i++) {
+    trg[i] = Cscl(src[i], g);
+    if (i) {
+      int j = l - i;
+      trg[j] = Cscl(src[j], g);
+    }
+  }
+}
+
+// typical:
+// 0 dB1 75 dB2 150 dB3 300 dB4 600 dB5 1200 dB6 2000 dB7 2800 dB8 3600
+// approximates W2IHY bandcenters.
+// no args, revert to no EQ.
+PRIVATE int
+setTXEQ(int n, char **p) {
+  if (n < 3) {
+    // revert to no EQ
+    memcpy((char *) tx.filt.ovsv->zfvec,
+	   (char *) tx.filt.save,
+	   tx.filt.ovsv->fftlen * sizeof(COMPLEX));
+    return 0;
+  } else {
+    int i;
+    REAL lof = atof(p[0]);
+    for (i = 0; i < n - 2; i += 2) {
+      REAL dB = atof(p[i + 1]),
+	   hif = atof(p[i + 2]);
+      if (lof < 0.0 || hif <= lof) return -1;
+      apply_txeq_band(lof, dB, hif);
+      lof = hif;
+    }
+    return 0;
+  }
+}
+
+//------------------------------------------------------------
+
+PRIVATE void
+apply_rxeq_band(REAL lof, REAL dB, REAL hif) {
+  int i,
+      lox = f2x(lof),
+      hix = f2x(hif),
+      l = rx.filt.ovsv->fftlen;
+  REAL g = dB2lin(dB);
+  COMPLEX *src = rx.filt.save,
+          *trg = rx.filt.ovsv->zfvec;
+  for (i = lox; i < hix; i++) {
+    trg[i] = Cscl(src[i], g);
+    if (i) {
+      int j = l - i;
+      trg[j] = Cscl(src[j], g);
+    }
+  }
+}
+
+PRIVATE int
+setRXEQ(int n, char **p) {
+  if (n < 3) {
+    // revert to no EQ
+    memcpy((char *) rx.filt.ovsv->zfvec,
+	   (char *) rx.filt.save,
+	   rx.filt.ovsv->fftlen * sizeof(COMPLEX));
+    return 0;
+  } else {
+    int i;
+    REAL lof = atof(p[0]);
+    for (i = 0; i < n - 2; i += 2) {
+      REAL dB = atof(p[i + 1]),
+	   hif = atof(p[i + 2]);
+      if (lof < 0.0 || hif <= lof) return -1;
+      apply_rxeq_band(lof, dB, hif);
+      lof = hif;
+    }
+    return 0;
+  }
+}
+
+//============================================================
+
+PRIVATE int
+setANFvals(int n, char **p) {
+  int taps  = atoi(p[0]),
+      delay = atoi(p[1]);
+  REAL gain = atof(p[2]),
+       leak = atof(p[3]);
+  rx.anf.gen->adaptive_filter_size = taps;
+  rx.anf.gen->delay = delay;
+  rx.anf.gen->adaptation_rate = gain;
+  rx.anf.gen->leakage = leak;
+  return 0;
+}
+
+PRIVATE int
+setNRvals(int n, char **p) {
+  int taps  = atoi(p[0]),
+      delay = atoi(p[1]);
+  REAL gain = atof(p[2]),
+       leak = atof(p[3]);
+  rx.anr.gen->adaptive_filter_size = taps;
+  rx.anr.gen->delay = delay;
+  rx.anr.gen->adaptation_rate = gain;
+  rx.anr.gen->leakage = leak;
+  return 0;
+}
+
+PRIVATE int
+setcorrectIQ(int n, char **p) {
+  int phaseadjustment = atoi(p[0]),
+      gainadjustment  = atoi(p[1]);
+  rx.iqfix->phase = 0.001 * (REAL) phaseadjustment;
+  rx.iqfix->gain  = 1.0+ 0.001 * (REAL) gainadjustment;
+  return 0;
+}
+
+PRIVATE int
+setcorrectIQphase(int n, char **p) {
+  int phaseadjustment = atoi(p[0]);
+  rx.iqfix->phase = 0.001 * (REAL) phaseadjustment;
+  return 0;
+}
+
+PRIVATE int
+setcorrectIQgain(int n, char **p) {
+  int gainadjustment = atoi(p[0]);
+  rx.iqfix->gain = 1.0 + 0.001 * (REAL) gainadjustment;
+  return 0;
+}
+
+PRIVATE int
+setSquelch(int n, char **p) {
+  rx.squelch.thresh = -atof(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setMeterOffset(int n, char **p) {
+  rx.squelch.offset.meter = atof(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setATTOffset(int n, char **p) {
+  rx.squelch.offset.att = atof(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setGainOffset(int n, char **p) {
+  rx.squelch.offset.gain = atof(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setSquelchSt(int n, char **p) {
+  rx.squelch.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setTRX(int n, char **p) {
+  uni.mode.trx = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setRunState(int n, char **p) {
+  RUNMODE rs = (RUNMODE) atoi(p[0]);
+  top.state = rs;
+  return 0;
+}
+
+PRIVATE int
+setSpotToneVals(int n, char **p) {
+  REAL gain = atof(p[0]),
+       freq = atof(p[1]),
+       rise = atof(p[2]),
+       fall = atof(p[3]);
+  setSpotToneGenVals(rx.spot.gen, gain, freq, rise, fall);
+  return 0;
+}
+
+PRIVATE int
+setSpotTone(int n, char **p) {
+  if (atoi(p[0])) {
+    SpotToneOn(rx.spot.gen);
+    rx.spot.flag = TRUE;
+  } else
+    SpotToneOff(rx.spot.gen);
+  return 0;
+}
+
+PRIVATE int
+setRXPreScl(int n, char **p) {
+  rx.scl.pre.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setRXPreSclVal(int n, char **p) {
+  rx.scl.pre.val = dB2lin(atof(p[0]));
+  return 0;
+}
+
+PRIVATE int
+setTXPreScl(int n, char **p) {
+  tx.scl.pre.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setTXPreSclVal(int n, char **p) {
+  tx.scl.pre.val = dB2lin(atof(p[0]));
+  return 0;
+}
+
+PRIVATE int
+setRXPostScl(int n, char **p) {
+  rx.scl.post.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setRXPostSclVal(int n, char **p) {
+  rx.scl.post.val = dB2lin(atof(p[0]));
+  return 0;
+}
+
+PRIVATE int
+setTXPostScl(int n, char **p) {
+  tx.scl.post.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setTXPostSclVal(int n, char **p) {
+  tx.scl.post.val = dB2lin(atof(p[0]));
+  return 0;
+}
+
+PRIVATE int
+setFinished(int n, char **p) {
+  top.running = FALSE;
+  pthread_cancel(top.thrd.trx.id);
+  pthread_cancel(top.thrd.upd.id);
+  pthread_cancel(top.thrd.mon.id);
+  return 0;
+}
+
+// next-trx-mode [nbufs-to-zap]
+PRIVATE int
+setSWCH(int n, char **p) {
+  top.swch.trx.next = atoi(p[0]);
+  if (n > 1) top.swch.bfct.want = atoi(p[1]);
+  else top.swch.bfct.want = 0;
+  top.swch.bfct.have = 0;
+  top.swch.run.last = top.state;
+  top.state = RUN_SWCH;
+  return 0;
+}
+
+PRIVATE int
+setMonDump(int n, char **p) {
+  sem_post(&top.sync.mon.sem);
+  return 0;
+}
+
+PRIVATE int
+setRingBufferReset(int n, char **p) {
+  extern void clear_jack_ringbuffer(jack_ringbuffer_t *rb, int nbytes);
+  jack_ringbuffer_reset(top.jack.ring.i.l);
+  jack_ringbuffer_reset(top.jack.ring.i.r);
+  jack_ringbuffer_reset(top.jack.ring.o.l);
+  jack_ringbuffer_reset(top.jack.ring.o.r);
+  clear_jack_ringbuffer(top.jack.ring.o.l, top.hold.size.bytes);
+  clear_jack_ringbuffer(top.jack.ring.o.r, top.hold.size.bytes);
+  return 0;
+}
+
+//========================================================================
+
+#include <thunk.h>
+
+CTE update_cmds[] = {
+  {"setANF", setANF},
+  {"setANFvals", setANFvals},
+  {"setATTOffset", setATTOffset},
+  {"setBIN", setBIN},
+  {"setFilter", setFilter},
+  {"setFinished", setFinished},
+  {"setGainOffset", setGainOffset},
+  {"setMeterOffset", setMeterOffset},
+  {"setMode", setMode},
+  {"setNB", setNB},
+  {"setNBvals", setNBvals},
+  {"setNR", setNR},
+  {"setNRvals", setNRvals},
+  {"setOsc", setOsc},
+  {"setRXAGC", setRXAGC},
+  {"setRXAGCCompression", setRXAGCCompression},
+  {"setRXAGCHang", setRXAGCHang},
+  {"setRXAGCLimit", setRXAGCLimit},
+  {"setRXEQ", setRXEQ},
+  {"setRXPostScl", setRXPostScl},
+  {"setRXPostSclVal", setRXPostSclVal},
+  {"setRXPreScl", setRXPreScl},
+  {"setRXPreSclVal", setRXPreSclVal},
+  {"setRunState", setRunState},
+  {"setSDROM", setSDROM},
+  {"setSDROMvals",setSDROMvals},
+  {"setSWCH", setSWCH},
+  {"setSampleRate", setSampleRate},
+  {"setSpotTone", setSpotTone},
+  {"setSpotToneVals", setSpotToneVals},
+  {"setSquelch", setSquelch},
+  {"setSquelchSt", setSquelchSt},
+  {"setTRX", setTRX},
+  {"setTXAGC", setTXAGC},
+  {"setTXAGCCompression", setTXAGCCompression},
+  {"setTXAGCFFCompression",setTXAGCFFCompression},
+  {"setTXAGCHang", setTXAGCHang},
+  {"setTXAGCLimit", setTXAGCLimit},
+  {"setTXEQ", setTXEQ},
+  {"setTXPostScl", setTXPostScl},
+  {"setTXPostSclVal", setTXPostSclVal},
+  {"setTXPreScl", setTXPreScl},
+  {"setTXPreSclVal", setTXPreSclVal},
+  {"setTXSpeechCompression", setTXSpeechCompression},
+  {"setTXSpeechCompressionGain", setTXSpeechCompressionGain},
+  {"setcorrectIQ", setcorrectIQ},
+  {"setcorrectIQgain", setcorrectIQgain},
+  {"setcorrectIQphase", setcorrectIQphase},
+  {"setfixedAGC", setfixedAGC},
+  {"setMonDump", setMonDump},
+  {"setRingBufferReset", setRingBufferReset},
+  { 0, 0 }
+};
+
+//........................................................................
+
+int
+do_update(char *str, FILE *log) {
+  SPLIT splt = &uni.update.splt;
+
+  split(splt, str);
+
+  if (NF(splt) < 1) return -1;
+
+  else {
+    Thunk thk = Thunk_lookup(update_cmds, F(splt, 0));
+    if (!thk) return -1;
+    else {
+      int val;
+
+      sem_wait(&top.sync.upd.sem);
+      val = (*thk)(NF(splt) - 1, Fptr(splt, 1));
+      sem_post(&top.sync.upd.sem);
+
+      if (log) {
+	int i;
+	char *s = since(&top.start_tv);
+	fprintf(log, "update[%s]: returned %d from", s, val);
+	for (i = 0; i < NF(splt); i++)
+	  fprintf(log, " %s", F(splt, i));
+	putc('\n', log);
+	fflush(log);
+      }
+
+      return val;
+    }
+  }
+}
diff --git a/jDttSP/update.h b/jDttSP/update.h
new file mode 100644
index 0000000..b0de3c7
--- /dev/null
+++ b/jDttSP/update.h
@@ -0,0 +1,45 @@
+/* update.h
+
+common defs and code for parm update
+   
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _update_h
+#define _update_h
+
+#include <fromsys.h>
+#include <banal.h>
+#include <datatypes.h>
+
+extern int do_update(char *str, FILE *log);
+
+#endif
diff --git a/jDttSP/win/banal.c b/jDttSP/win/banal.c
new file mode 100644
index 0000000..154ba40
--- /dev/null
+++ b/jDttSP/win/banal.c
@@ -0,0 +1,152 @@
+/* banal.c
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <fromsys.h>
+#include <banal.h>
+
+int
+in_blocks(int count, int block_size) {
+  if (block_size < 1) {
+    fprintf(stderr, "block_size zero in in_blocks\n");
+    exit(1);
+  }
+  return (1 + ((count - 1) / block_size));
+}
+
+FILE *
+efopen(char *path, char *mode) {
+  FILE *iop = fopen(path, mode);
+  if (!iop) {
+    fprintf(stderr, "can't open \"%s\" in mode \"%s\"\n", path, mode);
+    exit(1);
+  }
+  return iop;
+}
+
+FILE *
+efreopen(char *path, char *mode, FILE *strm) {
+  FILE *iop = freopen(path, mode, strm);
+  if (!iop) {
+    fprintf(stderr, "can't reopen \"%s\" in mode \"%s\"\n", path, mode);
+    exit(1);
+  }
+  return iop;
+}
+
+size_t
+filesize(char *path) {
+  struct stat sbuf;
+  if (stat(path, &sbuf) == -1) return -1;
+  return sbuf.st_size;
+}
+
+size_t
+fdsize(int fd) {
+  struct stat sbuf;
+  if (fstat(fd, &sbuf) == -1) return -1;
+  return sbuf.st_size;
+}
+
+#define MILLION (1000000)
+#ifndef _WINDOWS
+// return current tv
+struct timeval
+now_tv(void) {
+  struct timeval tv;
+  gettimeofday(&tv, 0);
+  return tv;
+}
+
+// return ta - tb
+struct timeval
+diff_tv(struct timeval *ta, struct timeval *tb) {
+  struct timeval tv;
+  if (tb->tv_usec > ta->tv_usec) {
+    ta->tv_sec--;
+    ta->tv_usec += MILLION;
+  }
+  tv.tv_sec = ta->tv_sec - tb->tv_sec;
+  if ((tv.tv_usec = ta->tv_usec - tb->tv_usec) >= MILLION) {
+    tv.tv_usec -= MILLION;
+    tv.tv_sec++;
+  }
+  return tv;
+}
+
+// return ta + tb
+struct timeval
+sum_tv(struct timeval *ta, struct timeval *tb) {
+  struct timeval tv; 
+  tv.tv_sec = ta->tv_sec + tb->tv_sec;
+  if ((tv.tv_usec = ta->tv_usec + tb->tv_usec) >= MILLION) {
+    tv.tv_usec -= MILLION;
+    tv.tv_sec++;
+  }
+  return tv;
+}
+
+char *
+fmt_tv(struct timeval *tv) {
+#ifndef _WINDOWS
+  static char buff[256];
+  snprintf(buff, sizeof(buff), "%ds%du", tv->tv_sec, tv->tv_usec);
+#else
+  static char buff[512];
+  sprintf(buff, "%ds%du", tv->tv_sec, tv->tv_usec);
+#endif
+  return buff;
+}
+
+char *
+since(struct timeval *tv) {
+  struct timeval nt = now_tv(),
+                 dt = diff_tv(&nt, tv);
+  return fmt_tv(&dt);
+}
+#endif
+
+int
+hinterp_vec(REAL *u, int m, REAL *v, int n) {
+  if (!u || !v || (n < 2) || (m < n) || (m % n)) return 0;
+  else {
+    int div = m / n, i, j = 0;
+    for (i = 1; i < n; i++) {
+      int k;
+      REAL vl = v[i - 1], del = (v[i] - vl) / div;
+      u[j++] = vl;
+      for (k = 1; k < div; k++) u[j++] = vl + k * del;
+    }
+    u[j++] = v[n - 1];
+    return j;
+  }
+}
diff --git a/jDttSP/win/banal.h b/jDttSP/win/banal.h
new file mode 100644
index 0000000..4e4380d
--- /dev/null
+++ b/jDttSP/win/banal.h
@@ -0,0 +1,95 @@
+/* banal.h
+   stuff we're too embarrassed to declare otherwise
+   
+  This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _banal_h
+
+#define _banal_h
+
+#include <fromsys.h>
+#ifndef min
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#endif
+#ifndef max
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#endif
+#define abs(a) ((a) >= 0 ? (a) : -(a))
+
+#define MONDO 1e15
+#define BITSY 1e-15
+
+#define TRUE 1
+#define FALSE 0
+
+_inline void
+nilfunc(void) {}
+
+_inline double
+sqr(double x) { return x * x; }
+
+_inline int
+popcnt(int k) {
+  int c, i;
+  c = k & 01;
+  for (i = 1; i < 32; i++) c += (k >> i) & 01;
+  return c;
+}
+
+_inline int
+npoof2(int n) {
+  int i = 0;
+  --n;
+  while (n > 0) n >>= 1, i++;
+  return i;
+}
+
+_inline int
+nblock2(int n) { return 1 << npoof2(n); }
+
+extern int in_blocks(int count, int block_size);
+extern FILE *efopen(char *path, char *mode);
+extern FILE *efreopen(char *path, char *mode, FILE *strm);
+extern size_t filesize(char *path);
+extern size_t fdsize(int fd);
+#ifndef _WINDOWS
+extern struct timeval now_tv(void);
+extern struct timeval diff_tv(struct timeval *, struct timeval *);
+extern struct timeval sum_tv(struct timeval *, struct timeval *);
+extern char *fmt_tv(struct timeval *);
+extern char *since(struct timeval *);
+extern struct timeval now_tv(void);
+#endif
+extern int hinterp_vec(REAL *, int, REAL *, int);
+#endif
+
+
diff --git a/jDttSP/win/chan.c b/jDttSP/win/chan.c
new file mode 100644
index 0000000..68889b0
--- /dev/null
+++ b/jDttSP/win/chan.c
@@ -0,0 +1,113 @@
+/* chan.c
+
+fast inter-user-process single-reader/single-writer channels
+using a modified version of jack ringbuffers and memory-mapped files.
+   
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807 
+*/
+
+#include <chan.h>
+
+//------------------------------------------------------------------------
+
+size_t
+putChan(Chan c, char *data, size_t size) {
+  return ringb_write(c->rb, data, size);
+}
+
+size_t
+getChan(Chan c, char *data, size_t size) {
+  return ringb_read(c->rb, data, size);
+}
+
+BOOLEAN
+putChan_nowait(Chan c, char *data, size_t size) {
+  if (ringb_write_space(c->rb) >= size) {
+    ringb_write(c->rb, data, size);
+    return TRUE;
+  } else return FALSE;
+}
+
+BOOLEAN
+getChan_nowait(Chan c, char *data, size_t size) {
+  if (ringb_read_space(c->rb) >= size) {
+    ringb_read(c->rb, data, size);
+    return TRUE;
+  } else return FALSE;
+}
+
+Chan
+openChan(char *path,size_t want) {
+  Chan c = (Chan) safealloc(sizeof(ChanDesc), 1, "Chan header");
+  c->size.rib = sizeof(ringb_t);
+  c->size.buf = (size_t) nblock2((int) want);
+#ifndef _WINDOWS
+  c->file.path = path;
+  if ((c->file.desc = open(c->file.path, O_RDWR)) == -1) {
+    fprintf(stderr, "can't open Chan file %s\n", c->file.path);
+    exit(1);
+  }
+  c->size.tot = c->size.rib + c->size.buf;
+  if ((c->size.tru = fdsize(c->file.desc)) < c->size.tot) {
+    fprintf(stderr,
+	    "Chan file %s is too small (%d) for required size (%s)\n",
+	    c->file.path, c->size.tru, c->size.tot);
+    exit(1);
+  }
+  if (!(c->map.base = (char *) mmap(0,
+				    c->size.tot,
+				    PROT_READ | PROT_WRITE,
+				    MAP_SHARED,
+				    c->file.desc,
+				    0))) {
+    fprintf(stderr, "can't memory map %s for Chan\n",
+	    c->file.path);
+    exit(1);
+  }
+#endif
+  if (!(c->rb = ringb_create(c->size.buf))) {
+    fprintf(stderr, "can't make RB for Chan\n");
+    exit(1);
+  }
+  return c;
+}
+
+void
+closeChan(Chan c) {
+  if (c) {
+#ifndef _WINDOWS
+    munmap(c->map.base, c->size.tot);
+    close(c->file.desc);
+#endif
+    ringb_destroy(c->rb);
+    safefree((char *) c);
+  }
+}
diff --git a/jDttSP/win/chan.h b/jDttSP/win/chan.h
new file mode 100644
index 0000000..eecc507
--- /dev/null
+++ b/jDttSP/win/chan.h
@@ -0,0 +1,77 @@
+/* chan.h
+
+fast inter-user-process single-reader/single-writer channels
+using a modified version of jack ringbuffers and memory-mapped files.
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _chan_h
+#define _chan_h
+
+#include <sys/types.h>
+#include <stdlib.h>
+#include <banal.h>
+#include <bufvec.h>
+#ifndef _WINDOWS
+#include <values.h>
+#else
+#include <windows.h>
+#endif
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <ringb.h>
+
+
+typedef
+struct _chan {
+  struct {
+    size_t buf, rib, tot, tru;
+  } size;
+  struct {
+    char *path;
+    int desc;
+  } file;
+  struct {
+    char *base;
+  } map;
+  ringb_t *rb;
+} ChanDesc, *Chan;
+
+extern size_t putChan(Chan c, char *data, size_t size);
+extern size_t getChan(Chan c, char *data, size_t size);
+extern BOOLEAN putChan_nowait(Chan c, char *data, size_t size);
+extern BOOLEAN getChan_nowait(Chan c, char *data, size_t size);
+extern Chan openChan(char *path,size_t want);
+extern void closeChan(Chan c);
+
+#endif
diff --git a/jDttSP/win/common.h b/jDttSP/win/common.h
new file mode 100644
index 0000000..09121a2
--- /dev/null
+++ b/jDttSP/win/common.h
@@ -0,0 +1,78 @@
+/* common.h
+a simple way to get all the necessary includes
+   
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _common_h
+
+#define _common_h
+
+#include <fromsys.h>
+#include <banal.h>
+#include <splitfields.h>
+#include <datatypes.h>
+#include <bufvec.h>
+#include <cxops.h>
+#include <ringb.h>
+#include <chan.h>
+#include <fft.h>
+#include <lmadf.h>
+#include <fftw.h>
+#include <ovsv.h>
+#include <filter.h>
+#include <oscillator.h>
+#include <digitalagc.h>
+#include <am_demod.h>
+#include <fm_demod.h>
+#include <noiseblanker.h>
+#include <correctIQ.h>
+#include <crc16.h>
+#include <speechproc.h>
+#include <spottone.h>
+#include <update.h>
+#include <power_spectrum.h>
+#include <meter.h>
+#ifdef _WINDOWS
+#include <ringb.h>
+#include <windows.h>
+typedef long pid_t;
+typedef long uid_t;
+typedef LPDWORD pthread_t;
+typedef HANDLE sem_t;
+#define DLLVERS
+//#define PROCESSVERS
+#define NEWSPLIT
+#endif
+
+#include <sdrexport.h>
+#endif
+
diff --git a/jDttSP/win/datatypes.h b/jDttSP/win/datatypes.h
new file mode 100644
index 0000000..74b3dc6
--- /dev/null
+++ b/jDttSP/win/datatypes.h
@@ -0,0 +1,56 @@
+/* datatypes.h
+   local definitions and aliases for our data
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _datatypes_h
+
+#define _datatypes_h
+
+#include <fromsys.h>
+#include <banal.h>
+#ifndef _WINDOWS
+typedef int BOOLEAN;
+#else
+typedef unsigned char BOOLEAN;
+#endif
+typedef double REAL;
+typedef double IMAG;
+typedef short SAMPLE_16t;
+
+#include <complex.h>
+
+#ifndef PRIVATE
+#define PRIVATE static
+#endif
+
+#endif
+
diff --git a/jDttSP/win/fromsys.h b/jDttSP/win/fromsys.h
new file mode 100644
index 0000000..c943da9
--- /dev/null
+++ b/jDttSP/win/fromsys.h
@@ -0,0 +1,95 @@
+/* fromsys.h
+   stuff we need to import everywhere 
+ This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _fromsys_h
+#define _fromsys_h
+#ifndef _WINDOWS 
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/wait.h>  
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>  
+#include <signal.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <setjmp.h>
+
+#include <stdlib.h>
+#include <values.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <math.h>
+#include <assert.h>
+#include <libgen.h>
+
+#include <pthread.h>
+#include <semaphore.h>
+
+#include <jack/jack.h>
+#include <jack/ringbuffer.h>
+#define DttSP_EXP
+
+#else
+
+#include <sys/types.h>
+//#include <sys/param.h> // WINBLOWS
+#define MAXPATHLEN (260-1 /* NULL */)
+#include <sys/stat.h>
+#include <time.h>
+//#include <unistd.h>
+#include <fcntl.h>
+
+#include <stdlib.h>
+#include <windows.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <math.h>
+#ifndef M_PI
+#define M_PI 3.14159265358928
+#endif
+#include <assert.h>
+#define DttSP_EXP __declspec(dllexport)
+#define DttSP_IMP __declspec(dllimport)
+
+#define sem_wait(p) WaitForSingleObject(p,INFINITE)
+#define sem_post(p) ReleaseSemaphore(p,1,NULL);
+#define pthread_exit(p) ExitThread((DWORD)p)
+
+#endif  // _WINDOWS
+#endif // _fromsys_h
diff --git a/jDttSP/win/main.c b/jDttSP/win/main.c
new file mode 100644
index 0000000..96c3cda
--- /dev/null
+++ b/jDttSP/win/main.c
@@ -0,0 +1,534 @@
+/* main.c
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/  
+  
+#include <common.h>
+  
+/////////////////////////////////////////////////////////////////////////
+extern void process_samples(float *, float *, int);
+extern void setup_workspace(void);
+
+#ifdef _WINDOWS
+  
+#define PARMPATH NULL
+#define RINGMULT (4)
+#define METERPATH NULL
+#define METERMULT (2)
+#define PWSPATH NULL
+#define PWSMULT (32768)
+#define TEST
+
+#else
+  
+#define PARMPATH "./IPC/SDR-1000-0-commands.fifo"
+#define RINGMULT (4)
+#define METERPATH "./IPC/SDR-1000-0-meter.chan"
+#define METERMULT (2)
+#define PWSPATH "./IPC/SDR-1000-0-pws.chan"
+#define PWSMULT (32768)
+  
+#endif
+//------------------------------------------------------------------------
+  
+#ifdef _WINDOWS
+PRIVATE DWORD WINAPI
+process_updates_thread(void) {
+  size_t tmp;
+  while (top.running) {
+    while (newupdates()) {
+      tmp = ringb_read_space(uni.update.chan.c->rb);
+      getChan_nowait(uni.update.chan.c, top.parm.buff, tmp);
+      do_update(top.parm.buff);
+    }
+  }
+  ExitThread(0);
+}
+
+//========================================================================
+
+PRIVATE void 
+gethold(void) {
+  ringb_write(top.jack.ring.o.l, (char *) top.hold.buf.l, top.hold.size.bytes);
+  ringb_write(top.jack.ring.o.r, (char *) top.hold.buf.r, top.hold.size.bytes);
+  ringb_read(top.jack.ring.i.l, (char *) top.hold.buf.l, top.hold.size.bytes);
+  ringb_read(top.jack.ring.i.r, (char *) top.hold.buf.r, top.hold.size.bytes);
+}
+
+PRIVATE BOOLEAN canhold(void) {
+  return ringb_read_space(top.jack.ring.i.l) >= top.hold.size.bytes;
+}
+
+
+#else
+
+//========================================================================
+
+PRIVATE void 
+process_updates_thread(void) {
+  while (top.running) {
+    while (fgets(top.parm.buff, sizeof(top.parm.buff), top.parm.fp))
+      do_update(top.parm.buff, top.verbose ? stderr : 0);
+  }
+  pthread_exit(0);
+}
+
+PRIVATE void 
+gethold(void) {
+  jack_ringbuffer_write(top.jack.ring.o.l, (char *) top.hold.buf.l, top.hold.size.bytes);
+  jack_ringbuffer_write(top.jack.ring.o.r, (char *) top.hold.buf.r, top.hold.size.bytes);
+  jack_ringbuffer_read(top.jack.ring.i.l, (char *) top.hold.buf.l, top.hold.size.bytes);
+  jack_ringbuffer_read(top.jack.ring.i.r, (char *) top.hold.buf.r, top.hold.size.bytes);
+}
+
+PRIVATE BOOLEAN canhold(void) {
+  return jack_ringbuffer_read_space(top.jack.ring.i.l) >= top.hold.size.bytes;
+}
+
+#endif
+
+PRIVATE void 
+run_mute(void) {
+  memset((char *) top.hold.buf.l, 0, top.hold.size.bytes);
+  memset((char *) top.hold.buf.r, 0, top.hold.size.bytes);
+}
+
+PRIVATE void 
+run_pass(void) {}
+
+PRIVATE void 
+run_play(void) {
+  process_samples(top.hold.buf.l, top.hold.buf.r, top.hold.size.frames);
+} 
+
+// NB do not set RUN_SWCH directly via setRunState;
+// use setSWCH instead
+
+PRIVATE void 
+run_swch(void) {
+  if (top.swch.bfct.have == 0) {
+    // first time
+    // apply ramp down
+    int i, m = top.swch.fade, n = top.swch.tail;
+    for (i = 0; i < m; i++) {
+      float w = (float) 1.0 - (float) i / m;
+      top.hold.buf.l[i] *= w, top.hold.buf.r[i] *= w;
+    }
+    memset((char *) (top.hold.buf.l + m), 0, n);
+    memset((char *) (top.hold.buf.r + m), 0, n);
+    top.swch.bfct.have++;
+  } else if (top.swch.bfct.have < top.swch.bfct.want) {
+    // in medias res
+    memset((char *) top.hold.buf.l, 0, top.hold.size.bytes);
+    memset((char *) top.hold.buf.r, 0, top.hold.size.bytes);
+    top.swch.bfct.have++;
+  } else {
+    // last time
+    // apply ramp up
+    int i, m = top.swch.fade, n = top.swch.tail;
+    for (i = 0; i < m; i++) {
+      float w = (float) i / m;
+      top.hold.buf.l[i] *= w, top.hold.buf.r[i] *= w;
+    }
+    uni.mode.trx = top.swch.trx.next;
+    top.state = top.swch.run.last;
+    top.swch.bfct.want = top.swch.bfct.have = 0;
+  }
+
+  process_samples(top.hold.buf.l, top.hold.buf.r, top.hold.size.frames);
+} 
+
+//========================================================================
+
+#ifdef _WINDOWS
+
+static int exchptr = 0;
+DttSP_EXP void 
+exchange_samples(float *input, float *output, int nframes) {
+  int i, j;
+  for (i = 0, j = 0; i < nframes; i++, j += 2) {
+    ringb_read(top.jack.ring.o.l, (char *) &output[j], sizeof(float));
+    ringb_read(top.jack.ring.o.r, (char *) &output[j + 1], sizeof(float));
+    ringb_write(top.jack.ring.i.l, (char *) &input[j], sizeof(float));
+    ringb_write(top.jack.ring.i.r, (char *) &input[j + 1], sizeof(float));
+  }
+  if (ringb_read_space(top.jack.ring.i.l) >= top.hold.size.bytes)
+    ReleaseSemaphore(top.sync.buf.sem, 1L, NULL);
+}
+
+DttSP_EXP void
+audioreset(void) { exchptr = 0; }
+
+PRIVATE DWORD WINAPI
+process_samples_thread(void) {
+  while (top.running) {
+    WaitForSingleObject(top.sync.buf.sem, INFINITE);
+    WaitForSingleObject(top.sync.upd.sem, INFINITE);
+    do {
+      gethold();
+      switch (top.state) {
+      case RUN_MUTE:
+	run_mute();
+	break;
+      case RUN_PASS:
+	run_pass();
+	break;
+      case RUN_PLAY:
+	run_play();
+	break;
+      case RUN_SWCH:
+	run_swch();
+	break;
+      }
+    } while (canhold());
+    ReleaseSemaphore(top.sync.upd.sem, 1L, NULL);
+  }
+  ExitThread(0);
+  return 1;
+}
+  
+#else	/*  */
+
+PRIVATE void 
+audio_callback(jack_nframes_t nframes, void *arg) {
+  float *lp, *rp;
+  int nbytes = nframes * sizeof(float);
+  
+  // output: copy from ring to port
+  lp = (float *) jack_port_get_buffer(top.jack.port.o.l, nframes);
+  rp = (float *) jack_port_get_buffer(top.jack.port.o.r, nframes);
+  jack_ringbuffer_read(top.jack.ring.o.l, (char *) lp, nbytes);
+  jack_ringbuffer_read(top.jack.ring.o.r, (char *) rp, nbytes);
+  
+  // input: copy from port to ring
+  lp = (float *) jack_port_get_buffer(top.jack.port.i.l, nframes);
+  rp = (float *) jack_port_get_buffer(top.jack.port.i.r, nframes);
+  jack_ringbuffer_write(top.jack.ring.i.l, (char *) lp, nbytes);
+  jack_ringbuffer_write(top.jack.ring.i.r, (char *) rp, nbytes);
+  
+  // if enough accumulated in ring, fire dsp
+  if (jack_ringbuffer_read_space(top.jack.ring.i.l) >= top.hold.size.bytes)
+    sem_post(&top.sync.buf.sem);
+}
+
+PRIVATE void 
+process_samples_thread(void) {
+  while (top.running) {
+    sem_wait(&top.sync.buf.sem);
+    do {
+      gethold();
+      sem_wait(&top.sync.upd.sem);
+      switch (top.state) {
+      case RUN_MUTE:
+	run_mute();
+	break;
+      case RUN_PASS:
+	run_pass();
+	break;
+      case RUN_PLAY:
+	run_play();
+	break;
+      case RUN_SWCH:
+	run_swch();
+	break;
+      }
+      sem_post(&top.sync.upd.sem);
+    } while (canhold());
+  }
+  pthread_exit(0);
+}
+
+#endif
+
+//========================================================================
+
+#ifdef _WINDOWS
+DttSP_EXP  void 
+execute(void) {
+  ResumeThread(top.thrd.trx.thrd);
+}
+
+DttSP_EXP void
+closeup(void) {
+  extern void destroy_workspace();
+  TerminateThread(top.thrd.trx.thrd, 0L);
+  CloseHandle(top.thrd.trx.thrd);
+  CloseHandle(top.thrd.upd.thrd);
+  CloseHandle(top.sync.buf.sem);
+  CloseHandle(top.sync.upd.sem);
+  destroy_workspace();
+} 
+
+#else
+
+PRIVATE void 
+execute(void) {
+  sem_post(&top.sync.upd.sem);
+  
+  // start audio processing
+  if (jack_activate(top.jack.client))
+    perror("cannot activate jack client"), exit(1);
+  
+  // wait for threads to terminate
+  pthread_join(top.thrd.trx.id, 0);
+  pthread_join(top.thrd.upd.id, 0);
+  
+  // stop audio processing
+  jack_client_close(top.jack.client);
+}
+
+PRIVATE void 
+closeup(void) { exit(0); }
+
+PRIVATE void 
+usage(void) {
+  fprintf(stderr, "usage:\n");
+  fprintf(stderr, "-m\n");
+  fprintf(stderr, "-v\n");
+  exit(1);
+}
+
+PRIVATE void 
+nonblock(int fd) {
+  long arg;
+  arg = fcntl(fd, F_GETFL);
+  arg |= O_NONBLOCK;
+/*  if (fcntl(fd, F_GETFL, &arg) >= 0)
+    fcntl(fd, F_SETFL, arg | O_NONBLOCK); */ 
+    fcntl(fd, F_SETFL, arg);
+} 
+
+#endif
+
+//........................................................................
+
+PRIVATE void 
+setup_meter(void) {
+  uni.meter.flag = TRUE;
+  uni.meter.chan.path = METERPATH;
+  uni.meter.chan.size = METERMULT * sizeof(REAL);
+  uni.meter.val = -200.0;
+  uni.meter.chan.c = openChan(uni.meter.chan.path, uni.meter.chan.size);
+}
+
+PRIVATE void 
+setup_powerspectrum(void) {
+  uni.powsp.flag = TRUE;
+  uni.powsp.chan.path = PWSPATH;
+  uni.powsp.chan.size = 8192 * sizeof(COMPLEX);
+  uni.powsp.buf = newCXB(4096, NULL, "PowerSpectrum Chan Buffer");
+  uni.powsp.fftsize = 4096;
+  uni.powsp.chan.c = openChan(uni.powsp.chan.path, uni.powsp.chan.size);
+}
+
+PRIVATE void 
+setup_switching(void) {
+  top.swch.fade = (int) (0.1 * uni.buflen + 0.5);
+  top.swch.tail = (top.hold.size.frames - top.swch.fade) * sizeof(float);
+}
+
+PRIVATE void 
+setup_local_audio(void) {
+  top.hold.size.frames = uni.buflen;
+  top.hold.size.bytes = top.hold.size.frames * sizeof(float);
+  top.hold.buf.l = (float *) safealloc(top.hold.size.frames, sizeof(float),
+				       "main hold buffer left");
+  top.hold.buf.r = (float *) safealloc(top.hold.size.frames, sizeof(float),
+				       "main hold buffer right");
+} 
+
+#ifdef _WINDOWS
+
+PRIVATE void 
+setup_updates(void) {
+  uni.update.flag = TRUE;
+  uni.update.chan.path = NULL;
+  uni.update.chan.size = 4096;
+  uni.update.chan.c = openChan(uni.update.chan.path, uni.update.chan.size);
+} PRIVATE void 
+
+setup_system_audio(void) {
+  sprintf(top.jack.name, "sdr-%d", top.pid);
+  top.jack.ring.i.l = ringb_create(top.hold.size.bytes * RINGMULT);
+  top.jack.ring.i.r = ringb_create(top.hold.size.bytes * RINGMULT);
+  top.jack.ring.o.l = ringb_create(top.hold.size.bytes * RINGMULT);
+  top.jack.ring.o.r = ringb_create(top.hold.size.bytes * RINGMULT);
+  {
+    unsigned int i;
+    char zero = 0;
+    for (i = 0; i < top.hold.size.bytes; i++) {
+      ringb_write(top.jack.ring.o.l, &zero, 1);
+      ringb_write(top.jack.ring.o.r, &zero, 1);
+    }
+  }
+}
+
+DttSP_EXP void
+release_update(void) {}
+
+DttSP_EXP void
+suspend_sdr(void) { SuspendThread(top.thrd.trx.thrd); }
+
+PRIVATE void 
+setup_threading(void) {
+  top.sync.upd.sem = CreateSemaphore(NULL, 1L, 1L, "UpdateSemaphore");
+  top.sync.buf.sem = CreateSemaphore(NULL, 0L, 1L, "Process Samples Semaphore");
+  top.thrd.trx.thrd = CreateThread((LPSECURITY_ATTRIBUTES) NULL, 0L, process_samples_thread,
+				   NULL, CREATE_SUSPENDED, &top.thrd.trx.id);
+  SetThreadPriority(top.thrd.trx.thrd, THREAD_PRIORITY_HIGHEST);
+}
+
+DttSP_EXP void
+setup_sdr(void) {
+  top.pid = GetCurrentThreadId();
+  top.uid = 0L;
+  top.running = TRUE;
+  top.state = RUN_PLAY;
+  setup_meter();
+  setup_powerspectrum();
+  setup_updates();
+  uni.meter.flag = TRUE;
+  top.verbose = FALSE;
+  setup_workspace();
+  setup_local_audio();
+  setup_system_audio();
+  setup_threading();
+  setup_switching();
+}
+
+#else
+
+PRIVATE void 
+setup_updates(void) {
+  top.parm.path = PARMPATH;
+  if ((top.parm.fd = open(top.parm.path, O_RDWR)) == -1)
+    perror(top.parm.path), exit(1);
+  if (!(top.parm.fp = fdopen(top.parm.fd, "r+"))) {
+    fprintf(stderr, "can't fdopen parm pipe %s\n", PARMPATH);
+    exit(1);
+  }
+}
+
+PRIVATE void 
+setup_system_audio(void) {
+  sprintf(top.jack.name, "sdr-%d", top.pid);
+  if (!(top.jack.client = jack_client_new(top.jack.name)))
+    perror("can't make client -- jack not running?"), exit(1);
+  jack_set_process_callback(top.jack.client, (void *) audio_callback, 0);
+  top.jack.port.i.l = jack_port_register(top.jack.client,
+					 "il",
+					 JACK_DEFAULT_AUDIO_TYPE,
+					 JackPortIsInput,
+					 0);
+  top.jack.port.i.r = jack_port_register(top.jack.client,
+					 "ir",
+					 JACK_DEFAULT_AUDIO_TYPE,
+					 JackPortIsInput,
+					 0);
+  top.jack.port.o.l = jack_port_register(top.jack.client,
+					 "ol",
+					 JACK_DEFAULT_AUDIO_TYPE,
+					 JackPortIsOutput,
+					 0);
+  top.jack.port.o.r = jack_port_register(top.jack.client,
+					 "or",
+					 JACK_DEFAULT_AUDIO_TYPE,
+					 JackPortIsOutput,
+					 0);
+  top.jack.ring.i.l = jack_ringbuffer_create(top.hold.size.bytes * RINGMULT);
+  top.jack.ring.i.r = jack_ringbuffer_create(top.hold.size.bytes * RINGMULT);
+  top.jack.ring.o.l = jack_ringbuffer_create(top.hold.size.bytes * RINGMULT);
+  top.jack.ring.o.r = jack_ringbuffer_create(top.hold.size.bytes * RINGMULT);
+  {
+    int i;
+    char zero = 0;
+    for (i = 0; i < top.hold.size.bytes * RINGMULT / 2; i++) {
+      jack_ringbuffer_write(top.jack.ring.o.l, &zero, 1);
+      jack_ringbuffer_write(top.jack.ring.o.r, &zero, 1);
+    }
+  }
+}
+
+PRIVATE void 
+setup_threading(void) {
+  sem_init(&top.sync.upd.sem, 0, 0);
+  pthread_create(&top.thrd.upd.id, NULL, (void *) process_updates_thread, NULL);
+  sem_init(&top.sync.buf.sem, 0, 0);
+  pthread_create(&top.thrd.trx.id, NULL, (void *) process_samples_thread, NULL);
+} 
+
+//========================================================================
+
+PRIVATE void 
+setup(int argc, char **argv) {
+  int i;
+  top.pid = getpid();
+  top.uid = getuid();
+  top.start_tv = now_tv();
+  top.running = TRUE;
+  top.verbose = FALSE;
+  top.state = RUN_PLAY;
+  setup_meter();
+  setup_updates();
+  for (i = 1; i < argc; i++)
+    if (argv[i][0] == '-')
+      switch (argv[i][1]) {
+      case 'm':
+	uni.meter.flag = TRUE;
+	break;
+      case 'v':
+	top.verbose = TRUE;
+	break;
+      default:
+	usage();
+      }
+    else break;
+  if (i < argc) {
+    if (!freopen(argv[i], "r", stdin))
+      perror(argv[i]), exit(1);
+    i++;
+  }
+  setup_workspace();
+  setup_local_audio();
+  setup_system_audio();
+  setup_threading();
+  setup_switching();
+}
+
+
+//========================================================================
+
+int 
+main(int argc, char **argv) {
+  setup(argc, argv), execute(), closeup();
+} 
+
+#endif  
diff --git a/jDttSP/win/meter.c b/jDttSP/win/meter.c
new file mode 100644
index 0000000..c194fe1
--- /dev/null
+++ b/jDttSP/win/meter.c
@@ -0,0 +1,15 @@
+#include <common.h>
+#ifdef _WINDOWS
+
+DttSP_EXP float
+calculate_meters(METERTYPE mt) {
+  float result;
+  REAL tmp;
+  uni.meter.type = mt;
+  if (getChan_nowait(uni.meter.chan.c, (char *) &tmp, sizeof(REAL)) != 0)
+    uni.meter.val = tmp;
+  result = (float) uni.meter.val;
+  return result;
+}
+
+#endif
diff --git a/jDttSP/win/power_spectrum.c b/jDttSP/win/power_spectrum.c
new file mode 100644
index 0000000..1f1977b
--- /dev/null
+++ b/jDttSP/win/power_spectrum.c
@@ -0,0 +1,128 @@
+#include <common.h>
+ 
+#ifdef _WINDOWS
+
+PWS
+newPowerSpectrum(int size, SPECTRUMTYPE type) {
+  PWS p = (PWS) safealloc(1, sizeof(powerspectrum), "New Power Spectrum");
+
+  p->buf.win = newRLB(size, NULL, "Power Spectrum Window Buffer");
+  p->buf.res = newRLB(32768, NULL, "Save buffer");
+  p->buf.wdat = newCXB(size, NULL, "Power Spectrum Windowed Signal buffer");
+  p->buf.zdat = newCXB(size, NULL, "Power Spectrum FFT Results Buffer");
+  p->fft.size = size;
+  p->flav.spec = type;
+
+  makewindow(BLACKMANHARRIS_WINDOW, size, RLBbase(p->buf.win));
+
+#ifdef notdef  
+  {
+    REAL *tmp = (REAL *) alloca(size * sizeof(REAL));
+    int n = size / 2, nb = n * sizeof(REAL);
+    memcpy(&tmp[n], RLBbase(p->buf.win), nb);
+    memcpy(tmp, &RLBdata(p->buf.win, n), nb);
+  }
+#endif
+
+  p->fft.plan = fftw_create_plan(size, FFTW_FORWARD, uni.wisdom.bits);
+
+  return p;
+}
+
+void
+delPowerSpectrum(PWS pws) {
+  delCXB(pws->buf.wdat);
+  delCXB(pws->buf.zdat);
+  delRLB(pws->buf.win);
+  delRLB(pws->buf.win2);
+  fftw_destroy_plan(pws->fft.plan);
+  safefree((char *) pws);
+}
+
+DttSP_EXP BOOLEAN
+process_spectrum(float *results) {
+  int i, j, n = CXBsize(uni.powsp.buf);
+
+  if (getChan_nowait(uni.powsp.chan.c,
+		     (char *) CXBbase(uni.powsp.buf),
+		     uni.powsp.fft.size * sizeof(COMPLEX))
+      == TRUE) {
+    
+    // Window the data to minimize "splatter" in the powerspectrum
+    for (i = 0; i < uni.powsp.fft.size; i++)
+      CXBdata(uni.powsp.gen->buf.wdat, i) = Cscl(CXBdata(uni.powsp.buf, i),
+						 RLBdata(uni.powsp.gen->buf.win, i));
+    
+    // Compute the FFT
+    fftw_one(uni.powsp.gen->fft.plan,
+	     (fftw_complex *) CXBbase(uni.powsp.gen->buf.wdat),
+	     (fftw_complex *) CXBbase(uni.powsp.gen->buf.zdat));
+    for (i = 0; i < n / 2; i++) {
+      RLBdata(uni.powsp.gen->buf.res, 8 * i) =
+	results[8 * i] = 
+	(float) (10.0 *
+		 log10(1e-160 +
+		       Csqrmag(CXBdata(uni.powsp.gen->buf.zdat,
+				       (i + uni.buflen)))));
+      RLBdata(uni.powsp.gen->buf.res, 8 * (i + uni.buflen)) =
+	results[8 * (i + uni.buflen)] =
+	(float) (10.0 *
+		  log10(1e-160 +
+			Csqrmag(CXBdata(uni.powsp.gen->buf.zdat, i))));
+    } 
+
+    // Interpolate for display on high resolution monitors
+
+    for (i = 0; i < 32768; i += 8)
+      for (j = 1; j < 8; j++)
+	RLBdata(uni.powsp.gen->buf.res, i + j) =
+	  results[i + j] = (float) 0.125 * (results[i] * (float) (8 - j)
+					    + results[i + 8] * (float) j);
+    return TRUE;
+  } else {
+    for (i = 0; i < 32768; i++)
+      results[i] = (float) RLBdata(uni.powsp.gen->buf.res, i);
+    return FALSE;
+  }
+}
+
+DttSP_EXP BOOLEAN
+process_phase(float *results, int numpoints) {
+  int i, j;
+  if (getChan_nowait(uni.powsp.chan.c,
+		     (char *) CXBbase(uni.powsp.buf),
+		     uni.powsp.fft.size * sizeof(COMPLEX))
+      == TRUE) {
+    for (i = 0, j = 0; i < numpoints; i++, j += 2) {
+      RLBdata(uni.powsp.gen->buf.res, j) =
+	results[j] = (float) CXBreal(uni.powsp.buf, i);
+      RLBdata(uni.powsp.gen->buf.res, j + 1) =
+	results[j + 1] = (float) CXBimag(uni.powsp.buf, i);
+    } return TRUE;
+  } else {
+    for (i = 0; i < 2 * numpoints; i++)
+      results[i] = (float) RLBdata(uni.powsp.gen->buf.res, i);
+    return FALSE;
+  }
+}
+
+// Send out Real Signal, reals only
+
+DttSP_EXP BOOLEAN
+process_scope(float *results) {
+  int i;
+  if (getChan_nowait(uni.powsp.chan.c,
+		     (char *) CXBbase(uni.powsp.buf),
+		     uni.powsp.fft.size * sizeof(COMPLEX))
+      == TRUE) {
+    for (i = 0; i < uni.powsp.fft.size; i++) {
+      results[i] = (float) CXBreal(uni.powsp.buf, i);
+    } return TRUE;
+  } else {
+    for (i = 0; i < uni.powsp.fft.size; i++)
+      results[i] = (float) CXBreal(uni.powsp.buf, i);
+    return FALSE;
+  }
+}
+
+#endif
diff --git a/jDttSP/win/power_spectrum.h b/jDttSP/win/power_spectrum.h
new file mode 100644
index 0000000..9711186
--- /dev/null
+++ b/jDttSP/win/power_spectrum.h
@@ -0,0 +1,53 @@
+#ifndef _power_spectrum_h
+#define _power_spectrum_h
+
+#include <fftw.h>
+#include <complex.h>
+#include <bufvec.h>
+
+#ifndef _PWSMODE
+#define _PWSMODE
+
+typedef enum { MAG, DB } SPECTRUMTYPE;
+
+typedef enum _powerspectrummode {
+  POSTFILTER, PREFILTER, AUDIO 
+} PWSMODE;
+
+typedef enum _pws_submode {
+  OFF, SPECTRUM, PANADAPTER, SCOPE, PHASE, PHASE2, WATERFALL, HISTOGRAM
+} PWSSUBMODE;
+
+typedef struct _powerspectrum {
+  struct {
+    int size;
+    fftw_plan plan;
+  } fft;
+  RLB WindowBuf, WindowBuf2, results;
+  CXB WindowedDataBuf, PowerSpectrumFFTresults;
+  struct {
+    RLB win, res;
+    CXB wdat, zdat;
+  } buf;
+  struct {
+    PWSMODE main;
+    PWSSUBMODE sub;
+    SPECTRUMTYPE spec;
+  } flav;
+} *PWS, powerspectrum;
+
+typedef struct _powerspectrum {
+  fftw_plan pwrspecfft;
+  int fftsize;
+  RLB WindowBuf, WindowBuf2, results;
+  CXB WindowedDataBuf, PowerSpectrumFFTresults;
+  PWSMODE Mode;
+  PWSSUBMODE SubMode;
+  SPECTRUMTYPE SpectrumType;
+} *PWS, powerspectrum;
+
+extern PWS newPowerSpectrum(int size, SPECTRUMTYPE SpectrumType);
+extern void delPowerSpectrum(PWS pws);
+extern void process_powerspectrum(float *results, int numpoints);
+
+#endif
diff --git a/jDttSP/win/sdrexport.h b/jDttSP/win/sdrexport.h
new file mode 100644
index 0000000..c6a337a
--- /dev/null
+++ b/jDttSP/win/sdrexport.h
@@ -0,0 +1,346 @@
+/* sdrexport.h
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/  
+  
+#ifndef _sdrexport_h
+#define _sdrexport_h
+  
+#include <common.h>
+//------------------------------------------------------------------------
+/* modulation types, modes */ 
+typedef enum _sdrmode {
+  LSB,				//  0
+  USB,				//  1
+  DSB,				//  2
+  CWL,				//  3
+  CWU,				//  4
+  FMN,				//  5
+  AM,				//  6
+  PSK,				//  7
+  SPEC,				//  8
+  RTTY,				//  9
+  SAM,				// 10
+  DRM				// 11
+} SDRMODE;
+typedef enum _trxmode { RX, TX } TRXMODE;
+
+//========================================================================
+/* RX/TX both */ 
+//------------------------------------------------------------------------
+extern struct _uni {
+  REAL samplerate;
+  int buflen;
+
+  struct {
+    SDRMODE sdr;
+    TRXMODE trx;
+  } mode;
+
+  struct {
+    BOOLEAN flag;
+    struct {
+      char *path;
+      size_t size;
+      Chan c;
+    } chan;
+    REAL val, avgval;
+    METERTYPE type;
+  } meter;
+
+  struct {
+    BOOLEAN flag;
+    PWS gen;
+    struct {
+      char *path;
+      size_t size;
+      Chan c;
+    } chan;
+    CXB buf;
+    int fftsize;
+  } powsp;
+
+  struct {
+    BOOLEAN flag;
+    struct {
+      char *path;
+      size_t size;
+      Chan c;
+    } chan;
+    splitfld splt;
+  } update;
+
+  struct {
+    char *path;
+    int bits;
+  } wisdom;
+
+} uni;
+
+//------------------------------------------------------------------------
+/* RX */ 
+//------------------------------------------------------------------------
+extern struct _rx {
+  struct {
+    CXB i, o;
+  } buf;
+  struct {
+    REAL freq, phase;
+    OSC gen;
+  } osc;
+  struct {
+    ComplexFIR coef;
+    FiltOvSv ovsv;
+    COMPLEX * save;
+  } filt;
+  IQ iqfix;
+  struct {
+    REAL thresh;
+    NB gen;
+    BOOLEAN flag;
+  } nb;
+  struct {
+    REAL thresh;
+    NB gen;
+    BOOLEAN flag;
+  } nb_sdrom;
+  struct {
+    LMSR gen;
+    BOOLEAN flag;
+  } anr, anf;
+  struct {
+    DIGITALAGC gen;
+    BOOLEAN flag;
+  } agc;
+  struct { AMD gen; } am;
+  struct { FMD gen; } fm;
+  struct {
+    BOOLEAN flag;
+    SpotToneGen gen;
+  } spot;
+  struct {
+    struct {
+      REAL val;
+      BOOLEAN flag;
+    } pre, post;
+  } scl;
+  struct {
+    REAL thresh, power;
+    struct {
+      REAL meter, att, gain;
+    } offset;
+    BOOLEAN flag, running, set;
+    int num;
+  } squelch;
+  SDRMODE mode;
+  struct { BOOLEAN flag; } bin;
+} rx;
+
+//------------------------------------------------------------------------
+/* TX */ 
+//------------------------------------------------------------------------
+extern struct _tx {
+  struct {
+    CXB i, o;
+  } buf;
+  struct {
+    REAL freq, phase;
+    OSC gen;
+  } osc;
+  struct {
+    ComplexFIR coef;
+    FiltOvSv ovsv;
+    COMPLEX * save;
+  } filt;
+  struct {
+    ComplexFIR coef;
+    FiltOvSv ovsv;
+    CXB in, out;
+  } fm;
+  struct {
+    DIGITALAGC gen;
+    BOOLEAN flag;
+  } agc;
+  struct {
+    SpeechProc gen;
+    BOOLEAN flag;
+  } spr;
+  struct {
+    COMPLEX dc;
+    struct {
+      REAL val;
+      BOOLEAN flag;
+    } pre, post;
+  } scl;
+  SDRMODE mode;
+} tx;
+
+//------------------------------------------------------------------------
+
+typedef enum _runmode {
+  RUN_MUTE, RUN_PASS, RUN_PLAY, RUN_SWCH 
+} RUNMODE;
+
+#ifndef _WINDOWS
+
+extern struct _top {
+  pid_t pid;
+  uid_t uid;
+  
+  struct timeval start_tv;
+
+  BOOLEAN running, verbose;
+  RUNMODE state;
+  
+  // audio io
+  struct {
+    struct {
+      float *l, *r;
+    } buf;
+    struct {
+      unsigned int frames, bytes;
+    } size;
+  } hold;
+  struct {
+    char *path;
+    int fd;
+    FILE * fp;
+    char buff[4096];
+  } parm;
+  
+  struct {
+    char name[256];
+    jack_client_t * client;
+    struct {
+      struct {
+	jack_port_t *l, *r;
+      } i, o;
+    } port;
+    struct {
+      struct {
+	jack_ringbuffer_t *l, *r;
+      } i, o;
+    } ring;
+  } jack;
+
+  // update io
+  // multiprocessing & synchronization
+  struct {
+    struct {
+      pthread_t id;
+    } trx, upd, pws, meter;
+  } thrd;
+  struct {
+    struct {
+      sem_t sem;
+    } buf, upd;
+  } sync;
+  
+  // TRX switching
+  struct {
+    struct {
+      int want, have;
+    } bfct;
+    struct {
+      TRXMODE next;
+    } trx;
+    struct {
+      RUNMODE last;
+    } run;
+    int fade, tail;
+  } swch;
+} top;
+
+#else
+
+extern struct _top {
+  pid_t pid;
+  uid_t uid;
+
+  BOOLEAN running, verbose;
+  RUNMODE state;
+  
+  // audio io
+  struct {
+    struct {
+      float *l, *r;
+    } buf;
+    struct {
+      unsigned int frames, bytes;
+    } size;
+  } hold;
+  struct {
+    char *path;
+    int fd;
+    HANDLE *fpr;
+    HANDLE *fpw;
+    char buff[4096];
+  } parm;
+  
+  struct {
+    char name[256];
+    struct {
+      struct {
+	ringb_t *l, *r;
+      } i, o;
+    } ring;
+  } jack;
+
+  // update io
+  // multiprocessing & synchronization
+  struct {
+    struct {
+      DWORD id;
+      HANDLE thrd;
+    } trx, upd, pws, meter;
+  } thrd;
+  struct {
+    struct {
+      HANDLE sem;
+    } buf, upd, upd2;
+  } sync;
+  
+  // TRX switching
+  struct {
+    struct {
+      int want, have;
+    } bfct;
+    struct {
+      TRXMODE next;
+    } trx;
+    struct {
+      RUNMODE last;
+    } run;
+    int fade, tail;
+  } swch;
+} top;
+
+#endif
diff --git a/jDttSP/win/update.c b/jDttSP/win/update.c
new file mode 100644
index 0000000..baec77a
--- /dev/null
+++ b/jDttSP/win/update.c
@@ -0,0 +1,1441 @@
+/* update.c
+
+common defs and code for parm update 
+   
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <common.h>
+
+////////////////////////////////////////////////////////////////////////////
+
+PRIVATE REAL
+dB2lin(REAL dB) { return pow(10.0, dB / 20.0); }
+
+
+PRIVATE int
+setRXFilter(int n, char **p) {
+  REAL low_frequency  = atof(p[0]),
+       high_frequency = atof(p[1]);
+  int ncoef = uni.buflen + 1;
+  int i, fftlen = 2 * uni.buflen;
+  fftw_plan ptmp;
+  COMPLEX *zcvec;
+
+  if (fabs(low_frequency) >= 0.5 * uni.samplerate) return -1;
+  if (fabs(high_frequency) >= 0.5 * uni.samplerate) return -2;
+  if ((low_frequency + 10) >= high_frequency) return -3;
+  delFIR_COMPLEX(rx.filt.coef);
+
+  rx.filt.coef = newFIR_Bandpass_COMPLEX(low_frequency,
+					 high_frequency,
+					 uni.samplerate,
+					 ncoef);
+
+  zcvec = newvec_COMPLEX(fftlen, "filter z vec in setFilter");
+  ptmp = fftw_create_plan(fftlen, FFTW_FORWARD, FFTW_OUT_OF_PLACE);
+#ifdef LHS
+  for (i = 0; i < ncoef; i++) zcvec[i] = rx.filt.coef->coef[i];
+#else
+  for (i = 0; i < ncoef; i++) zcvec[fftlen - ncoef + i] = rx.filt.coef->coef[i];
+#endif
+  fftw_one(ptmp, (fftw_complex *) zcvec, (fftw_complex *) rx.filt.ovsv->zfvec);
+  fftw_destroy_plan(ptmp);
+  delvec_COMPLEX(zcvec);
+  memcpy((char *) rx.filt.save,
+	 (char *) rx.filt.ovsv->zfvec,
+	 rx.filt.ovsv->fftlen * sizeof(COMPLEX));
+
+  return 0;
+}
+
+
+PRIVATE int
+setTXFilter(int n, char **p) {
+  REAL low_frequency  = atof(p[0]),
+       high_frequency = atof(p[1]);
+  int ncoef = uni.buflen + 1;
+  int i, fftlen = 2 * uni.buflen;
+  fftw_plan ptmp;
+  COMPLEX *zcvec;
+
+  if (fabs(low_frequency) >= 0.5 * uni.samplerate) return -1;
+  if (fabs(high_frequency) >= 0.5 * uni.samplerate) return -2;
+  if ((low_frequency + 10) >= high_frequency) return -3;
+  delFIR_COMPLEX(tx.filt.coef);
+  tx.filt.coef = newFIR_Bandpass_COMPLEX(low_frequency,
+					high_frequency,
+					uni.samplerate,
+					ncoef);
+  
+  zcvec = newvec_COMPLEX(fftlen, "filter z vec in setFilter");
+  ptmp = fftw_create_plan(fftlen, FFTW_FORWARD, FFTW_OUT_OF_PLACE);
+#ifdef LHS
+  for (i = 0; i < ncoef; i++) zcvec[i] = tx.filt.coef->coef[i];
+#else
+  for (i = 0; i < ncoef; i++) zcvec[fftlen - ncoef + i] = tx.filt.coef->coef[i];
+#endif
+  fftw_one(ptmp, (fftw_complex *) zcvec, (fftw_complex *) tx.filt.ovsv->zfvec);
+  fftw_destroy_plan(ptmp);
+  delvec_COMPLEX(zcvec);
+  memcpy((char *) tx.filt.save,
+	 (char *) tx.filt.ovsv->zfvec,
+	 tx.filt.ovsv->fftlen * sizeof(COMPLEX));
+
+  return 0;
+}
+
+PRIVATE int
+setFilter(int n, char **p) {
+  if (n == 2) return setRXFilter(n, p);
+  else {
+    int trx = atoi(p[2]);
+    if      (trx == RX) return setRXFilter(n, p);
+    else if (trx == TX) return setTXFilter(n, p);
+    else                return -1;
+  }
+}
+
+// setMode <mode> [TRX]
+
+PRIVATE int
+setMode(int n, char **p) {
+  int mode = atoi(p[0]);
+  if (n > 1) {
+    int trx = atoi(p[1]);
+    switch (trx) {
+    case TX: tx.mode = mode; break;
+    case RX: 
+    default: rx.mode = mode; break;
+    }
+  } else
+    tx.mode = rx.mode = uni.mode.sdr = mode;
+  if (rx.mode == AM) rx.am.gen->mode = AMdet;
+  if (rx.mode == SAM) rx.am.gen->mode = SAMdet;
+  return 0;
+}
+
+// setOsc <freq> [TRX]
+PRIVATE int
+setOsc(int n, char **p) {
+  REAL newfreq = atof(p[0]);
+//  fprintf(stderr,"freq =%lf, samplerate = %lf\n",newfreq,uni.samplerate);
+  if (fabs(newfreq) >= 0.5 * uni.samplerate) return -1;
+  newfreq *= 2.0 * M_PI / uni.samplerate;
+  if (n > 1) {
+    int trx = atoi(p[1]);
+    switch (trx) {
+    case TX: tx.osc.gen->Frequency = newfreq; break;
+    case RX:
+    default: rx.osc.gen->Frequency = newfreq; break;
+    }
+  } else
+    tx.osc.gen->Frequency = rx.osc.gen->Frequency = newfreq;
+  return 0;
+}
+
+PRIVATE int
+setSampleRate(int n, char **p) {
+  REAL samplerate = atof(p[0]);
+  uni.samplerate = samplerate;
+  return 0;
+}
+
+PRIVATE int
+setNR(int n, char **p) {
+  rx.anr.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setANF(int n, char **p) {
+  rx.anf.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setNB(int n, char **p) {
+  rx.nb.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setNBvals(int n, char **p) {
+ REAL threshold = atof(p[0]);
+  rx.nb.gen->threshold = rx.nb.thresh = threshold;
+  return 0;
+}
+
+PRIVATE int
+setSDROM(int n, char **p) {
+  rx.nb_sdrom.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setSDROMvals(int n, char **p) {
+ REAL threshold = atof(p[0]);
+  rx.nb_sdrom.gen->threshold = rx.nb_sdrom.thresh = threshold;
+  return 0;
+}
+
+PRIVATE int
+setBIN(int n, char **p) {
+  rx.bin.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE
+// setfixedAGC <gain> [TRX]
+int
+setfixedAGC(int n, char **p) {
+  REAL gain = atof(p[0]);
+  if (n > 1) {
+    int trx = atoi(p[1]);
+    switch(trx) {
+    case TX: tx.agc.gen->AgcFixedGain = gain; break;
+    case RX:
+    default: rx.agc.gen->AgcFixedGain = gain; break;
+    }
+  } else
+    tx.agc.gen->AgcFixedGain = rx.agc.gen->AgcFixedGain = gain;
+  return 0;
+}
+
+PRIVATE int
+setTXAGC(int n, char **p) {
+  int setit = atoi(p[0]);
+  switch (setit) {
+  case agcOFF:
+    tx.agc.gen->AgcMode = agcOFF;
+    tx.agc.flag = FALSE;
+    break;
+  case agcSLOW:
+    tx.agc.gen->AgcMode = agcSLOW;
+    tx.agc.gen->Hang = 10;
+    tx.agc.flag = TRUE;
+    break;
+  case agcMED:
+    tx.agc.gen->AgcMode = agcMED;
+    tx.agc.gen->Hang = 6;
+    tx.agc.flag = TRUE;
+    break;
+  case agcFAST:
+    tx.agc.gen->AgcMode = agcFAST;
+    tx.agc.gen->Hang = 3;
+    tx.agc.flag = TRUE;
+    break;
+  case agcLONG:
+    tx.agc.gen->AgcMode = agcLONG;
+    tx.agc.gen->Hang = 23;
+    tx.agc.flag = TRUE;
+    break;
+  }
+  return 0;
+}
+
+PRIVATE int
+setTXAGCCompression(int n, char **p) {
+  REAL txcompression = atof(p[0]);
+  tx.agc.gen->MaxGain = pow(10.0 , txcompression * 0.05);
+  return 0;
+}
+
+PRIVATE int
+setTXAGCFF(int n, char **p) {
+	int setit = atoi(p[0]);
+	tx.spr.flag = setit;
+	return 0;
+}
+
+PRIVATE int
+setTXAGCFFCompression(int n, char **p) {
+  REAL txcompression = atof(p[0]);
+  tx.spr.gen->MaxGain = pow(10.0 , txcompression * 0.05);
+  return 0;
+}
+
+PRIVATE int
+setTXAGCHang(int n, char **p) {
+  int hang = atoi(p[0]);
+  tx.agc.gen->Hang =
+    (int) max(1, min(23, ((REAL) hang) * uni.samplerate / (1000.0 * uni.buflen)));
+  return 0;
+}
+
+PRIVATE int
+setTXAGCLimit(int n, char **p) {
+  REAL limit = atof(p[0]);
+  tx.agc.gen->AgcLimit = 0.001 * limit;
+  return 0;
+}
+
+PRIVATE int
+setTXSpeechCompression(int n, char **p) {
+  tx.spr.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setTXSpeechCompressionGain(int n, char **p) {
+  tx.spr.gen->MaxGain = dB2lin(atof(p[0]));
+  return 0;
+}
+
+//============================================================
+
+PRIVATE int
+f2x(REAL f) {
+  REAL fix = tx.filt.ovsv->fftlen * f / uni.samplerate;
+  return (int) (fix + 0.5);
+}
+
+//------------------------------------------------------------
+
+PRIVATE void
+apply_txeq_band(REAL lof, REAL dB, REAL hif) {
+  int i,
+      lox = f2x(lof),
+      hix = f2x(hif),
+	  l = tx.filt.ovsv->fftlen;
+  REAL g = dB2lin(dB);
+  COMPLEX *src = tx.filt.save,
+          *trg = tx.filt.ovsv->zfvec;
+   for (i = lox; i < hix; i++) {
+    trg[i] = Cscl(src[i], g);
+    if (i) {
+      int j = l - i;
+      trg[j] = Cscl(src[j], g);
+    }
+  }
+}
+
+// typical:
+// 0 dB1 75 dB2 150 dB3 300 dB4 600 dB5 1200 dB6 2000 dB7 2800 dB8 3600
+// approximates W2IHY bandcenters.
+// no args, revert to no EQ.
+PRIVATE int
+setTXEQ(int n, char **p) {
+  if (n < 3) {
+    // revert to no EQ
+    memcpy((char *) tx.filt.ovsv->zfvec,
+	   (char *) tx.filt.save,
+	   tx.filt.ovsv->fftlen * sizeof(COMPLEX));
+    return 0;
+  } else {
+    int i;
+    REAL lof = atof(p[0]);
+    for (i = 0; i < n - 2; i += 2) {
+      REAL dB = atof(p[i + 1]),
+	   hif = atof(p[i + 2]);
+      if (lof < 0.0 || hif <= lof) return -1;
+      apply_txeq_band(lof, dB, hif);
+      lof = hif;
+    }
+    return 0;
+  }
+}
+
+//------------------------------------------------------------
+
+PRIVATE void
+apply_rxeq_band(REAL lof, REAL dB, REAL hif) {
+  int i,
+      lox = f2x(lof),
+      hix = f2x(hif),
+      l = rx.filt.ovsv->fftlen;
+  REAL g = dB2lin(dB);
+  COMPLEX *src = rx.filt.save,
+          *trg = rx.filt.ovsv->zfvec;
+  for (i = lox; i < hix; i++) {
+    trg[i] = Cscl(src[i], g);
+    if (i) {
+      int j = l - i;
+      trg[j] = Cscl(src[j], g);
+    }
+  }
+}
+
+PRIVATE int
+setRXEQ(int n, char **p) {
+  if (n < 3) {
+    // revert to no EQ
+    memcpy((char *) rx.filt.ovsv->zfvec,
+	   (char *) rx.filt.save,
+	   rx.filt.ovsv->fftlen * sizeof(COMPLEX));
+    return 0;
+  } else {
+    int i;
+    REAL lof = atof(p[0]);
+    for (i = 0; i < n - 2; i += 2) {
+      REAL dB = atof(p[i + 1]),
+	   hif = atof(p[i + 2]);
+      if (lof < 0.0 || hif <= lof) return -1;
+      apply_rxeq_band(lof, dB, hif);
+      lof = hif;
+    }
+    return 0;
+  }
+}
+
+//============================================================
+PRIVATE int
+setRXAGC(int n, char **p) {
+  int setit = atoi(p[0]);
+  switch (setit) {
+  case agcOFF:
+    rx.agc.gen->AgcMode = agcOFF;
+    rx.agc.flag = TRUE;
+    break;
+  case agcSLOW:
+    rx.agc.gen->AgcMode = agcSLOW;
+    rx.agc.gen->Hang = 10;
+    rx.agc.flag = TRUE;
+    break;
+  case agcMED:
+    rx.agc.gen->AgcMode = agcMED;
+    rx.agc.gen->Hang = 6;
+    rx.agc.flag = TRUE;
+    break;
+  case agcFAST:
+    rx.agc.gen->AgcMode = agcFAST;
+    rx.agc.gen->Hang = 3;
+    rx.agc.flag = TRUE;
+    break;
+  case agcLONG:
+    rx.agc.gen->AgcMode = agcLONG;
+    rx.agc.gen->Hang = 23;
+    rx.agc.flag = TRUE;
+    break;
+  }
+  return 0;
+}
+
+PRIVATE int
+setANFvals(int n, char **p) {
+  int taps  = atoi(p[0]),
+      delay = atoi(p[1]);
+  REAL gain = atof(p[2]),
+       leak = atof(p[3]);
+  rx.anf.gen->adaptive_filter_size = taps;
+  rx.anf.gen->delay = delay;
+  rx.anf.gen->adaptation_rate = gain;
+  rx.anf.gen->leakage = leak;
+  return 0;
+}
+
+PRIVATE int
+setNRvals(int n, char **p) {
+  int taps  = atoi(p[0]),
+      delay = atoi(p[1]);
+  REAL gain = atof(p[2]),
+       leak = atof(p[3]);
+  rx.anr.gen->adaptive_filter_size = taps;
+  rx.anr.gen->delay = delay;
+  rx.anr.gen->adaptation_rate = gain;
+  rx.anr.gen->leakage = leak;
+  return 0;
+}
+
+PRIVATE int
+setcorrectIQ(int n, char **p) {
+  int phaseadjustment = atoi(p[0]),
+      gainadjustment  = atoi(p[1]);
+  rx.iqfix->phase = 0.001 * (REAL) phaseadjustment;
+  rx.iqfix->gain  = 1.0+ 0.001 * (REAL) gainadjustment;
+  return 0;
+}
+
+PRIVATE int
+setcorrectIQphase(int n, char **p) {
+  int phaseadjustment = atoi(p[0]);
+  rx.iqfix->phase = 0.001 * (REAL) phaseadjustment;
+  return 0;
+}
+
+PRIVATE int
+setcorrectIQgain(int n, char **p) {
+  int gainadjustment = atoi(p[0]);
+  rx.iqfix->gain = 1.0 + 0.001 * (REAL) gainadjustment;
+  return 0;
+}
+
+PRIVATE int
+setSquelch(int n, char **p) {
+  rx.squelch.thresh = -atof(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setMeterOffset(int n, char **p) {
+  rx.squelch.offset.meter = atof(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setATTOffset(int n, char **p) {
+  rx.squelch.offset.att = atof(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setGainOffset(int n, char **p) {
+  rx.squelch.offset.gain = atof(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setSquelchSt(int n, char **p) {
+  rx.squelch.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setTRX(int n, char **p) {
+  uni.mode.trx = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setRunState(int n, char **p) {
+  RUNMODE rs = (RUNMODE) atoi(p[0]);
+  top.state = rs;
+  return 0;
+}
+
+PRIVATE int
+setSpotToneVals(int n, char **p) {
+  REAL gain  = atof(p[0]),
+       freq  = atof(p[1]),
+       rise  = atof(p[2]),
+       fall  = atof(p[3]);
+  setSpotToneGenVals(rx.spot.gen, gain, freq, rise, fall);
+  return 0;
+}
+
+PRIVATE int
+setSpotTone(int n, char **p) {
+  if (atoi(p[0])) {
+    SpotToneOn(rx.spot.gen);
+    rx.spot.flag = TRUE;
+  } else
+    SpotToneOff(rx.spot.gen);
+  return 0;
+}
+
+PRIVATE int
+setRXPreScl(int n, char **p) {
+  rx.scl.pre.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setRXPreSclVal(int n, char **p) {
+  rx.scl.pre.val = dB2lin(atof(p[0]));
+  return 0;
+}
+
+PRIVATE int
+setTXPreScl(int n, char **p) {
+  tx.scl.pre.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setTXPreSclVal(int n, char **p) {
+  tx.scl.pre.val = dB2lin(atof(p[0]));
+  return 0;
+}
+
+PRIVATE int
+setRXPostScl(int n, char **p) {
+  rx.scl.post.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setRXPostSclVal(int n, char **p) {
+  rx.scl.post.val = dB2lin(atof(p[0]));
+  return 0;
+}
+
+PRIVATE int
+setTXPostScl(int n, char **p) {
+  tx.scl.post.flag = atoi(p[0]);
+  return 0;
+}
+
+PRIVATE int
+setTXPostSclVal(int n, char **p) {
+  tx.scl.post.val = dB2lin(atof(p[0]));
+  return 0;
+}
+
+PRIVATE int
+setFinished(int n, char **p) {
+  top.running = FALSE;
+  return 0;
+}
+
+PRIVATE int
+setPWSmode(int n,char **p) {
+    int setit = atoi(p[0]);
+	uni.powerspectrum.pws->Mode = setit;
+	return 0;
+}
+
+PRIVATE int
+setPWSSubmode(int n,char **p) {
+    int setit = atoi(p[0]);
+	uni.powerspectrum.pws->SubMode = setit;
+	return 0;
+}
+
+// next-trx-mode [nbufs-to-zap]
+PRIVATE int
+setSWCH(int n, char **p) {
+  top.swch.trx.next = atoi(p[0]);
+  if (n > 1) top.swch.bfct.want = atoi(p[1]);
+  else top.swch.bfct.want = 0;
+  top.swch.bfct.have = 0;
+  top.swch.run.last = top.state;
+  top.state = RUN_SWCH;
+  return 0;
+}
+
+//========================================================================
+
+#include <thunk.h>
+
+CTE update_cmds[] = {
+  {"setANF", setANF},
+  {"setANFvals", setANFvals},
+  {"setATTOffset", setATTOffset},
+  {"setBIN", setBIN},
+  {"setcorrectIQ", setcorrectIQ},
+  {"setcorrectIQgain", setcorrectIQgain},
+  {"setcorrectIQphase", setcorrectIQphase},
+  {"setFilter", setFilter},
+  {"setfixedAGC", setfixedAGC},
+  {"setGainOffset", setGainOffset},
+  {"setMeterOffset", setMeterOffset},
+  {"setMode", setMode},
+  {"setNB", setNB},
+  {"setNBvals", setNBvals},
+  {"setNR", setNR},
+  {"setNRvals", setNRvals},
+  {"setOsc", setOsc},
+  {"setRXAGC", setRXAGC},
+  {"setRunState", setRunState},
+  {"setSampleRate", setSampleRate},
+  {"setSquelch", setSquelch},
+  {"setSquelchSt", setSquelchSt},
+  {"setTXAGC", setTXAGC},
+  {"setTXAGCCompression", setTXAGCCompression},
+  {"setTXAGCFFCompression",setTXAGCFFCompression},
+  {"setTXAGCHang", setTXAGCHang},
+  {"setTXAGCLimit", setTXAGCLimit},
+  {"setTXSpeechCompression", setTXSpeechCompression},
+  {"setTXSpeechCompressionGain", setTXSpeechCompressionGain},
+  {"setRXEQ", setRXEQ},
+  {"setTXEQ", setTXEQ},
+  {"setTRX", setTRX},
+  {"setRXPreScl", setRXPreScl},
+  {"setRXPreSclVal", setRXPreSclVal},
+  {"setTXPreScl", setTXPreScl},
+  {"setTXPreSclVal", setTXPreSclVal},
+  {"setRXPostScl", setRXPostScl},
+  {"setRXPostSclVal", setRXPostSclVal},
+  {"setTXPostScl", setTXPostScl},
+  {"setTXPostSclVal", setTXPostSclVal},
+  {"setFinished", setFinished},
+  {"setSWCH", setSWCH},
+  {"setSpotToneVals", setSpotToneVals},
+  {"setSpotTone", setSpotTone},
+  {"setPWSmode", setPWSmode},
+  {"setPWSSubmode",setPWSSubmode},
+  {"setSDROM", setSDROM},
+  {"setSDROMvals",setSDROMvals},
+  { 0, 0 }
+};
+
+//........................................................................
+
+int do_update(char *str) {
+  
+  SPLIT splt = &uni.update.splt;
+  
+  split(splt, str);
+  
+  if (NF(splt) < 1) return -1;
+  else {
+    Thunk thk = Thunk_lookup(update_cmds, F(splt, 0));
+    if (!thk) {
+      fprintf(stderr,"-1\n");
+      return -1;
+    } else {
+      int val;
+      WaitForSingleObject(top.sync.upd.sem,INFINITE);
+      val = (*thk)(NF(splt) - 1, Fptr(splt, 1));
+      ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+      return val;
+    }
+  }
+}
+
+BOOLEAN newupdates() {
+  WaitForSingleObject(top.sync.upd2.sem,INFINITE);
+  return TRUE;
+}
+
+PRIVATE void
+sendcommand(char *str) {
+  putChan_nowait(uni.update.chan.c,str,strlen(str)+1);;
+  ReleaseSemaphore(top.sync.upd2.sem,1L,NULL);
+  Sleep(0);
+}
+
+#ifdef PROCESSVERS
+DttSP_EXP int
+changeMode(SDRMODE mode) {
+  char str[128];
+  switch(mode) {
+  case LSB:
+    sprintf(str,"setMode %d",LSB);
+    sendcommand(str);
+    break;
+  case USB:
+    sprintf(str,"setMode %d",USB);
+    sendcommand(str);
+    break;
+  case DSB:
+    sprintf(str,"setMode %d",DSB);
+    sendcommand(str);
+    break;
+  case CWL:
+    sprintf(str,"setMode %d",CWL);
+    sendcommand(str);
+    break;
+  case CWU:
+    sprintf(str,"setMode %d",CWU);
+    sendcommand(str);
+    break;
+  case AM:
+    sprintf(str,"setMode %d",AM);
+    sendcommand(str);
+    break;
+  case PSK:
+    sprintf(str,"setMode %d",PSK);
+    sendcommand(str);
+    break;
+  case SPEC:
+    sprintf(str,"setMode %d",SPEC);
+    sendcommand(str);
+    break;
+  case RTTY:
+    sprintf(str,"setMode %d",RTTY);
+    sendcommand(str);
+    break;
+  case SAM:
+    sprintf(str,"setMode %d",SAM);
+    sendcommand(str);
+    break;
+  case DRM:
+    sprintf(str,"setMode %d",DRM);
+    sendcommand(str);
+    break;
+  default:
+    break;
+  }
+  return 0;
+}
+
+DttSP_EXP int
+changeOsc(REAL newfreq){
+  char str[64];
+  if (fabs(newfreq) >= 0.5* uni.samplerate) return -1;
+  sprintf(str,"setOsc %lf RX",newfreq);
+  sendcommand(str);
+  return 0;
+}
+
+DttSP_EXP int
+changeTXOsc(REAL newfreq){
+  char str[64];
+  if (fabs(newfreq) >= 0.5* uni.samplerate) return -1;
+  sprintf(str,"setOsc %lf TX",newfreq);
+  sendcommand(str);
+  return 0;
+}
+
+DttSP_EXP int
+changeSampleRate(REAL newSampleRate) {
+  char str[64];
+  sprintf(str,"setSampleRate %9.0lf",newSampleRate);
+  sendcommand(str);
+  return 0;
+}
+
+DttSP_EXP void changeNR(int setit) {
+  char str[64];
+  sprintf(str,"setNR %d",setit);
+  sendcommand(str);
+}
+
+DttSP_EXP void changeANF(int setit) {
+  char str[64];
+  sprintf(str,"setANF %d",setit);
+  sendcommand(str);
+}
+
+DttSP_EXP void changeNB(int setit) {
+  char str[64];
+  sprintf(str,"setNB %d",setit);
+  sendcommand(str);
+}
+
+DttSP_EXP void changeNBvals(REAL threshold) {
+  char str[64];
+  sprintf(str,"setNBvals %lf",threshold);
+  sendcommand(str);	
+}
+
+
+DttSP_EXP void changeBIN(int setit) {
+  char str[64];
+  sprintf(str,"setBIN %d",setit);
+  sendcommand(str);
+}
+
+DttSP_EXP void changeAGC(AGCMODE setit) {
+  char str[64];
+  switch (setit) {
+  case agcOFF:
+    sprintf(str,"setRXAGC %d",agcOFF);
+    break;
+  case agcLONG:
+    sprintf(str,"setRXAGC %d",agcLONG);
+    break;
+  case agcSLOW:
+    sprintf(str,"setRXAGC %d",agcSLOW);
+    break;
+  case agcMED:
+    sprintf(str,"setRXAGC %d",agcMED);
+    break;
+  case agcFAST:
+    sprintf(str,"setRXAGC %d",agcFAST);
+    break;
+  }
+  sendcommand(str);
+}
+
+DttSP_EXP void changeANFvals(int taps, int delay, REAL gain, REAL leak) {
+  char str[128];
+  sprintf(str,"setANFvals %3d %3d %9.7lf %9.7lf",taps,delay,gain,leak);
+  sendcommand(str);
+}
+
+DttSP_EXP void changeNRvals(int taps, int delay, REAL gain, REAL leak) {
+  char str[128];
+  sprintf(str,"setNRvals %3d %3d %9.7lf %9.7lf",taps,delay,gain,leak);
+  sendcommand(str);
+}
+
+DttSP_EXP void setcorrectIQcmd(int phaseadjustment,int gainadjustment) {
+  char str[64];
+  sprintf(str,"setcorrectIQ %d %d",phaseadjustment,gainadjustment);
+  sendcommand(str);
+}
+
+DttSP_EXP void changecorrectIQphase(int phaseadjustment){
+  char str[64];
+  sprintf(str,"setcorrectIQphase %d",phaseadjustment);
+  sendcommand(str);
+}
+
+DttSP_EXP void changecorrectIQgain(int gainadjustment){
+  char str[64];
+  sprintf(str,"setcorrectIQgain %d",gainadjustment);
+  sendcommand(str);
+}
+
+DttSP_EXP int
+changeFilter(REAL low_frequency,REAL high_frequency,int ncoef, TRXMODE trx) {
+  char str[64];
+  if (trx == RX)  sprintf(str,"setFilter %6.0lf %6.0lf RX",low_frequency,high_frequency);
+  else sprintf(str,"setFilter %6.0lf %6.0lf TX",low_frequency,high_frequency);
+  sendcommand(str);
+  return 0;
+}
+
+DttSP_EXP void
+changePWSmode(PWSMODE setit) {
+  char str[64];
+  switch (setit) {
+  case PREFILTER:
+    sprintf(str,"setPWSmode %d",PREFILTER);
+    break;
+  case POSTFILTER:
+    sprintf(str,"setPWSmode %d",POSTFILTER);
+    break;
+  case AUDIO:
+    sprintf(str,"setPWSmode %d",AUDIO);
+    break;
+  default:
+    return;
+  }
+  sendcommand(str);
+}
+
+DttSP_EXP void
+changePWSsubmode(PWSSUBMODE setit) {
+  char str[64];
+  switch (setit) {
+  case SPECTRUM:
+    sprintf(str,"setPWSSubmode %d",SPECTRUM);
+    break;
+  case PHASE:
+    sprintf(str,"setPWSSubmode %d",PHASE);
+    break;
+  case SCOPE:
+    sprintf(str,"setPWSSubmode %d",SCOPE);
+    break;
+  case PHASE2:
+    sprintf(str,"setPWSSubmode %d",PHASE);
+    break;
+  case WATERFALL:
+    sprintf(str,"setPWSSubmode %d",WATERFALL);
+    break;
+  case HISTOGRAM:
+    sprintf(str,"setPWSSubmode %d",HISTOGRAM);
+    break;
+  default:
+    return;
+  }
+  sendcommand(str);
+}
+
+DttSP_EXP void
+changeWindow(Windowtype Windowset){
+}
+
+DttSP_EXP void
+oldsetTXEQ(int *txeq) {
+  char str[256];
+  sprintf(str,
+	  "setTXEQ 0 %d 450 %d 800 %d 1150 %d 1450 %d 1800 %d 2150 %d 2450 %d 2800 %d 3600",
+	  txeq[0],
+	  txeq[1],
+	  txeq[2],
+	  txeq[3],
+	  txeq[4],
+	  txeq[5],
+	  txeq[6],
+	  txeq[7],
+	  txeq[8]);
+  sendcommand(str);
+}
+
+DttSP_EXP void
+changeTXAGCCompression(double txc) {
+  char str[64];
+  sprintf(str,"setTXAGCCompression %lf",txc);
+  sendcommand(str);
+}
+
+DttSP_EXP void
+changeTXAGCFFCompression(double txc) {
+  char str[64];
+  sprintf(str,"setTXAGCFFCompression %lf",txc);
+  sendcommand(str);
+}
+
+DttSP_EXP void oldsetGainOffset(float val) {
+  char str[64];
+  sprintf(str,"setGainOffset %f",val);
+  sendcommand(str);
+}
+
+DttSP_EXP void setTXScale(REAL scale) {
+  char str[32];
+  sprintf(str,"setTXPreScl 1 ");
+  sendcommand(str);
+  Sleep(0);
+  sprintf(str,"setTXPreSclVal %lf",20.0*log10(scale));
+  sendcommand(str);
+}
+
+DttSP_EXP void oldsetATTOffset(float val){
+  char str[64];
+  sprintf(str,"setATTOffset %f",val);
+  sendcommand(str);
+}
+
+DttSP_EXP setRXScale(float val) {
+  char str[64];
+  sprintf(str,"setRXPostScl 1");
+  sendcommand(str);
+  Sleep(0);
+  sprintf(str,"setRXPostSclVal %f",val);
+  sendcommand(str);
+}
+
+DttSP_EXP oldsetMeterOffset(float val){
+  char str[64];
+  sprintf(str,"setMeterOffset %f",val);
+  sendcommand(str);
+}
+
+DttSP_EXP changeSquelch(float setit) {
+  char str[64];
+  sprintf(str,"setSquelch %f",setit);
+  sendcommand(str);
+}
+
+DttSP_EXP changeSquelchSt(BOOLEAN setit) {
+  char str[64];
+  sprintf(str,"setSquelch %d",setit);
+  sendcommand(str);
+}
+
+DttSP_EXP void changeSDROM(BOOLEAN setit) {   
+  char str[64];
+  sprintf(str,"setSDROM %d",setit);
+  sendcommand(str);
+}
+
+DttSP_EXP void changeSDROMvals(REAL threshold) {
+  char str[64];
+  sprintf(str,"setSDROMvals %lf",threshold);
+  sendcommand(str);
+}
+
+
+#endif   // END PROCESSVERS
+
+
+
+#ifdef DLLVERS
+DttSP_EXP int
+changeMode(SDRMODE mode) {
+  switch(mode) {
+  case LSB:
+  case USB:
+  case DSB:
+  case CWL:
+  case CWU:
+  case FMN:
+  case AM:
+  case PSK:
+  case SPEC:
+  case RTTY:
+  case SAM:
+  case DRM:
+    WaitForSingleObject(top.sync.upd.sem,INFINITE);
+    rx.mode = tx.mode = uni.mode.sdr = mode;
+    if (mode == SAM) rx.am.gen->mode = SAMdet;
+    if (mode == AM)  rx.am.gen->mode = AMdet;
+    ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+    break;
+  default:
+    break;
+  }
+  return 0;
+}
+
+DttSP_EXP int
+changeOsc(REAL newfreq){
+  if (fabs(newfreq) >= 0.5* uni.samplerate) return -1;
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.osc.gen->Frequency = rx.osc.freq = 2.0*M_PI*newfreq/uni.samplerate;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+  return 0;
+}
+
+DttSP_EXP int
+changeTXOsc(REAL newfreq){
+  if (fabs(newfreq) >= 0.5* uni.samplerate) return -1;
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  tx.osc.gen->Frequency = tx.osc.freq = 2.0*M_PI*newfreq/uni.samplerate;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+  return 0;
+}
+
+DttSP_EXP int
+changeSampleRate(REAL newSampleRate) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  uni.samplerate = newSampleRate;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+  return 0;
+}
+
+DttSP_EXP void changeNR(BOOLEAN setit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.anr.flag = setit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void changeANF(BOOLEAN setit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.anf.flag = setit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void changeNB(BOOLEAN setit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.nb.flag = setit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void changeNBvals(REAL threshold) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.nb.gen->threshold = rx.nb.thresh = threshold;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void changeSDROM(BOOLEAN setit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.nb_sdrom.flag = setit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void changeSDROMvals(REAL threshold) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.nb_sdrom.gen->threshold = rx.nb_sdrom.thresh = threshold;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+
+DttSP_EXP void changeBIN(BOOLEAN setit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.bin.flag= setit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void changeAGC(AGCMODE setit) {
+  switch (setit) {
+  case agcOFF:
+    WaitForSingleObject(top.sync.upd.sem,INFINITE);
+    rx.agc.gen->AgcMode = setit;
+    ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+    break;
+  case agcLONG:
+    WaitForSingleObject(top.sync.upd.sem,INFINITE);
+    rx.agc.gen->AgcMode = setit;
+    rx.agc.gen->Hang = 23;
+    ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+    break;
+  case agcSLOW:
+    WaitForSingleObject(top.sync.upd.sem,INFINITE);
+    rx.agc.gen->AgcMode = setit;
+    rx.agc.gen->Hang = 7;
+    ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+    break;
+  case agcMED:
+    WaitForSingleObject(top.sync.upd.sem,INFINITE);
+    rx.agc.gen->AgcMode = setit;
+    rx.agc.gen->Hang = 4;
+    ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+    break;
+  case agcFAST:
+    WaitForSingleObject(top.sync.upd.sem,INFINITE);
+    rx.agc.gen->AgcMode = setit;
+    rx.agc.gen->Hang = 2;
+    ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+    break;
+  default:
+    break;
+  }
+}
+
+DttSP_EXP void changefixedAGC(REAL fixed_agc) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.agc.gen->AgcFixedGain = dB2lin(fixed_agc);
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void changemaxAGC(REAL max_agc) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.agc.gen->MaxGain = dB2lin(max_agc);
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void changeRXAGCAttackTimeScale(int limit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.agc.gen->AgcAttackTimeScale = limit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+
+}
+
+DttSP_EXP void changeRXAGCHang(int limit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.agc.gen->Hang = limit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+
+}
+
+DttSP_EXP void changeRXAGCLimit(int limit){
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.agc.gen->AgcLimit = 0.001 * (double)limit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void changeANFvals(int taps, int delay, REAL gain, REAL leak) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.anf.gen->adaptation_rate = gain;
+  rx.anf.gen->adaptive_filter_size = taps;
+  rx.anf.gen->delay = delay;
+  rx.anf.gen->leakage = leak;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void changeNRvals(int taps, int delay, REAL gain, REAL leak) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.anr.gen->adaptation_rate = gain;
+  rx.anr.gen->adaptive_filter_size = taps;
+  rx.anr.gen->delay = delay;
+  rx.anr.gen->leakage = leak;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void
+setcorrectIQcmd(int phaseadjustment,int gainadjustment) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.iqfix->phase = 0.001 * (REAL) phaseadjustment; 
+  rx.iqfix->gain  = 1.0 + 0.001 * (REAL) gainadjustment;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void
+changecorrectIQphase(int phaseadjustment) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.iqfix->phase = 0.001 * (REAL) phaseadjustment; 
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void
+changecorrectIQgain(int gainadjustment) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.iqfix->gaina = 1.0 + 0.001 * (REAL) gainadjustment;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP int
+changeFilter(REAL low_frequency,REAL high_frequency,int ncoef, TRXMODE trx) {
+  int i, fftlen = 2 * uni.buflen;
+  fftw_plan ptmp;
+  COMPLEX *zcvec;
+  ncoef = uni.buflen + 1;
+
+  if (fabs(low_frequency) >= 0.5 * uni.samplerate) return -1;
+  if (fabs(high_frequency) >= 0.5 * uni.samplerate) return -2;
+  if ((low_frequency + 10) >= high_frequency) return -3;
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  if (trx == RX) {
+    delFIR_COMPLEX(rx.filt.coef);
+
+    rx.filt.coef = newFIR_Bandpass_COMPLEX(low_frequency,
+					   high_frequency,
+					   uni.samplerate,
+					   ncoef + 1);
+
+    zcvec = newvec_COMPLEX(fftlen, "filter z vec in setFilter");
+    ptmp = fftw_create_plan(fftlen, FFTW_FORWARD, FFTW_OUT_OF_PLACE);
+#ifdef LHS
+    for (i = 0; i < ncoef; i++) zcvec[i] = rx.filt.coef->coef[i];
+#else
+    for (i = 0; i < ncoef; i++) zcvec[fftlen - ncoef + i] = rx.filt.coef->coef[i];
+#endif
+    fftw_one(ptmp, (fftw_complex *) zcvec, (fftw_complex *) rx.filt.ovsv->zfvec);
+    fftw_destroy_plan(ptmp);
+    delvec_COMPLEX(zcvec);
+    memcpy((char *) rx.filt.save,
+	   (char *) rx.filt.ovsv->zfvec,
+	   rx.filt.ovsv->fftlen * sizeof(COMPLEX));
+  } else {
+    delFIR_COMPLEX(tx.filt.coef);
+
+    tx.filt.coef = newFIR_Bandpass_COMPLEX(low_frequency,
+					   high_frequency,
+					   uni.samplerate,
+					   ncoef + 1);
+
+    zcvec = newvec_COMPLEX(fftlen, "filter z vec in setFilter");
+    ptmp = fftw_create_plan(fftlen, FFTW_FORWARD, FFTW_OUT_OF_PLACE);
+#ifdef LHS
+    for (i = 0; i < ncoef; i++) zcvec[i] = tx.filt.coef->coef[i];
+#else
+    for (i = 0; i < ncoef; i++) zcvec[fftlen - ncoef + i] = tx.filt.coef->coef[i];
+#endif
+    fftw_one(ptmp, (fftw_complex *) zcvec, (fftw_complex *) tx.filt.ovsv->zfvec);
+    fftw_destroy_plan(ptmp);
+    delvec_COMPLEX(zcvec);
+    memcpy((char *) tx.filt.save,
+	   (char *) tx.filt.ovsv->zfvec,
+	   tx.filt.ovsv->fftlen * sizeof(COMPLEX));
+
+  }
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+  return 0;
+}
+
+DttSP_EXP void
+changePWSmode(PWSMODE setit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  uni.powerspectrum.pws->Mode = setit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+
+}
+
+DttSP_EXP void
+changePWSsubmode(PWSSUBMODE setit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  uni.powerspectrum.pws->SubMode = setit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void
+changeWindow(Windowtype Windowset){
+}
+
+DttSP_EXP void
+oldsetTXEQ(int *txeq) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  apply_txeq_band(0.0   ,txeq[ 0],120.0);
+  apply_txeq_band(120.0 ,txeq[ 1],230.0);
+  apply_txeq_band(230.0 ,txeq[ 2],450.0);
+  apply_txeq_band(450.0 ,txeq[ 3],800.0);
+  apply_txeq_band(800.0 ,txeq[ 4],1150.0);
+  apply_txeq_band(1150.0,txeq[ 5],1450.0);
+  apply_txeq_band(1450.0,txeq[ 6],1800.0);
+  apply_txeq_band(1800.0,txeq[ 7],2150.0);
+  apply_txeq_band(2150.0,txeq[ 8],2450.0);
+  apply_txeq_band(2450.0,txeq[ 9],2800.0);
+  apply_txeq_band(2800.0,txeq[10],3250.0);
+  apply_txeq_band(3250.0,txeq[11],6000.0);
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void
+changeTXAGCCompression(double txc) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  tx.agc.gen->MaxGain = pow(10.0 , txc * 0.05);
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void
+changeTXAGCFF(BOOLEAN setit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  tx.spr.flag = setit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void
+changeTXAGCLimit(int setit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  tx.agc.gen->AgcLimit = 0.001*(REAL)setit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void
+changeTXAGCHang(int hang) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  tx.agc.gen->Hang = (int)max(1,min(23,((REAL)hang) * uni.samplerate /(1000.0*uni.buflen)));
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void
+changeTXAGCFFCompression(REAL txc) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  tx.spr.gen->MaxGain = pow(10.0 , txc * 0.05);
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void setTXScale(REAL scale) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  tx.scl.post.flag = TRUE;
+  tx.scl.post.val = scale;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void oldsetGainOffset(float val) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.squelch.offset.gain = (REAL)val;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP void oldsetATTOffset(float val){
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.squelch.offset.att = (REAL)val;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP oldsetMeterOffset(float val){
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.squelch.offset.meter = (REAL)val;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+
+DttSP_EXP setRXScale(REAL val) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.scl.post.flag = TRUE;
+  rx.scl.post.val = val;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP changeSquelch(int setit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.squelch.thresh = -(REAL)setit;	
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+
+DttSP_EXP changeSquelchSt(BOOLEAN setit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  rx.squelch.flag = setit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+
+}
+
+DttSP_EXP void oldsetTRX(TRXMODE setit) {
+  WaitForSingleObject(top.sync.upd.sem,INFINITE);
+  /*	top.swch.trx.next = setit;
+	top.swch.bfct.want = 2;
+	top.swch.bfct.have = 0;
+	top.swch.run.last = top.state;
+	top.state = RUN_SWCH; */
+  uni.mode.trx = setit;
+  ReleaseSemaphore(top.sync.upd.sem,1L,NULL);
+}
+#endif    //  END DLLVERS
+
+
+
diff --git a/jDttSP/win/update.h b/jDttSP/win/update.h
new file mode 100644
index 0000000..ea56405
--- /dev/null
+++ b/jDttSP/win/update.h
@@ -0,0 +1,46 @@
+/* update.h
+
+common defs and code for parm update
+   
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _update_h
+#define _update_h
+
+#include <fromsys.h>
+#include <banal.h>
+#include <datatypes.h>
+
+extern int do_update(char *str);
+extern BOOLEAN newupdates(void);
+
+#endif
diff --git a/jDttSP/win/valueswin.h b/jDttSP/win/valueswin.h
new file mode 100644
index 0000000..1fa0230
--- /dev/null
+++ b/jDttSP/win/valueswin.h
@@ -0,0 +1,83 @@
+/* Old compatibility names for <limits.h> and <float.h> constants.
+   Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+/* This interface is obsolete.  New programs should use
+   <limits.h> and/or <float.h> instead of <values.h>.  */
+
+#ifndef	_VALUES_H
+#define	_VALUES_H	1
+
+//#include <features.h>
+
+#include <limits.h>
+
+#define _TYPEBITS(type)	(sizeof (type) * CHAR_BIT)
+
+#define CHARBITS	_TYPEBITS (char)
+#define SHORTBITS	_TYPEBITS (short int)
+#define INTBITS		_TYPEBITS (int)
+#define LONGBITS	_TYPEBITS (long int)
+#define PTRBITS		_TYPEBITS (char *)
+#define DOUBLEBITS	_TYPEBITS (double)
+#define FLOATBITS	_TYPEBITS (float)
+
+//#ifndef MINSHORT
+//#define MINSHORT	SHRT_MIN
+//#endif
+
+#ifndef MININT
+#define	MININT		INT_MIN
+#endif
+
+//#ifndef MINLONG
+//#define	MINLONG		LONG_MIN
+//#endif
+//
+//#ifndef MAXSHORT
+//#define	MAXSHORT	SHRT_MAX
+//#endif
+
+#define	MAXINT		INT_MAX
+
+//#ifndef MAXLONG
+//#define	MAXLONG		LONG_MAX
+//#endif
+
+#define HIBITS		MINSHORT
+#define HIBITL		MINLONG
+
+
+#include <float.h>
+
+#define	MAXDOUBLE	DBL_MAX
+#define	MAXFLOAT	FLT_MAX
+#define	MINDOUBLE	DBL_MIN
+#define	MINFLOAT	FLT_MIN
+#define	DMINEXP		DBL_MIN_EXP
+#define	FMINEXP		FLT_MIN_EXP
+#define	DMAXEXP		DBL_MAX_EXP
+#define	FMAXEXP		FLT_MAX_EXP
+
+
+#ifdef __USE_MISC
+/* Some systems define this name instead of CHAR_BIT or CHARBITS.  */
+# define BITSPERBYTE	CHAR_BIT
+#endif
+
+#endif	/* values.h */
diff --git a/jDttSP/window.c b/jDttSP/window.c
new file mode 100644
index 0000000..9807bfe
--- /dev/null
+++ b/jDttSP/window.c
@@ -0,0 +1,158 @@
+/* window.c
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+Implemented from code by Bill Schottstaedt of Snd Editor at CCRMA
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#include <window.h>
+
+/* shamelessly stolen from Bill Schottstaedt's clm.c */
+/* made worse in the process, but enough for our purposes here */
+
+//static double
+//sqr(double x) { return (x * x); }
+
+/* mostly taken from
+ *    Fredric J. Harris, "On the Use of Windows for Harmonic Analysis with the
+ *    Discrete Fourier Transform," Proceedings of the IEEE, Vol. 66, No. 1,
+ *    January 1978.
+ *    Albert H. Nuttall, "Some Windows with Very Good Sidelobe Behaviour", 
+ *    IEEE Transactions of Acoustics, Speech, and Signal Processing, Vol. ASSP-29,
+ *    No. 1, February 1981, pp 84-91
+ *
+ * JOS had slightly different numbers for the Blackman-Harris windows.
+ */
+
+double *
+makewindow(Windowtype type, int size, double *window) {
+  int i, j, midn, midp1, midm1;
+  double freq, rate, sr1, angle, expn, expsum, cx, two_pi;
+
+  midn = size >> 1;
+  midp1 = (size + 1) / 2;
+  midm1 = (size - 1) / 2;
+  two_pi = 8.0 * atan(1.0);
+  freq = two_pi / (double) size;
+  rate = 1.0 / (double) midn;
+  angle = 0.0;
+  expn = log(2.0) / (double) midn + 1.0;
+  expsum = 1.0;
+
+  switch (type) {
+  case RECTANGULAR_WINDOW:
+    for (i = 0; i < size; i++) window[i] = 1.0;
+    break;
+  case HANNING_WINDOW:	/* Hann would be more accurate */
+    for (i = 0, j = size - 1, angle = 0.0; i <= midn; i++, j--, angle += freq)
+      window[j] = (window[i] = 0.5 - 0.5 * cos(angle));
+    break;
+  case WELCH_WINDOW:
+    for (i = 0, j = size - 1; i <= midn; i++, j--)
+      window[j] =
+	(window[i] = 1.0 - sqr((double) (i - midm1) / (double) midp1));
+    break;
+  case PARZEN_WINDOW:
+    for (i = 0, j = size - 1; i <= midn; i++, j--)
+      window[j] =
+	(window[i] = 1.0 - fabs((double) (i - midm1) / (double) midp1));
+    break;
+  case BARTLETT_WINDOW:
+    for (i = 0, j = size - 1, angle = 0.0; i <= midn; i++, j--, angle += rate)
+      window[j] = (window[i] = angle);
+    break;
+  case HAMMING_WINDOW:
+    for (i = 0, j = size - 1, angle = 0.0; i <= midn; i++, j--, angle += freq)
+      window[j] = (window[i] = 0.54 - 0.46 * cos(angle));
+    break;
+  case BLACKMAN2_WINDOW:	/* using Chebyshev polynomial equivalents here */
+    for (i = 0, j = size - 1, angle = 0.0; i <= midn; i++, j--, angle += freq) {
+      cx = cos(angle);
+      window[j] = (window[i] = (.34401 + (cx * (-.49755 + (cx * .15844)))));
+    }
+    break;
+  case BLACKMAN3_WINDOW:
+    for (i = 0, j = size - 1, angle = 0.0; i <= midn; i++, j--, angle += freq) {
+      cx = cos(angle);
+      window[j] =
+	(window[i] = (.21747 + (cx * (-.45325 + (cx * (.28256 - (cx * .04672)))))));
+    }
+    break;
+  case BLACKMAN4_WINDOW:
+    for (i = 0, j = size - 1, angle = 0.0; i <= midn; i++, j--, angle += freq) {
+      cx = cos(angle);
+      window[j] = (window[i] =
+		   (.084037 +
+		    (cx *
+		     (-.29145 +
+		      (cx *
+		       (.375696 + (cx * (-.20762 + (cx * .041194)))))))));
+    }
+    break;
+  case EXPONENTIAL_WINDOW:
+    for (i = 0, j = size - 1; i <= midn; i++, j--) {
+      window[j] = (window[i] = expsum - 1.0);
+      expsum *= expn;
+    }
+    break;
+  case RIEMANN_WINDOW:
+    sr1 = two_pi / (double) size;
+    for (i = 0, j = size - 1; i <= midn; i++, j--) {
+      if (i == midn) window[j] = (window[i] = 1.0);
+      else {
+	/* split out because NeXT C compiler can't handle the full expression */
+	cx = sr1 * (midn - i);
+	window[i] = sin(cx) / cx;
+	window[j] = window[i];
+      }
+    }
+    break;
+   case BLACKMANHARRIS_WINDOW:
+	{
+		double 
+			a0 = 0.35875,
+			a1 = 0.48829,
+			a2 = 0.14128,
+			a3 = 0.01168;
+
+
+		for (i = 0; i<size;i++) {
+			window[i] = a0 - a1*cos(two_pi*(double)(i+0.5)/(double)size) 
+				+ a2*cos(2.0*two_pi*(double)(i+0.5)/(double)size)
+				- a3*cos(3.0*two_pi*(double)(i+0.5)/(double)size);
+		}
+	}
+    break;
+ default:
+    return 0;
+    break;
+  }
+
+  return window;
+}
diff --git a/jDttSP/window.h b/jDttSP/window.h
new file mode 100644
index 0000000..1266db4
--- /dev/null
+++ b/jDttSP/window.h
@@ -0,0 +1,75 @@
+/* window.h
+
+This file is part of a program that implements a Software-Defined Radio.
+
+Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
+Implemented from code by Bill Schottstaedt of Snd Editor at CCRMA
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 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 GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+The authors can be reached by email at
+
+ab2kt@arrl.net
+or
+rwmcgwier@comcast.net
+
+or by paper mail at
+
+The DTTS Microwave Society
+6 Kathleen Place
+Bridgewater, NJ 08807
+*/
+
+#ifndef _window_h
+#define _window_h
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <math.h>
+
+/* #define RECTANGULAR_WINDOW 	 1
+#define HANNING_WINDOW 		 2
+#define WELCH_WINDOW 		 3
+#define PARZEN_WINDOW 		 4
+#define BARTLETT_WINDOW 	 5
+#define HAMMING_WINDOW 		 6
+#define BLACKMAN2_WINDOW	 7
+#define BLACKMAN3_WINDOW 	 8
+#define BLACKMAN4_WINDOW 	 9
+#define EXPONENTIAL_WINDOW 	10
+#define RIEMANN_WINDOW 		11 */
+
+typedef enum _windowtype {
+  RECTANGULAR_WINDOW,
+  HANNING_WINDOW,
+  WELCH_WINDOW,
+  PARZEN_WINDOW,
+  BARTLETT_WINDOW,
+  HAMMING_WINDOW,
+  BLACKMAN2_WINDOW,
+  BLACKMAN3_WINDOW,
+  BLACKMAN4_WINDOW,
+  EXPONENTIAL_WINDOW,
+  RIEMANN_WINDOW,
+  BLACKMANHARRIS_WINDOW,
+} Windowtype;
+
+extern double *makewindow(Windowtype type, int size, double *window);
+//extern char *window_name(int n);
+extern double sqr(double x);
+
+#endif
diff --git a/pyhw/Makefile b/pyhw/Makefile
new file mode 100644
index 0000000..d97d017
--- /dev/null
+++ b/pyhw/Makefile
@@ -0,0 +1,8 @@
+python:
+	swig -python hardware.i
+	gcc -fPIC -I. -I/usr/include/python -c hardware_wrap.c
+	gcc -fPIC -I. -c hardware.c
+	ld -shared hardware.o hardware_wrap.o -o _sdr1khw.so
+clean:
+	/bin/rm -f hardware_wrap.c sdr1khw.py *.o *.so *.pyc
+
diff --git a/pyhw/README b/pyhw/README
new file mode 100644
index 0000000..28307a7
--- /dev/null
+++ b/pyhw/README
@@ -0,0 +1,37 @@
+========================================================================
+Simple stuff.
+
+To use, run python interactively. Then
+
+>>> execfile("sdr1k-setup.py")
+
+to get the interface started.
+
+To set the frequency, do 
+
+>>> setDDSFreq(14.077)
+
+To toggle the mute relay,
+
+>>> setMuteRelay(not getMuteRelay())
+
+etc.
+
+To shut down,
+
+>>> closeRig()
+
+and exit python. (The startup script, which is crude and will be
+replaced shortly, does an openRig("/dev/parport0")
+========================================================================
+
+To build:
+
+There is a simple Makefile that does just the following --
+
+swig -python hardware.i
+gcc -fPIC -I. -I/usr/include/python -c hardware_wrap.c
+gcc -fPIC -I. -c hardware.c
+ld -shared hardware.o hardware_wrap.o -o _sdr1khw.so
+
+Ready to go.
diff --git a/pyhw/hardware.c b/pyhw/hardware.c
new file mode 100644
index 0000000..65d8477
--- /dev/null
+++ b/pyhw/hardware.c
@@ -0,0 +1,985 @@
+/* hardware.c */
+
+#include <hardware.h>
+
+Rig myRig;
+
+PRIVATE void CalcClock(void);
+PRIVATE void Latch(CtrlPin vCtrlPin);
+PRIVATE void PWrite(BYTE data);
+PRIVATE void DDSWrite(BYTE data, BYTE addr);
+PRIVATE void SetRadioFreq(double f);
+PRIVATE void Delay(void);
+PRIVATE void ResetLatches(void);
+PRIVATE void ResetDDS(void);
+BOOLEAN InputPin(StatusPin vStatusPin);
+
+static int counter = 0;
+
+// ======================================================
+// Properties
+// ======================================================
+
+BOOLEAN
+getExtended(void) {
+  return myRig.extended;
+}
+
+void
+setExtended(BOOLEAN value) {
+  myRig.extended = value;
+}
+
+BOOLEAN
+getRFE_Enabled(void) {
+  return myRig.rfe_enabled;
+}
+
+void
+setRFE_Enabled(BOOLEAN value) {
+  myRig.rfe_enabled = value;
+}
+
+BOOLEAN
+getXVTR_Enabled(void) {
+  return myRig.xvtr_enabled;
+}
+
+void
+setXVTR_Enabled(BOOLEAN value) {
+  myRig.xvtr_enabled = value;
+  if (myRig.xvtr_enabled)
+    myRig.max_freq = 146.0;
+  else
+    myRig.max_freq = 65.0;
+}
+
+//    private BOOLEANxvtr_tr_logic = FALSE;
+BOOLEAN
+getXVTR_TR_Logic(void) {
+  return myRig.xvtr_tr_logic;
+}
+
+void
+setXVTR_TR_Logic(BOOLEAN value) {
+  myRig.xvtr_tr_logic = value;
+}
+
+int
+getLatchDelay(void) {
+  return myRig.latch_delay;
+}
+
+void
+setLatchDelay(int value) {
+  myRig.latch_delay = value;
+}
+
+double
+getMinFreq(void) {
+  return myRig.min_freq;
+}
+
+double
+getMaxFreq(void) {
+  return myRig.max_freq;
+}
+
+/* unsigned short
+getBaseAddr(void) {
+  return myRig.baseAdr;
+}
+
+void
+setBaseAddr(unsigned short value) {
+  myRig.baseAdr = value;
+  }*/
+
+BandSetting
+getBandRelay(void) {
+  return myRig.band_relay;
+}
+
+void
+setBandRelay(BandSetting value) {
+
+  extern void Pwrite(unsigned char);
+  myRig.band_relay = value;
+  PWrite((unsigned char) (myRig.band_relay + myRig.transmit_relay +
+			  myRig.mute_relay));
+  Latch(BPF);
+}
+
+BOOLEAN
+getTransmitRelay(void) {
+  //Get state of TR relay on BPF board
+  if (myRig.transmit_relay == TR)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+void
+setTransmitRelay(BOOLEAN value) {
+  //If in valid Amateur BandRelay Save and output new TR Relay setting
+  BYTE tmpLatch = 0;
+  BOOLEAN tmpATTN = FALSE;
+  if (value == TRUE) {
+    if (IsHamBand(myRig.curBandPlan) == TRUE) {
+      myRig.transmit_relay = TR;	// Set to TX
+      if (getRFE_Enabled()) {
+	tmpATTN = getATTN_Relay();
+	if (getXVTR_Enabled() && (myRig.dds_freq >= 144))
+	  setXVTR_TR_Relay(myRig.xvtr_tr_logic);	//Set XVTR TR to transmit
+	else
+	  setAMP_Relay(TRUE);	//Switch RFE to transmit
+
+	// TODO: REMOVE THE AMP RELAY SWITCH ON THE PRODUCTION RFE
+
+	tmpLatch = (BYTE) (myRig.transmit_relay + myRig.mute_relay);
+      } else
+	tmpLatch =
+	  (BYTE) (myRig.band_relay + myRig.transmit_relay +
+		  myRig.mute_relay);
+    }
+  } else {
+    myRig.transmit_relay = 0;	// Set to RX
+    if (getRFE_Enabled()) {
+      setAMP_Relay(FALSE);
+      tmpLatch = (BYTE) (myRig.transmit_relay + myRig.mute_relay);
+      if (getXVTR_Enabled())
+	setXVTR_TR_Relay(!myRig.xvtr_tr_logic);	// Set XVTR TR to receive
+      setATTN_Relay(tmpATTN);
+    } else
+      tmpLatch =
+	(BYTE) (myRig.band_relay + myRig.transmit_relay +
+		myRig.mute_relay);
+  }
+  PWrite(tmpLatch);
+  Latch(BPF);
+}
+
+BOOLEAN
+getMuteRelay(void) {
+//Get state of MUTE relay on TRX board
+  if (myRig.mute_relay == MUTE)
+    return FALSE;
+  else
+    return TRUE;
+}
+
+void
+setMuteRelay(BOOLEAN value) {
+  //Mute the speaker relay if TRUE
+  if (value == TRUE)
+    myRig.mute_relay = 0;
+  else
+    myRig.mute_relay = MUTE;
+  PWrite((BYTE)
+	 (myRig.band_relay + myRig.transmit_relay + myRig.mute_relay));
+  Latch(BPF);
+}
+
+BOOLEAN
+getGainRelay(void) {
+  //Get state of GAIN relay on TRX board
+  if (myRig.gain_relay == GAIN)
+    return FALSE;
+  else
+    return TRUE;
+}
+
+void
+setGainRelay(BOOLEAN value) {				//Save and output state of GAIN relay on TRX board
+  if (value == TRUE)
+    myRig.gain_relay = 0;	// 40dB or 0dB w/RFE
+  else
+    myRig.gain_relay = GAIN;	// 26dB
+  PWrite((BYTE) (myRig.external_output + myRig.gain_relay));
+  Latch(EXT);
+}
+
+int
+getExternalOutput(void) {				//Get state of External Control outputs on PIO board
+  return myRig.external_output;
+}
+
+void
+setExternalOutput(int value) {
+  //Save and output state of External Control outputs on PIO board
+  myRig.external_output = value;
+  PWrite((BYTE) (myRig.external_output + myRig.gain_relay));
+  Latch(EXT);
+}
+
+double
+getDDSClockCorrection(void) {
+  return myRig.dds_clock_correction;
+}
+
+void
+setDDSClockCorrection(double value) {
+  myRig.dds_clock_correction = value;
+  CalcClock();
+  SetRadioFreq(myRig.dds_freq);
+}
+
+int
+getPLLMult(void) {
+  return myRig.pll_mult;
+}
+
+PRIVATE void
+CalcClock(void) {
+  //sysClock = (pll_mult * dds_clock);
+  myRig.sysClock = (myRig.pll_mult * myRig.dds_clock)
+    + myRig.dds_clock_correction;
+  //Calculates step size for 16 bit frequency step size
+  myRig.dds_step_size = myRig.sysClock / pow(2.0, 48.0);
+}
+
+void
+setPLLMult(int value) {
+  myRig.pll_mult = value;
+  CalcClock();
+}
+
+double
+getDDSClock(void) {
+  return myRig.dds_clock;
+}
+
+void
+setDDSClock(double value) {
+  //Compute internal DDS System Clock and Phase Truncation Elimination Step
+  myRig.dds_clock = value;
+  CalcClock();
+}
+
+BOOLEAN
+getIFShift(void) {
+  return myRig.if_shift;
+}
+
+void
+setIFShift(BOOLEAN value) {
+  //Turns IF shift on and off
+  myRig.if_shift = value;
+  if (!myRig.spur_reduction) {
+    if (myRig.if_shift) {
+      myRig.OSC_change = -11025.0;
+      myRig.needs_OSC_change = TRUE;
+    } else {
+      myRig.OSC_change = 0.0;
+      myRig.needs_OSC_change = TRUE;
+    }
+  } else
+  myRig.needs_OSC_change = FALSE;
+  SetRadioFreq(myRig.dds_freq);
+}
+
+BOOLEAN
+getSpurReduction(void) {
+  return myRig.spur_reduction;
+}
+
+void
+setSpurReduction(BOOLEAN value) {
+  //Turns DDS Phase Truncation Spur reduction on and off
+  myRig.spur_reduction = value;
+  if (!myRig.spur_reduction) {
+    if (myRig.if_shift) {
+      myRig.OSC_change = -11025.0;
+      myRig.needs_OSC_change = TRUE;
+    } else {
+      myRig.OSC_change = 0.0;
+      myRig.needs_OSC_change = TRUE;
+    }
+  } else
+  myRig.needs_OSC_change = FALSE;
+  SetRadioFreq(myRig.dds_freq);
+}
+
+double
+getIFFreq(void) {
+  return myRig.if_freq;
+}
+
+void
+setIFFreq(double value) {
+  //Sets the offset frequency for the IF in MHz
+  myRig.if_freq = value;
+}
+
+double
+getDDSFreq(void) {
+  return myRig.dds_freq;
+}
+
+void
+setDDSFreq(double value) {
+  myRig.dds_freq = value;
+  SetRadioFreq(myRig.dds_freq);
+}
+
+int
+getSampleRate(void) {
+  return myRig.sample_rate;
+}
+
+void
+setSampleRate(int value) {
+  myRig.sample_rate = value;
+  //Compute bandwidth of FFT bin
+  if (myRig.fft_length > 0)
+    myRig.FFT_Bin_Size = (myRig.sample_rate / myRig.fft_length) * 1e-6;
+}
+
+int
+getFFTLength(void) {
+  return myRig.fft_length;
+}
+
+void
+setFFTLength(int value) {
+  myRig.fft_length = value;
+  //Compute bandwidth of FFT bin
+  if (myRig.fft_length > 0)
+    myRig.FFT_Bin_Size = (myRig.sample_rate / myRig.fft_length) * 1e-6;
+}
+
+int
+getTuneFFT(void) {
+  return myRig.tune_fft;
+}
+
+double
+getTuneFracRel(void) {
+  return myRig.tune_frac_rel;
+}
+
+double
+getVFOOffset(void) {
+  return myRig.vfo_offset;
+}
+
+void
+setVFOOffset(double value) {
+  myRig.vfo_offset = value;
+  SetRadioFreq(myRig.dds_freq);
+}
+
+int
+getIOUDClock(void) {
+  return myRig.ioud_clock;
+}
+
+void
+setIOUDClock(int value) {
+  double bitVal, bytVal;
+  int i;
+  BYTE lWord;
+  myRig.ioud_clock = value;	//Save value
+
+  bitVal = value;		//Compute Numeric Value
+
+  for (i = 24; i >= 0; i -= 8)	//Convert to binary strings
+  {
+    // bytVal = bitVal / (Math.Pow(2, i));  //Compute binary byte Value
+    bytVal = bitVal / pow(2.0, (double) i);	//Compute binary byte Value
+    lWord = (BYTE) bytVal;	//Truncate fractional portion
+    bitVal -= lWord * pow(2.0, (double) i);	//Reduce value
+    switch (i)			//Write to byte position
+    {
+    case 32:
+      DDSWrite(lWord, 22);
+      break;
+    case 16:
+      DDSWrite(lWord, 23);
+      break;
+    case 8:
+      DDSWrite(lWord, 24);
+      break;
+    case 0:
+      DDSWrite(lWord, 25);
+      break;
+    }
+  }
+}
+
+unsigned short
+getDACMult(void) {
+  return myRig.dac_mult;
+}
+
+void
+setDACMult(unsigned short value) {
+  double bitVal, bytVal;
+  int i;
+  BYTE lWord;
+  //Send new I DAC Multiplier value to DDS
+  myRig.dac_mult = value;
+  bitVal = value;		//Compute Numeric Value
+  for (i = 8; i >= 0; i -= 8)	//Convert to binary strings
+  {
+    bytVal = bitVal / pow(2.0, (double) i);	//Compute binary byte Value
+    lWord = (BYTE) bytVal;	//Truncate fractional portion
+    bitVal -= lWord * pow(2.0, (double) i);	//Reduce value
+    switch (i) {
+    case 8:
+      DDSWrite(lWord, 33);
+      break;
+    case 0:
+      DDSWrite(lWord, 34);
+      break;
+    }
+  }
+
+  bitVal = value;		//Compute Numeric Value
+  for (i = 8; i >= 0; i -= 8)	//Convert to binary strings
+  {
+    bytVal = bitVal / pow(2.0, (double) i);	//Compute binary byte Value
+    lWord = (BYTE) bytVal;	//Truncate fractional portion
+    bitVal -= lWord * pow(2.0, (double) i);	//Reduce value
+    switch (i) {
+    case 8:
+      DDSWrite(lWord, 35);
+      break;
+    case 0:
+      DDSWrite(lWord, 36);
+      break;
+    }
+  }
+}
+
+// ======================================================
+// Private Member Functions
+// ======================================================
+
+PRIVATE void
+Delay(void) {
+  usleep(1000 * myRig.latch_delay);
+}
+
+PRIVATE void
+Latch(CtrlPin vCtrlPin) {
+  unsigned char mask;
+  //Strobe the specified pin to latch data
+  switch (vCtrlPin) {
+  case EXT:
+    mask = 0xA, ioctl(myRig.fd, PPWCONTROL, &mask);
+    Delay();
+    mask = 0xB, ioctl(myRig.fd, PPWCONTROL, &mask);
+    break;
+  case BPF:
+    mask = 0x9, ioctl(myRig.fd, PPWCONTROL, &mask);
+    Delay();
+    mask = 0xB, ioctl(myRig.fd, PPWCONTROL, &mask);
+    break;
+  case DAT:
+    mask = 0xF, ioctl(myRig.fd, PPWCONTROL, &mask);
+    Delay();
+    mask = 0xB, ioctl(myRig.fd, PPWCONTROL, &mask);
+    break;
+  case ADR:
+    mask = 0x3, ioctl(myRig.fd, PPWCONTROL, &mask);
+    Delay();
+    mask = 0xB, ioctl(myRig.fd, PPWCONTROL, &mask);
+    break;
+  }
+}
+
+PRIVATE void
+ResetLatches(void) {				//Set all latch outputs to logic zero (relays off)
+  PWrite(0);
+  Latch(ADR);
+  Latch(DAT);
+
+  myRig.gain_relay = GAIN;
+  myRig.external_output = 0;
+  PWrite((BYTE) (myRig.external_output + myRig.gain_relay));
+  Latch(EXT);
+
+  setBandRelay(bsnone);
+  myRig.transmit_relay = 0;
+  myRig.mute_relay = MUTE;
+
+  PWrite((BYTE)
+	 (myRig.band_relay + myRig.transmit_relay + myRig.mute_relay));
+  Latch(BPF);
+}
+
+PRIVATE void
+PWrite(BYTE data) {				//Write data Byte to parallel port
+  ioctl(myRig.fd, PPWDATA, &data);
+  Delay();			//Delay to allow data line setup
+}
+
+PRIVATE void
+ResetDDS(void) {
+  PWrite(RESET + WRB);		//Reset the DDS chip
+  Latch(ADR);
+  PWrite(WRB);			//Leave WRB high
+  Latch(ADR);
+  DDSWrite(COMP_PD, 29);	//Power down comparator
+  //TODO: ADD PLL MULTIPLIER PROPERTY AND LOGIC
+  DDSWrite(BYPASS_PLL, 30);	//Bypass PLL
+  //DDSWrite(BYPASS_SINC + OSK_EN, 32);//Bypass Inverse Sinc and enable DAC Mult
+  DDSWrite(BYPASS_SINC, 32);
+  setDACMult(4095);		//Set DAC multiplier value
+}
+
+PRIVATE void
+DDSWrite(BYTE data, BYTE addr) {
+  //Set up data bits
+  PWrite(data);
+  Latch(DAT);
+
+  //Set up address bits with WRB high
+  PWrite((BYTE) (addr + WRB));
+  Latch(ADR);
+
+  //Send write command with WRB low
+  PWrite(addr);
+  Latch(ADR);
+
+  //Return WRB high
+  PWrite(WRB);
+  Latch(ADR);
+}
+
+PRIVATE void
+SetRadioFreq(double f) {
+  double vfoFreq = f;
+  int i;
+  // calculate software frequency to program
+  if (getXVTR_Enabled() && f >= 144 && f <= 146)	//If transverter enabled compute 28MHz IF frequency
+    f -= 116;			//Subtract 116MHz (144-28) from VFO display frequency
+
+  if (myRig.if_shift)
+    f -= myRig.if_freq;	// adjust for IF shift
+
+  f += myRig.vfo_offset;	// adjust for vfo offset
+
+  unsigned long long int tuning_word =
+    (unsigned long long int) (f / myRig.sysClock * pow(2.0, 48.0));
+
+  // start with current tuning word
+  // clear first bit, low 31 bits; set bit 31
+  if (myRig.spur_reduction) {
+    unsigned long long int sr_tuning_word =
+      (tuning_word & ~(0x80007fffffffLL)) | 0x000080000000LL;
+    double software_offset =
+      (sr_tuning_word - tuning_word) * myRig.dds_step_size;
+
+    if (myRig.if_shift)	//Convert the tuning fraction to rel frq
+      myRig.tune_frac_rel = 1000000.0 * (software_offset) - 11025.0;
+    else
+      myRig.tune_frac_rel = 1000000.0 * (software_offset);
+    myRig.OSC_change = myRig.tune_frac_rel;
+    myRig.needs_OSC_change = TRUE;
+
+    tuning_word = sr_tuning_word;
+  }
+  // program hardware
+  SetBPF(vfoFreq);
+
+  if (tuning_word != myRig.last_tuning_word) {
+    //Debug.WriteLine("tuning_word != last_tuning_word");
+    //Debug.Write("tuning word: ");
+
+    myRig.last_tuning_word = tuning_word;	//save new tuning word    
+
+    for (i = 0; i < 6; i++) {
+      BYTE b =
+	(BYTE) (tuning_word >> (unsigned long long int) (40 - i * 8)) &
+	0xFFLL;
+      //Debug.Write(b+" ");
+      DDSWrite(b, (BYTE) (4 + i));
+    }
+    //Debug.WriteLine("");
+  }
+}
+
+// ======================================================
+// Public Member Functions
+// ======================================================
+
+BOOLEAN
+InputPin(StatusPin vStatusPin) {				//Readback state and mask specified status pin
+  unsigned char status;
+  ioctl(myRig.fd, PPRSTATUS, &status);
+  if (vStatusPin == PIN_11)	//Pin 11 is inverted
+    return (((BYTE) vStatusPin & status) == 0);
+  else
+    return (((BYTE) vStatusPin & status) != 0);
+}
+
+BYTE
+StatusPort(void) {
+  unsigned char status;
+  ioctl(myRig.fd, PPRSTATUS, &status);
+  return status;
+}
+
+void
+RigInit(void) {
+  setIFShift(TRUE);
+
+  // user setable through the setup form
+  //DDSClockCorrection = 0.000;
+  setPLLMult(1);
+  setDDSClock(200.0);
+  setIFFreq(0.011025);
+  setSampleRate(48000);
+  setFFTLength(4096);
+  setDACMult(4095);
+
+  //                      ResetLatches(void);         //Reset all control latches
+  //
+  //                      if(RFE_Enabled)
+  //                      {
+  //                              ResetRFE(void);
+  //                              if(XVTR_Enabled)
+  //                                      XVTR_TR_Relay = TRUE;  //Set transverter to receive mode
+  //                      }
+  //                      ResetDDS(void);                     //Hardware reset for DDS                        
+}
+
+void
+PowerOn(void) {
+  // set mute/gain relays based on console
+  if (getXVTR_Enabled())
+    setXVTR_TR_Relay(!myRig.xvtr_tr_logic);
+  setDDSFreq(myRig.dds_freq);
+}
+
+void
+StandBy(void) {
+  ResetLatches();
+  if (getRFE_Enabled())
+    ResetRFE();
+  if (getXVTR_Enabled())
+    setXVTR_TR_Relay(FALSE);
+  ResetDDS();
+}
+
+void
+SetExt(ExtPin pin) {
+  //Set the designated external pin high
+  myRig.external_output += (BYTE) pin;
+  PWrite((BYTE) (myRig.external_output + myRig.gain_relay));
+  Latch(EXT);
+}
+
+void
+ResExt(ExtPin pin) {
+  //Reset the designated external pin high
+  myRig.external_output -= (BYTE) pin;
+  PWrite((BYTE) (myRig.external_output + myRig.gain_relay));
+  Latch(EXT);
+}
+
+BOOLEAN
+PinValue(ExtPin pin) {
+  //Return TRUE if Pin is set
+  if ((myRig.external_output & (int) pin) != 0)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+void
+SetBPF(double VFOValue) {
+  if (getRFE_Enabled())		// RFE is present
+  {
+    //Use shift registers on RFE to control BPF and LPF banks
+    if (VFOValue <= 2)		// DC to 2MHz
+    {
+      SRLoad(IC10, LPF9 + BPF0);
+      SRLoad(IC9, 0);
+    } else if (VFOValue <= 4)	// 2MHz to 4MHz
+    {
+      SRLoad(IC10, BPF1);
+      SRLoad(IC9, LPF7);
+    } else if (VFOValue <= 6)	// 4MHz to 6MHz
+    {
+      SRLoad(IC10, BPF1);
+      SRLoad(IC9, LPF2);
+    } else if (VFOValue <= 7.3)	// 6MHz to 7.3MHz
+    {
+      SRLoad(IC10, BPF2);
+      SRLoad(IC9, LPF5);
+    } else if (VFOValue <= 10.2)	// 7.3MHz to 10.2MHz
+    {
+      SRLoad(IC10, BPF2);
+      SRLoad(IC9, LPF4);
+    } else if (VFOValue <= 12)	// 10.2MHz to 12MHz
+    {
+      SRLoad(IC10, BPF2);
+      SRLoad(IC9, LPF3);
+    } else if (VFOValue <= 14.5)	// 12MHz to 14.5MHz
+    {
+      SRLoad(IC10, BPF3);
+      SRLoad(IC9, LPF3);
+    } else if (VFOValue <= 21.5)	// 14.5MHz to 21.5MHz
+    {
+      SRLoad(IC10, BPF3 + LPF8);
+      SRLoad(IC9, 0);
+    } else if (VFOValue <= 24)	// 21.5MHz to 24MHz
+    {
+      SRLoad(IC10, BPF3);
+      SRLoad(IC9, LPF6);
+    } else if (VFOValue <= 30)	// 24MHz to 30MHz
+    {
+      SRLoad(IC10, BPF4);
+      SRLoad(IC9, LPF6);
+    } else if (VFOValue <= 36)	// 30MHz to 36MHz
+    {
+      SRLoad(IC10, BPF4);
+      SRLoad(IC9, LPF1);
+    } else if (VFOValue <= 65)	// 36MHz to 65Mhz
+    {
+      SRLoad(IC10, BPF5);
+      SRLoad(IC9, LPF1);
+    } else if (getXVTR_Enabled() && VFOValue >= 144 && VFOValue <= 146)	//28MHz IF for transverter
+    {
+      SRLoad(IC10, BPF4);
+      SRLoad(IC9, LPF6);
+      setXVTR_Relay(TRUE);
+    }
+    if (getXVTR_Enabled() && VFOValue < 144)
+      setXVTR_Relay(FALSE);
+  } else			// RFE is not present
+  {
+    //Select the BPF relays using the high frequency cutoff
+    if (VFOValue < 2)		//DC to 2MHz
+      setBandRelay(bs0);
+    else if (VFOValue < 6)	//2MHz to 6MHz
+      setBandRelay(bs1);
+    else if (VFOValue < 12)	//6MHz to 12MHz
+      setBandRelay(bs2);
+    else if (VFOValue < 24)	//12MHz to 24MHz
+      setBandRelay(bs3);
+    else if (VFOValue < 36)	//24MHz to 36MHz
+      setBandRelay(bs4);
+    else			//36MHz to 65Mhz
+      setBandRelay(bs5);
+  }
+}
+
+BOOLEAN
+IsHamBand(BandPlan b) {
+  if (myRig.extended)
+    return TRUE;
+
+  switch (b) {
+  case IARU1:
+    if (myRig.dds_freq >= 1.8 && myRig.dds_freq <= 2.0)
+      return TRUE;
+    else if (myRig.dds_freq >= 3.5 && myRig.dds_freq <= 4.0)
+      return TRUE;
+    else if (myRig.dds_freq == 5.3305)
+      return TRUE;
+    else if (myRig.dds_freq == 5.3465)
+      return TRUE;
+    else if (myRig.dds_freq == 5.3665)
+      return TRUE;
+    else if (myRig.dds_freq == 5.3715)
+      return TRUE;
+    else if (myRig.dds_freq == 5.4035)
+      return TRUE;
+    else if (myRig.dds_freq >= 7.0 && myRig.dds_freq <= 7.3)
+      return TRUE;
+    else if (myRig.dds_freq >= 10.1 && myRig.dds_freq <= 10.15)
+      return TRUE;
+    else if (myRig.dds_freq >= 14.0 && myRig.dds_freq <= 14.35)
+      return TRUE;
+    else if (myRig.dds_freq >= 18.068 && myRig.dds_freq <= 18.168)
+      return TRUE;
+    else if (myRig.dds_freq >= 21.0 && myRig.dds_freq <= 21.45)
+      return TRUE;
+    else if (myRig.dds_freq >= 24.89 && myRig.dds_freq <= 24.99)
+      return TRUE;
+    else if (myRig.dds_freq >= 21.0 && myRig.dds_freq <= 21.45)
+      return TRUE;
+    else if (myRig.dds_freq >= 28.0 && myRig.dds_freq <= 29.7)
+      return TRUE;
+    else if (myRig.dds_freq >= 50.0 && myRig.dds_freq <= 54.0)
+      return TRUE;
+    else if (myRig.dds_freq >= 144.0 && myRig.dds_freq <= 146.0) {
+      if (getRFE_Enabled() && getXVTR_Enabled())
+	return TRUE;
+      else
+	return FALSE;
+    } else
+      return FALSE;
+  default:
+    return FALSE;
+    // TODO: Implement other bandplans here
+  }
+}
+
+void
+TestPort(void) {
+  //Toggle 1 and 0 to each of the four parallel port latches
+  PWrite(0);
+  Latch(BPF);
+  Latch(ADR);
+  Latch(DAT);
+  Latch(EXT);
+  PWrite(255);
+  Latch(BPF);
+  Latch(ADR);
+  Latch(DAT);
+  Latch(EXT);
+}
+
+void
+RCKStrobe(BOOLEAN ClearReg, RFE_RCK Reg) {
+  //Strobe the RFE 1:4 decoder output to transfer contents of shift register to output latches
+  if (ClearReg)			//Clear the shift register contents
+    PWrite((BYTE) (Reg));	//Strobe decoder output low and clear register
+  else
+    PWrite((BYTE) (SCLR_NOT + Reg + myRig.transmit_relay + myRig.mute_relay));	//Strobe decoder output low
+  Latch(BPF);
+  PWrite((BYTE) (SCLR_NOT + DCDR_NE + myRig.transmit_relay + myRig.mute_relay));	//Disable 1:4 decoder outputs
+  Latch(BPF);
+}
+
+void
+SRLoad(RFE_RCK Reg, int Data) {
+  //Shift data into shift registers on RFE
+  int choose[] = { 128, 64, 32, 16, 8, 4, 2, 1 };
+  int i;
+
+  for (i = 0; i < 8; i++) {
+    int mask = choose[i];	//Mask the current bit
+    if ((mask & Data) == 0)	//Current bit = 0
+    {
+      PWrite((BYTE) (SCLR_NOT + DCDR_NE + myRig.transmit_relay + myRig.mute_relay));	//Output 0 bit
+      Latch(BPF);
+      PWrite((BYTE) (SCLR_NOT + DCDR_NE + SCK + myRig.transmit_relay + myRig.mute_relay));	//Clock 0 into shift register
+    } else			//Current bit = 1
+    {
+      PWrite((BYTE) (SCLR_NOT + DCDR_NE + SER + myRig.transmit_relay + myRig.mute_relay));	//Output 1 bit
+      Latch(BPF);
+      PWrite((BYTE) (SCLR_NOT + DCDR_NE + SER + SCK + myRig.transmit_relay + myRig.mute_relay));	//Clock 1 into shift register
+    }
+    Latch(BPF);
+    PWrite((BYTE) (SCLR_NOT + DCDR_NE + myRig.transmit_relay + myRig.mute_relay));	//Return SCK low
+    Latch(BPF);
+  }
+  RCKStrobe(FALSE, Reg);	//Strobe Register Clock
+}
+
+void
+ResetRFE(void) {
+  //Reset all RFE shift registers to zero output
+  RCKStrobe(TRUE, IC11);
+  RCKStrobe(TRUE, IC7);
+  RCKStrobe(TRUE, IC10);
+  RCKStrobe(TRUE, IC9);
+}
+
+BOOLEAN
+getAMP_Relay(void) {
+  return (myRig.m_IC7_Memory & AMP_RLYS) != 0;
+}
+
+void
+setAMP_Relay(BOOLEAN value) {
+  //Set or reset LNA relay
+  if (value)
+    myRig.m_IC7_Memory = (myRig.m_IC7_Memory | AMP_RLYS);
+  else
+    myRig.m_IC7_Memory = (myRig.m_IC7_Memory & (AMP_RLYS ^ 255));
+  SRLoad(IC7, myRig.m_IC7_Memory);
+}
+
+
+BOOLEAN
+getATTN_Relay(void) {
+  return (myRig.m_IC7_Memory & ATTN_RLY) != 0;
+}
+
+void
+setATTN_Relay(BOOLEAN value) {
+  //Set or reset attenuator relay
+  if (value)
+    myRig.m_IC7_Memory = (myRig.m_IC7_Memory | ATTN_RLY);
+  else
+    myRig.m_IC7_Memory = (myRig.m_IC7_Memory & (ATTN_RLY ^ 255));
+  SRLoad(IC7, myRig.m_IC7_Memory);
+}
+
+BOOLEAN
+getXVTR_TR_Relay(void) {
+  return (myRig.m_IC7_Memory & XVTR_TR_RLY) != 0;
+}
+
+void
+setXVTR_TR_Relay(BOOLEAN value) {
+  //Set or reset transverter relay
+  if (value)
+    myRig.m_IC7_Memory = (myRig.m_IC7_Memory | XVTR_TR_RLY);
+  else
+    myRig.m_IC7_Memory = myRig.m_IC7_Memory & (XVTR_TR_RLY ^ 255);
+  SRLoad(IC7, myRig.m_IC7_Memory);
+}
+
+BOOLEAN
+getXVTR_Relay(void) {
+  return (myRig.m_IC7_Memory & XVTR_RLY) != 0;
+}
+
+void
+setXVTR_Relay(BOOLEAN value) {
+  //Set or reset XVTR 8R (TR) relay
+  if (value)
+    myRig.m_IC7_Memory = myRig.m_IC7_Memory | XVTR_RLY;
+  else
+    myRig.m_IC7_Memory = myRig.m_IC7_Memory & (XVTR_RLY ^ 255);
+  SRLoad(IC7, myRig.m_IC7_Memory);
+}
+
+BOOLEAN
+getIMPULSE_Relay(void) {
+  return (myRig.m_IC7_Memory & IMPULSE_RLY) != 0;
+}
+
+void
+setIMPULSE_Relay(BOOLEAN value) {
+  //Set or reset Impulse relay
+  if (value)
+    myRig.m_IC7_Memory = myRig.m_IC7_Memory | IMPULSE_RLY;
+  else
+    myRig.m_IC7_Memory = myRig.m_IC7_Memory & (IMPULSE_RLY ^ 255);
+  SRLoad(IC7, myRig.m_IC7_Memory);
+}
+
+void
+Impulse(void) {
+  //Send a single impulse to the QSD
+  SRLoad(IC7, (myRig.m_IC7_Memory | 128));
+  SRLoad(IC7, myRig.m_IC7_Memory);
+}
+
+BOOLEAN
+openRig(char *port) {
+  int mode = IEEE1284_MODE_COMPAT;
+  if (!port) port = "/dev/parport0";
+  if ((myRig.fd = open(port, O_RDWR)) < 0) {
+    perror("open parallel port");
+    return FALSE;
+  }
+  ioctl(myRig.fd, PPCLAIM);
+  ioctl(myRig.fd, PPSETMODE, &mode);
+  return TRUE;
+}
+  
+void
+closeRig(void) {
+  ioctl(myRig.fd, PPRELEASE);
+  close(myRig.fd);
+}
diff --git a/pyhw/hardware.h b/pyhw/hardware.h
new file mode 100644
index 0000000..99e81c7
--- /dev/null
+++ b/pyhw/hardware.h
@@ -0,0 +1,318 @@
+/* hardware.h */
+
+#ifndef _HARDWARE_H
+#define _HARDWARE_H
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/wait.h>  
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>  
+#include <signal.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <setjmp.h>
+
+#include <stdlib.h>
+#include <values.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <string.h>
+#include <math.h>
+#include <assert.h>
+#include <libgen.h>
+
+#include <pthread.h>
+#include <semaphore.h>
+
+#include <linux/ppdev.h>
+#include <linux/parport.h>
+
+#ifndef PRIVATE
+#define PRIVATE static
+#endif
+
+typedef int BOOLEAN;
+typedef unsigned char BYTE;
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+// ======================================================
+// Constants and PRIVATE Variables
+// ======================================================
+
+typedef enum _bandplan
+{
+  IARU1 = 1,
+  IARU2 = 2,
+  IARU3 = 3,
+} BandPlan;
+
+//Constants for BPF relays
+
+typedef enum _bandsetting
+{
+  bsnone = 0,			//none
+  bs0 = 0x01,			//2.5MHz LPF
+  bs1 = 0x02,			//2-6MHz BPF
+  bs2 = 0x08,			//5-12MHz BPF
+  bs3 = 0x04,			//10-24MHz BPF
+  bs4 = 0x10,			//20-40MHz BPF
+  bs5 = 0x20,			//35-60MHz BPF
+} BandSetting;
+
+//PIO Control Pin Numbers
+
+typedef enum _ctrlpin
+{
+  EXT = 1,			//C0
+  BPF = 14,			//C1
+  DAT = 16,			//C2
+  ADR = 17,			//C3
+} CtrlPin;
+
+//PIO Status Mask
+
+typedef enum _statuspin
+{
+  PIN_12 = 0x08,		//S3
+  Dash = 0x10,			//S4
+  Dot = 0x20,			//S5
+  PTT = 0x40,			//S6
+  PIN_11 = 0x80,		//S7
+} StatusPin;
+
+//External control port mask
+
+typedef enum _extpin
+{
+  P1 = 0x01,
+  P2 = 0x02,
+  P3 = 0x04,
+  P4 = 0x08,
+  P5 = 0x10,
+  P6 = 0x20,
+  P7 = 0x40,
+} ExtPin;
+
+//BEGIN RFE CONTROLS =====================================================
+
+//Control and data lines for RFE serial decoders
+#define SER  1
+#define SCK  2
+#define SCLR_NOT  4
+#define DCDR_NE  32
+
+//RFE 1:4 Decoder (74HC139) values to drive shift register RCK lines
+typedef enum _rfe_rck
+{
+  IC11 = 0,
+  IC7 = 8,
+  IC9 = 24,
+  IC10 = 16,
+} RFE_RCK;
+
+//RFE control constants
+#define LPF0  1			//On board low pass filter relays
+#define LPF1 2
+#define LPF2  4
+#define LPF3 8
+#define LPF4 16
+#define LPF5  32
+#define LPF6  64
+#define LPF7  128
+#define LPF8  1
+#define LPF9 2
+
+#define BPF0  128		//Band pass filter relays
+#define BPF1  64
+#define BPF2  16		//Note: BPF2 and BPF3 are reverse order
+#define BPF3  32		//on BPF board
+#define BPF4  8
+#define BPF5  4
+
+#define PAF0  1			//Power Amplifier low pass filters
+#define PAF1  2
+#define PAF2  4
+#define PAF3  8
+#define PAF4  16
+#define PAF5  32
+#define PAFR  64		//Power amplifier TR relay
+
+#define ATUCTL  128		//Automatic Tuning Unit control
+
+#define AMP_RLYS  3		//Controls both AMP1 and AMP2 relays
+#define XVTR_RLY  8		//Switches 2M transverter switching relayinto signal path
+#define ATTN_RLY  16		//Attenuator relay
+#define XVTR_TR_RLY  4		//2M transverter TR relay (on for RX) XVRX on schematic
+#define IMPULSE_RLY  32		//Impulse circuit switching relay
+#define SPARE_CTRL  64		//Spare control line to PA
+
+
+//Constants latch outputs
+
+#define TR  0x40
+#define MUTE  0x80
+#define GAIN  0x80
+#define WRB  0x40
+#define RESET  0x80
+
+//DDS Control Constants
+#define COMP_PD  0x10		//DDS Comparator power down
+#define DIG_PD  0x01		//DDS Digital Power down
+#define BYPASS_PLL  0x20	//Bypass DDS PLL
+#define INT_IOUD  0x01		//Internal IO Update
+#define OSK_EN  0x20		//Offset Shift Keying enable
+#define OSK_INT  0x10		//Offset Shift Keying
+#define BYPASS_SINC  0x40	//Bypass Inverse Sinc Filter
+#define PLL_RANGE  0x40		//Set PLL Range
+
+typedef struct _rig
+{
+  //PIO register base address
+//  unsigned short baseAdr;
+  double min_freq;		// minimum allowable tuning frequency
+  double max_freq;		// maximum allowable tuning frequency
+  unsigned radio_number;
+  unsigned short Adr;
+  int m_IC7_Memory;
+  //RFE relay memory
+  BOOLEAN rfe_enabled;		//True if RFE board is enabled
+  BOOLEAN xvtr_enabled;		//Transverter is enabled
+  BOOLEAN extended;
+  BOOLEAN xvtr_tr_logic;
+
+  // END RFE controls
+  //Latch Memories
+
+  BandSetting band_relay;
+  int external_output;
+  int mute_relay;
+  int transmit_relay;
+  int gain_relay;
+  int latch_delay;
+
+  //DDS Clock properties
+  double dds_clock;
+  int pll_mult;
+  double dds_clock_correction;
+  double sysClock;
+  int ioud_clock;
+  unsigned short dac_mult;
+
+  //DDS Frequency Control properties
+  double dds_freq;
+  double if_freq;
+  BOOLEAN if_shift;
+  BOOLEAN spur_reduction;
+  double dds_step_size;
+  int sample_rate;
+  int fft_length;
+  double FFT_Bin_Size;
+  int tune_fft;
+  double tune_frac_rel;
+  double vfo_offset;
+  double last_VFO;
+
+  //Current Bandplan
+  BandPlan curBandPlan;
+
+  double TWO_TO_THE_48_DIVIDED_BY_200;
+  long last_tuning_word;
+
+  int fd;
+  BOOLEAN needs_OSC_change;
+  double OSC_change;
+} Rig;
+
+extern Rig myRig;
+
+extern BOOLEAN openRig(char *port);
+extern void closeRig(void);
+
+extern BOOLEAN getExtended(void);
+extern void setExtended(BOOLEAN value);
+extern BOOLEAN getRFE_Enabled(void);
+extern void setRFE_Enabled(BOOLEAN value);
+extern BOOLEAN getXVTR_Enabled(void);
+extern void setXVTR_Enabled(BOOLEAN value);
+extern BOOLEAN getXVTR_TR_Logic(void);
+extern void setXVTR_TR_Logic(BOOLEAN value);
+extern int getLatchDelay(void);
+extern void setLatchDelay(int value);
+extern double getMinFreq(void);
+extern double getMaxFreq(void);
+//extern unsigned short getBaseAddr(void);
+//extern void setBaseAddr(unsigned short value);
+extern BandSetting getBandRelay(void);
+extern void setBandRelay(BandSetting value);
+extern BOOLEAN getTransmitRelay(void);
+extern void setTransmitRelay(BOOLEAN value);
+extern BOOLEAN getMuteRelay(void);
+extern void setMuteRelay(BOOLEAN value);
+extern BOOLEAN getGainRelay(void);
+extern void setGainRelay(BOOLEAN value);
+extern int getExternalOutput(void);
+extern void setExternalOutput(int value);
+extern double getDDSClockCorrection(void);
+extern void setDDSClockCorrection(double value);
+extern int getPLLMult(void);
+extern void setPLLMult(int value);
+extern double getDDSClock(void);
+extern void setDDSClock(double value);
+extern BOOLEAN getIFShift(void);
+extern void setIFShift(BOOLEAN value);
+extern BOOLEAN getSpurReduction(void);
+extern void setSpurReduction(BOOLEAN value);
+extern double getIFFreq(void);
+extern void setIFFreq(double value);
+extern double getDDSFreq(void);
+extern void setDDSFreq(double value);
+extern int getSampleRate(void);
+extern void setSampleRate(int value);
+extern int getFFTLength(void);
+extern void setFFTLength(int value);
+extern int getTuneFFT(void);
+extern double getTuneFracRel(void);
+extern double getVFOOffset(void);
+extern void setVFOOffset(double value);
+extern int getIOUDClock(void);
+extern void setIOUDClock(int value);
+extern unsigned short getDACMult(void);
+extern void setDACMult(unsigned short value);
+extern BOOLEAN InputPin(StatusPin vStatusPin);
+extern BYTE StatusPort(void);
+extern void RigInit(void);
+extern void PowerOn(void);
+extern void StandBy(void);
+extern void SetExt(ExtPin pin);
+extern void ResExt(ExtPin pin);
+extern BOOLEAN PinValue(ExtPin pin);
+extern void SetBPF(double VFOValue);
+extern BOOLEAN IsHamBand(BandPlan b);
+extern void TestPort(void);
+extern void RCKStrobe(BOOLEAN ClearReg, RFE_RCK Reg);
+extern void SRLoad(RFE_RCK Reg, int Data);
+extern void ResetRFE(void);
+extern BOOLEAN getAMP_Relay(void);
+extern void setAMP_Relay(BOOLEAN value);
+extern BOOLEAN getATTN_Relay(void);
+extern void setATTN_Relay(BOOLEAN value);
+extern BOOLEAN getXVTR_TR_Relay(void);
+extern void setXVTR_TR_Relay(BOOLEAN value);
+extern BOOLEAN getXVTR_Relay(void);
+extern void setXVTR_Relay(BOOLEAN value);
+extern BOOLEAN getIMPULSE_Relay(void);
+extern void setIMPULSE_Relay(BOOLEAN);
+extern void Impulse(void);
+#endif
diff --git a/pyhw/hardware.i b/pyhw/hardware.i
new file mode 100644
index 0000000..99a24ff
--- /dev/null
+++ b/pyhw/hardware.i
@@ -0,0 +1,5 @@
+%module sdr1khw
+%{
+#include "hardware.h"
+%}
+%include "hardware.h"
diff --git a/pyhw/sdr1k-setup.py b/pyhw/sdr1k-setup.py
new file mode 100644
index 0000000..ba50777
--- /dev/null
+++ b/pyhw/sdr1k-setup.py
@@ -0,0 +1,19 @@
+from sdr1khw import *
+
+openRig("/dev/parport0")
+setRFE_Enabled(TRUE)
+ResetRFE()
+setXVTR_Enabled(FALSE)
+setExtended(FALSE)
+setXVTR_TR_Logic(FALSE)
+setBandRelay(bs0)
+RigInit()
+setVFOOffset(0.0)
+setATTN_Relay(TRUE)
+setTransmitRelay(FALSE)
+setGainRelay(TRUE)
+setSpurReduction(FALSE)
+setExternalOutput(FALSE)
+setDDSClockCorrection(0.0)
+setDDSFreq(13.845)
+setMuteRelay(FALSE)