Initial import of argyll version 1.5.1-8debian/1.5.1-8

1 files changed, 12093 insertions, 0 deletions

diff --git a/spectro/i1pro_imp.c b/spectro/i1pro_imp.c
new file mode 100644
index 0000000..2211bd4
--- /dev/null
+++ b/spectro/i1pro_imp.c
@@ -0,0 +1,12093 @@
+
+/*
+ * Argyll Color Correction System
+ *
+ * Gretag i1Pro implementation functions
+ *
+ * Author: Graeme W. Gill
+ * Date:   24/11/2006
+ *
+ * Copyright 2006 - 2013 Graeme W. Gill
+ * All rights reserved.
+ *
+ * This material is licenced under the GNU GENERAL PUBLIC LICENSE Version 2 or later :-
+ * see the License2.txt file for licencing details.
+ */
+
+/* 
+   If you make use of the instrument driver code here, please note
+   that it is the author(s) of the code who take responsibility
+   for its operation. Any problems or queries regarding driving
+   instruments with the Argyll drivers, should be directed to
+   the Argyll's author(s), and not to any other party.
+
+   If there is some instrument feature or function that you
+   would like supported here, it is recommended that you
+   contact Argyll's author(s) first, rather than attempt to
+   modify the software yourself, if you don't have firm knowledge
+   of the instrument communicate protocols. There is a chance
+   that an instrument could be damaged by an incautious command
+   sequence, and the instrument companies generally cannot and
+   will not support developers that they have not qualified
+   and agreed to support.
+ */
+
+/* TTBD:
+
+	Some things probably aren't quite correct:
+	The way the sensor saturation and optimal target is
+	computed probably doesn't account for the dark level
+	correctly, since the targets are in sensor value,
+	but the comparison is done after subtracting black ??
+	See the Munki implementation for an approach to fix this ??
+
+	It should be possible to add a refresh-display calibration
+	routine based on an emissive scan + the auto-correlation
+	(see i1d3.c). Whether this will noticably improve repeatibility
+	remains to be seen.
+*/
+
+/*
+	Notes:
+
+	Naming of spectral values:
+
+		sensor  - the 16 bit values from the sensor including any dummy/shielded values
+		raw		- the floating point values of the spectral section 
+		absraw	- raw after scaling for integration time and gain settings.
+
+	The Rev D seems to die if it is ever given a GET_STATUS. This is why
+	the WinUSB driver can't be used with it.
+
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <time.h>
+#include <stdarg.h>
+#include <math.h>
+#if defined(UNIX)
+# include <utime.h>
+#else
+# include <sys/utime.h>
+#endif
+#include <sys/stat.h>
+#ifndef SALONEINSTLIB
+#include "copyright.h"
+#include "aconfig.h"
+#include "numlib.h"
+#include "rspl.h"
+#else /* SALONEINSTLIB */
+#include <fcntl.h>
+#include "sa_config.h"
+#include "numsup.h"
+#include "rspl1.h"
+#endif /* SALONEINSTLIB */
+#include "xspect.h"
+#include "insttypes.h"
+#include "conv.h"
+#include "icoms.h"
+#include "sort.h"
+
+/* Configuration */
+#define ENABLE_2		/* [Def] Enable i1pro2/Rev E driver code, else treat i1pro2 as i1pro */
+#undef USE_HIGH_GAIN_MODE /* [Und] Make use of high gain mode in Rev A-D mode */ 
+#define USE_THREAD		/* Need to use thread, or there are 1.5 second internal */
+						/* instrument delays ! */
+#undef WAIT_FOR_DELAY_TRIGGER	/* [Und] Hack to diagnose threading problems */
+#undef ENABLE_WRITE		/* [Und] Enable writing of calibration and log data to the EEProm */
+#define ENABLE_NONVCAL	/* [Def] Enable saving calibration state between program runs in a file */
+#define ENABLE_NONLINCOR	/* [Def] Enable non-linear correction */
+#define WLCALTOUT (24 * 60 * 60) /* [24 Hrs] Wavelength calibration timeout in seconds */
+#define DCALTOUT  (     60 * 60) /* [60 Minuites] Dark Calibration timeout in seconds */
+#define DCALTOUT2 ( 1 * 60 * 60) /* [1 Hr] i1pro2 Dark Calibration timeout in seconds */
+#define WCALTOUT  ( 1 * 60 * 60) /* [1 Hr] White Calibration timeout in seconds */
+#define MAXSCANTIME 15.0	/* [15] Maximum scan time in seconds */
+#define SW_THREAD_TIMEOUT	(10 * 60.0) 	/* [10 Min] Switch read thread timeout */
+
+#define SINGLE_READ		/* [Def] Use a single USB read for scan to eliminate latency issues. */
+#define HIGH_RES		/* [Def] Enable high resolution spectral mode code. Dissable */
+						/* to break dependency on rspl library. */
+
+/* Debug [Und] */
+#undef DEBUG			/* Turn on debug printfs */
+#undef PLOT_DEBUG		/* Use plot to show readings & processing */
+#undef PLOT_REFRESH 	/* Plot refresh rate measurement info */
+#undef DUMP_SCANV		/* Dump scan readings to a file "i1pdump.txt" */
+#undef DUMP_DARKM		/* Append raw dark readings to file "i1pddump.txt" */
+#undef APPEND_MEAN_EMMIS_VAL /* Append averaged uncalibrated reading to file "i1pdump.txt" */
+#undef TEST_DARK_INTERP    /* Test out the dark interpolation (need DEBUG for plot) */
+#undef PATREC_DEBUG			/* Print & Plot patch/flash recognition information */
+#undef PATREC_ALLBANDS		/* Plot all bands of scan */
+#undef IGNORE_WHITE_INCONS	/* Ignore define reference reading inconsistency */
+#undef HIGH_RES_DEBUG
+#undef HIGH_RES_PLOT
+#undef PLOT_BLACK_SUBTRACT	/* Plot temperature corrected black subtraction */
+#undef FAKE_AMBIENT		/* Fake the ambient mode for a Rev A */
+
+#define MATCH_SPOT_OMD			/* [Def] Match Original Manufacturers Driver. Reduce */
+								/* integration time and lamp turn on time */
+
+#define DISP_INTT 2.0			/* Seconds per reading in display spot mode */
+								/* More improves repeatability in dark colors, but limits */
+								/* the maximum brightness level befor saturation. */
+								/* A value of 2.0 seconds has a limit of about 110 cd/m^2 */
+#define DISP_INTT2 0.8			/* High brightness display spot mode seconds per reading, */
+								/* Should be good up to 275 cd/m^2 */
+#define DISP_INTT3 0.3			/* High brightness display spot mode seconds per reading, */
+								/* Should be good up to 700 cd/m^2 */
+
+#define ADARKINT_MAX 2.0		/* Max cal time for adaptive dark cal */
+#define ADARKINT_MAX2 4.0		/* Max cal time for adaptive dark cal Rev E or no high gain */
+
+#define EMIS_SCALE_FACTOR 1.0	/* Emission mode scale factor */ 
+#define AMB_SCALE_FACTOR (1.0/3.141592654)	/* Ambient mode scale factor - convert */ 
+								/* from Lux to Lux/PI */
+								/* These factors get the same behaviour as the GMB drivers. */
+
+#define NSEN_MAX 140			/* Maximum nsen value we can cope with */
+
+/* High res mode settings */
+#define HIGHRES_SHORT 350
+#define HIGHRES_LONG  740
+#define HIGHRES_WIDTH  (10.0/3.0) /* (The 3.3333 spacing and lanczos2 seems a good combination) */
+#define HIGHRES_REF_MIN 375.0	  /* Too much stray light below this in reflective mode */
+								  /* (i1pro2 could go lower with different correction) */
+
+#include "i1pro.h"
+#include "i1pro_imp.h"
+
+/* - - - - - - - - - - - - - - - - - - */
+#define LAMP_OFF_TIME 1500		/* msec to make sure lamp is dark for dark measurement */
+#define PATCH_CONS_THR 0.1		/* Dark measurement consistency threshold */
+#define TRIG_DELAY 10			/* Measure trigger delay to allow pending read, msec */
+
+/* - - - - - - - - - - - - - - - - - - */
+
+#if defined(DEBUG) || defined(PLOT_DEBUG) || defined(PATREC_DEBUG)
+# include <plot.h>
+#endif
+
+
+#if defined(DEBUG) || defined(PLOT_DEBUG) || defined(HIGH_RES_PLOT) || defined(PATREC_DEBUG)
+static int disdebplot = 0;
+
+#define DISDPLOT disdebplot = 1;
+#define ENDPLOT disdebplot = 0;
+
+#else
+
+#define DISDPLOT 
+#define ENDPLOT 
+	
+#endif	/* DEBUG */
+
+#if defined(DEBUG) || defined(PLOT_DEBUG) || defined(PATREC_DEBUG)
+/* ============================================================ */
+/* Debugging support */
+
+/* Plot a CCD spectra */
+void plot_raw(double *data) {
+	int i;
+	double xx[NSEN_MAX];
+	double yy[NSEN_MAX];
+
+	if (disdebplot)
+		return;
+
+	for (i = 0; i < 128; i++) {
+		xx[i] = (double)i;
+		yy[i] = data[i];
+	}
+	do_plot(xx, yy, NULL, NULL, 128);
+}
+
+/* Plot two CCD spectra */
+void plot_raw2(double *data1, double *data2) {
+	int i;
+	double xx[128];
+	double y1[128];
+	double y2[128];
+
+	if (disdebplot)
+		return;
+
+	for (i = 0; i < 128; i++) {
+		xx[i] = (double)i;
+		y1[i] = data1[i];
+		y2[i] = data2[i];
+	}
+	do_plot(xx, y1, y2, NULL, 128);
+}
+
+/* Plot a converted spectra */
+void plot_wav(i1proimp *m, int hires, double *data) {
+	int i;
+	double xx[128];
+	double yy[128];
+
+	if (disdebplot)
+		return;
+
+	for (i = 0; i < m->nwav[hires]; i++) {
+		xx[i] = XSPECT_WL(m->wl_short[hires], m->wl_long[hires], m->nwav[hires], i);
+		yy[i] = data[i];
+	}
+	do_plot(xx, yy, NULL, NULL, m->nwav[hires]);
+}
+
+/* Plot two converted spectra for the current res. mode */
+void plot_wav_2(i1proimp *m, int hires, double *data1, double *data2) {
+	int i;
+	double xx[128];
+	double y1[128];
+	double y2[128];
+
+	if (disdebplot)
+		return;
+
+	for (i = 0; i < m->nwav[hires]; i++) {
+		xx[i] = XSPECT_WL(m->wl_short[hires], m->wl_long[hires], m->nwav[hires], i);
+		y1[i] = data1[i];
+		y2[i] = data2[i];
+	}
+	do_plot(xx, y1, y2, NULL, m->nwav[hires]);
+}
+
+#endif	/* PLOT_DEBUG */
+
+/* ============================================================ */
+
+/* Implementation struct */
+
+/* Add an implementation structure */
+i1pro_code add_i1proimp(i1pro *p) {
+	i1proimp *m;
+
+	if ((m = (i1proimp *)calloc(1, sizeof(i1proimp))) == NULL) {
+		a1logd(p->log,1,"add_i1proimp malloc %ld bytes failed (1)\n",sizeof(i1proimp));
+		return I1PRO_INT_MALLOC;
+	}
+	m->p = p;
+
+	/* EEProm data store */
+	if ((m->data = new_i1data(m)) == NULL)
+		return I1PRO_INT_CREATE_EEPROM_STORE;
+		
+	m->lo_secs = 2000000000;		/* A very long time */
+	m->msec = msec_time();
+
+	p->m = (void *)m;
+	return I1PRO_OK;
+}
+
+/* Shutdown instrument, and then destroy */
+/* implementation structure */
+void del_i1proimp(i1pro *p) {
+
+	a1logd(p->log,5,"i1pro_del called\n");
+
+#ifdef ENABLE_NONVCAL
+	/* Touch it so that we know when the instrument was last open */
+	i1pro_touch_calibration(p);
+#endif /* ENABLE_NONVCAL */
+
+	if (p->m != NULL) {
+		int i, j;
+		i1proimp *m = (i1proimp *)p->m;
+		i1pro_state *s;
+		i1pro_code ev;
+
+		if (p->itype != instI1Pro2 && (ev = i1pro_update_log(p)) != I1PRO_OK) {
+			a1logd(p->log,2,"i1pro_update_log: Updating the cal and log parameters to"
+			                                              " EEProm failed failed\n");
+		}
+
+		/* i1pro_terminate_switch() seems to fail on a rev A & Rev C ?? */
+		if (m->th != NULL) {		/* Terminate switch monitor thread */
+			m->th_term = 1;			/* Tell thread to exit on error */
+			i1pro_terminate_switch(p);
+			
+			for (i = 0; m->th_termed == 0 && i < 5; i++)
+				msec_sleep(50);		/* Wait for thread to terminate */
+			if (i >= 5) {
+				a1logd(p->log,5,"i1pro switch thread termination failed\n");
+			}
+			m->th->del(m->th);
+			usb_uninit_cancel(&m->cancelt);		/* Don't need cancel token now */
+		}
+		a1logd(p->log,5,"i1pro switch thread terminated\n");
+
+		/* Free any per mode data */
+		for (i = 0; i < i1p_no_modes; i++) {
+			s = &m->ms[i];
+
+			free_dvector(s->dark_data, -1, m->nraw-1);  
+			free_dvector(s->dark_data2, -1, m->nraw-1);  
+			free_dvector(s->dark_data3, -1, m->nraw-1);  
+			free_dvector(s->white_data, -1, m->nraw-1);
+			free_dmatrix(s->idark_data, 0, 3, -1, m->nraw-1);  
+
+			free_dvector(s->cal_factor[0], 0, m->nwav[0]-1);
+			free_dvector(s->cal_factor[1], 0, m->nwav[1]-1);
+		}
+
+		/* Free EEProm key data */
+		if (m->data != NULL)
+			m->data->del(m->data);
+
+		/* Free all Rev E and high res raw2wav filters */
+		for (i = 0; i < 2; i++) {
+			for (j = 0; j < 2; j++) {
+				if (m->mtx_c[i][j].index != NULL)
+					free(m->mtx_c[i][j].index);
+				if (m->mtx_c[i][j].nocoef != NULL)
+					free(m->mtx_c[i][j].nocoef);
+				if (m->mtx_c[i][j].coef != NULL)
+					free(m->mtx_c[i][j].coef);
+			}
+		}
+
+		/* Free RevE straylight arrays */
+		for (i = 0; i < 2; i++) {
+			if (m->straylight[i] != NULL)
+				free_dmatrix(m->straylight[i], 0, m->nwav[i]-1, 0, m->nwav[i]-1);  
+		}
+
+		/* RevA-D high res. recal support */
+		if (m->raw2wav != NULL)
+			m->raw2wav->del(m->raw2wav);
+
+		free(m);
+		p->m = NULL;
+	}
+}
+
+/* ============================================================ */
+/* High level functions */
+
+/* Initialise our software state from the hardware */
+i1pro_code i1pro_imp_init(i1pro *p) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_code ev = I1PRO_OK;
+	unsigned char *eeprom;	/* EEProm contents, i1pro = half, i1pro2 = full */
+	int len = 8192;
+
+	a1logd(p->log,5,"i1pro_init:\n");
+
+	/* Revert to i1pro if i1pro2 driver is not enabled */
+	if (p->itype == instI1Pro2
+#ifdef ENABLE_2
+	 && getenv("ARGYLL_DISABLE_I1PRO2_DRIVER") != NULL	/* Disabled by environment */
+#endif
+	) {
+		p->itype = instI1Pro;
+	}
+
+	if (p->itype != instI1Monitor
+	 && p->itype != instI1Pro
+	 && p->itype != instI1Pro2)
+		return I1PRO_UNKNOWN_MODEL;
+
+	m->trig = inst_opt_trig_user;
+	m->scan_toll_ratio = 1.0;
+
+	/* Take conservative approach to when the light was last on. */
+	/* Assume it might have been on right before init was called again. */
+	m->slamponoff = msec_time();
+	m->llampoffon = msec_time();
+	m->llamponoff = msec_time();
+
+	if ((ev = i1pro_reset(p, 0x1f)) != I1PRO_OK)
+		return ev;
+
+	usb_init_cancel(&m->cancelt);			/* Init cancel token */
+
+#ifdef USE_THREAD
+	/* Setup the switch monitoring thread */
+	if ((m->th = new_athread(i1pro_switch_thread, (void *)p)) == NULL)
+		return I1PRO_INT_THREADFAILED;
+#endif
+
+	/* Get the current misc. status, fwrev etc */
+	if ((ev = i1pro_getmisc(p, &m->fwrev, NULL, &m->maxpve, NULL, &m->powmode)) != I1PRO_OK)
+		return ev; 
+	a1logd(p->log,2,"Firmware rev = %d, max +ve value = 0x%x\n",m->fwrev, m->maxpve);
+
+	if (p->itype == instI1Pro2 && m->fwrev < 600) {		/* Hmm */
+		a1logd(p->log,2, "Strange, firmware isn't up to i1pro2 but has extra pipe..revert to i1pro driver\n",m->fwrev);
+		p->itype = instI1Pro;
+	}
+
+	/* Get the EEProm size */
+	m->eesize = 8192;		/* Rev A..D */
+	if (p->itype == instI1Pro2) {
+#ifdef NEVER
+// ~~99		Hmm. makes it worse. Why ???
+//		/* Make sure LED sequence is finished, because it interferes with EEProm read! */
+//		if ((ev = i1pro2_indLEDoff(p)) != I1PRO_OK)
+//			return ev; 
+#endif
+
+		if ((ev = i1pro2_geteesize(p, &m->eesize)) != I1PRO_OK) {
+			return ev; 
+		}
+
+	}
+	
+	if (m->eesize < 8192) {
+		a1logd(p->log,2,"Strange, EEProm size is < 8192!\n",m->fwrev);
+		return I1PRO_HW_EE_SIZE;
+	}
+	
+	if ((eeprom = (unsigned char *)malloc(m->eesize)) == NULL) {
+		a1logd(p->log,1,"Malloc %d bytes for eeprom failed\n",m->eesize);
+		return I1PRO_INT_MALLOC;
+	}
+
+	/* Read the EEProm */
+	if ((ev = i1pro_readEEProm(p, eeprom, 0, m->eesize)) != I1PRO_OK) {
+		free(eeprom);
+		return ev;
+	}
+
+	if (p->itype == instI1Pro2) {
+		/* Get the Chip ID (This doesn't work until after reading the EEProm !) */
+		if ((ev = i1pro2_getchipid(p, m->chipid)) != I1PRO_OK) {
+			free(eeprom);
+			return ev; 
+		}
+	}
+	
+	/* Parse the i1pro data */
+	if ((ev = m->data->parse_eeprom(m->data, eeprom, m->eesize, 0)) != I1PRO_OK) {
+		free(eeprom);
+		return ev;
+	}
+
+	/* Parse the i1pro2 extra data */
+	if (p->itype == instI1Pro2) {
+		if ((ev = m->data->parse_eeprom(m->data, eeprom, m->eesize, 1)) != I1PRO_OK) {
+			free(eeprom);
+			return ev;
+		}
+	}
+	free(eeprom); eeprom = NULL;
+
+	/* Setup various calibration parameters from the EEprom */
+	{
+		int *ip, i, xcount;
+		unsigned int count;
+		double *dp;
+
+		/* Information about the instrument */
+
+		if ((ip = m->data->get_ints(m->data, &count, key_serno)) == NULL || count < 1)
+			return I1PRO_HW_CALIBINFO;
+		m->serno = ip[0];
+		a1logd(p->log,2,"Serial number = %d\n",m->serno);
+		sprintf(m->sserno,"%ud",m->serno);
+
+		if ((ip = m->data->get_ints(m->data, &count, key_dom)) == NULL || count < 1)
+			return I1PRO_HW_CALIBINFO;
+		m->dom = ip[0];
+		a1logd(p->log,2, "Date of manufactur = %d-%d-%d\n",
+		                          m->dom/1000000, (m->dom/10000) % 100, m->dom % 10000);
+
+		if ((ip = m->data->get_ints(m->data, &count, key_cpldrev)) == NULL || count < 1)
+			return I1PRO_HW_CALIBINFO;
+		m->cpldrev = ip[0];
+		a1logd(p->log,2,"CPLD rev = %d\n",m->cpldrev);
+
+		if ((ip = m->data->get_ints(m->data, &count, key_capabilities)) == NULL || count < 1)
+			return I1PRO_HW_CALIBINFO;
+		m->capabilities = ip[0];
+		if (m->capabilities & 0x6000)		/* Has ambient */
+			m->capabilities2 |= I1PRO_CAP2_AMBIENT;	/* Mimic in capabilities2 */
+		a1logd(p->log,2,"Capabilities flag = 0x%x\n",m->capabilities);
+		if (m->capabilities & 0x6000)
+			a1logd(p->log,2," Can read ambient\n");
+
+		if ((ip = m->data->get_ints(m->data, &count, key_physfilt)) == NULL || count < 1)
+			return I1PRO_HW_CALIBINFO;
+		m->physfilt = ip[0];
+		if (m->physfilt == 0x82)
+			m->capabilities2 |= I1PRO_CAP2_UV_FILT;	/* Mimic in cap 2 */
+		a1logd(p->log,2,"Physical filter flag = 0x%x\n",m->physfilt);
+		if (m->physfilt == 0x80)
+			a1logd(p->log,2," No filter fitted\n");
+		else if (m->physfilt == 0x81)
+			a1logd(p->log,2," Emission only ??\n");
+		else if (m->physfilt == 0x82)
+			a1logd(p->log,2," Is fitted with Ultra Violet Filter\n");
+
+		/* Underlying calibration information */
+
+		m->nsen = 128;
+		m->nraw = 128;
+		if (p->itype == instI1Pro2) {
+			int clkusec, subdiv, xraw, nraw;
+			if ((ev = i1pro2_getmeaschar(p, &clkusec, &xraw, &nraw, &subdiv)) != I1PRO_OK)
+				return ev;
+			m->intclkp2 = clkusec * 1e-6;	/* Rev E integration clock period, ie. 36 usec */
+			m->subclkdiv2 = subdiv;			/* Rev E sub clock divider, ie. 136 */
+
+			m->nsen = nraw + xraw;
+			if (clkusec != 36 || xraw != 6 || nraw != 128 || subdiv != 136)
+				return I1PRO_HW_UNEX_SPECPARMS;
+
+			if (m->nsen > NSEN_MAX)		/* Static allocation assumed */
+				return I1PRO_HW_UNEX_SPECPARMS;
+		}
+		if (m->data->get_ints(m->data, &m->nwav[0], key_mtx_index) == 0)
+			return I1PRO_HW_CALIBINFO;
+		if (m->nwav[0] != 36)
+			return I1PRO_HW_CALIBINFO;
+		m->wl_short[0] = 380.0;		/* Normal res. range */
+		m->wl_long[0] = 730.0;
+
+		/* Fill high res in too */
+		m->wl_short[1] = HIGHRES_SHORT;
+		m->wl_long[1] = HIGHRES_LONG;
+		m->nwav[1] = (int)((m->wl_long[1]-m->wl_short[1])/HIGHRES_WIDTH + 0.5) + 1;	
+
+		if ((dp = m->data->get_doubles(m->data, &count, key_hg_factor)) == NULL || count < 1)
+			return I1PRO_HW_CALIBINFO;
+		m->highgain = dp[0];
+		a1logd(p->log,2,"High gain         = %.10f\n",m->highgain);
+
+		if ((m->lin0 = m->data->get_doubles(m->data, &m->nlin0, key_ng_lin)) == NULL
+		                                                               || m->nlin0 < 1)
+			return I1PRO_HW_CALIBINFO;
+
+		if ((m->lin1 = m->data->get_doubles(m->data, &m->nlin1, key_hg_lin)) == NULL
+		                                                               || m->nlin1 < 1)
+			return I1PRO_HW_CALIBINFO;
+
+		if (p->log->debug >= 2) {
+			char oline[200] = { '\000' }, *bp = oline;
+	
+			bp += sprintf(bp,"Normal non-lin    =");
+			for(i = 0; i < m->nlin0; i++)
+				bp += sprintf(bp," %1.10f",m->lin0[i]);
+			bp += sprintf(bp,"\n");
+			a1logd(p->log,2,oline);
+	
+			bp = oline;
+			bp += sprintf(bp,"High Gain non-lin =");
+			for(i = 0; i < m->nlin1; i++)
+				bp += sprintf(bp," %1.10f",m->lin1[i]);
+			bp += sprintf(bp,"\n");
+			a1logd(p->log,2,oline);
+		}
+
+		if ((dp = m->data->get_doubles(m->data, &count, key_min_int_time)) == NULL || count < 1)
+			return I1PRO_HW_CALIBINFO;
+		m->min_int_time = dp[0];
+
+		/* And then override it */
+		if (p->itype == instI1Pro2) {
+			m->min_int_time = m->subclkdiv2 * m->intclkp2;		/* 0.004896 */
+		} else {
+			if (m->fwrev >= 301)
+				m->min_int_time = 0.004716;
+			else
+				m->min_int_time = 0.00884;		/* == 1 sub clock */
+		}
+
+		if ((dp = m->data->get_doubles(m->data, &count, key_max_int_time)) == NULL || count < 1)
+			return I1PRO_HW_CALIBINFO;
+		m->max_int_time = dp[0];
+
+
+		if ((m->mtx_o.index = m->data->get_ints(m->data, &count, key_mtx_index)) == NULL
+		                                                                   || count != m->nwav[0])
+			return I1PRO_HW_CALIBINFO;
+
+		if ((m->mtx_o.nocoef = m->data->get_ints(m->data, &count, key_mtx_nocoef)) == NULL
+		                                                                   || count != m->nwav[0])
+			return I1PRO_HW_CALIBINFO;
+
+		for (xcount = i = 0; i < m->nwav[0]; i++)	/* Count number expected in matrix coeffs */
+			xcount += m->mtx_o.nocoef[i];
+
+		if ((m->mtx_o.coef = m->data->get_doubles(m->data, &count, key_mtx_coef)) == NULL
+		                                                                    || count != xcount)
+			return I1PRO_HW_CALIBINFO;
+
+		if ((m->white_ref[0] = m->data->get_doubles(m->data, &count, key_white_ref)) == NULL
+		                                                                   || count != m->nwav[0]) {
+			if (p->itype != instI1Monitor)
+				return I1PRO_HW_CALIBINFO;
+			m->white_ref[0] = NULL;
+		}
+
+		if ((m->emis_coef[0] = m->data->get_doubles(m->data, &count, key_emis_coef)) == NULL
+		                                                                   || count != m->nwav[0])
+			return I1PRO_HW_CALIBINFO;
+
+		if ((m->amb_coef[0] = m->data->get_doubles(m->data, &count, key_amb_coef)) == NULL
+		                                                                   || count != m->nwav[0]) {
+			if (p->itype != instI1Monitor
+			 && m->capabilities & 0x6000)		/* Expect ambient calibration */
+				return I1PRO_HW_CALIBINFO;
+			m->amb_coef[0] = NULL;
+		}
+		/* Default to original EEProm raw to wav filters values*/
+		m->mtx[0][0] = m->mtx_o;	/* Std res reflective */
+		m->mtx[0][1] = m->mtx_o;	/* Std res emissive */
+
+		if ((ip = m->data->get_ints(m->data, &count, key_sens_target)) == NULL || count < 1)
+			return I1PRO_HW_CALIBINFO;
+		m->sens_target = ip[0];
+
+		if ((ip = m->data->get_ints(m->data, &count, key_sens_dark)) == NULL || count < 1)
+			return I1PRO_HW_CALIBINFO;
+		m->sens_dark = ip[0];
+
+		if ((ip = m->data->get_ints(m->data, &count, key_ng_sens_sat)) == NULL || count < 1)
+			return I1PRO_HW_CALIBINFO;
+		m->sens_sat0 = ip[0];
+
+		if ((ip = m->data->get_ints(m->data, &count, key_hg_sens_sat)) == NULL || count < 1)
+			return I1PRO_HW_CALIBINFO;
+		m->sens_sat1 = ip[0];
+
+		a1logd(p->log,2,"sens_target %d, sens_dark %d, sens_sat0 %d, sens_sat1 %d\n",
+		                      m->sens_target, m->sens_dark, m->sens_sat0, m->sens_sat1);
+
+		/* Then read the log data. Don't fatal error if there is a problem with this. */
+		for (;;) {
+
+			/* Total Measure (Emis/Remis/Ambient/Trans/Cal) count */
+			if ((ip = m->data->get_ints(m->data, &count, key_meascount)) == NULL || count < 1)
+				break;
+			m->meascount = ip[0];
+
+			/* Remspotcal last calibration date */
+			if ((ip = m->data->get_ints(m->data, &count, key_caldate)) == NULL || count < 1)
+				break;
+			m->caldate = ip[0];
+
+			/* Remission spot measure count at last Remspotcal. */
+			if ((ip = m->data->get_ints(m->data, &count, key_calcount)) == NULL || count < 1)
+				break;
+			m->calcount = ip[0];
+
+			/* Last remision spot reading integration time */
+			if ((dp = m->data->get_doubles(m->data, &count, key_rpinttime)) == NULL || count < 1)
+				break;
+			m->rpinttime = dp[0];
+
+			/* Remission spot measure count */
+			if ((ip = m->data->get_ints(m->data, &count, key_rpcount)) == NULL || count < 1)
+				break;
+			m->rpcount = ip[0];
+
+			/* Remission scan measure count (??) */
+			if ((ip = m->data->get_ints(m->data, &count, key_acount)) == NULL || count < 1)
+				break;
+			m->acount = ip[0];
+
+			/* Total lamp usage time in seconds (??) */
+			if ((dp = m->data->get_doubles(m->data, &count, key_lampage)) == NULL || count < 1)
+				break;
+			m->lampage = dp[0];
+			a1logd(p->log,3,"Read log information OK\n");
+
+			break;
+		}
+	}
+
+	/* Read Rev E specific keys */
+	if (p->itype == instI1Pro2) {
+		int i, j;
+		double *dp;
+		int *sip;
+		unsigned int count;
+		int *ip;
+
+		/* Capability bits */
+		if ((ip = m->data->get_ints(m->data, &count, key2_capabilities)) == NULL
+		                                                                  || count != 1)
+			return I1PRO_HW_CALIBINFO;
+		m->capabilities2 = *ip;
+		if (p->log->debug >= 2) {
+			a1logd(p->log,2,"Capabilities2 flag = 0x%x\n",m->capabilities2);
+			if (m->capabilities2 & I1PRO_CAP2_AMBIENT)
+				a1logd(p->log,2," Can read ambient\n");
+			if (m->capabilities2 & I1PRO_CAP2_WL_LED)
+				a1logd(p->log,2," Has Wavelength Calibration LED\n");
+			if (m->capabilities2 & I1PRO_CAP2_UV_LED)
+				a1logd(p->log,2," Has Ultra Violet LED\n");
+			if (m->capabilities2 & I1PRO_CAP2_ZEB_RUL)
+				a1logd(p->log,2," Has Zebra Ruler sensor\n");
+			if (m->capabilities2 & I1PRO_CAP2_IND_LED)
+				a1logd(p->log,2," Has user indicator LEDs\n");
+			if (m->capabilities2 & I1PRO_CAP2_UV_FILT)
+				a1logd(p->log,2," Is fitted with Ultra Violet Filter\n");
+		}
+
+		if (m->capabilities2 & I1PRO_CAP2_WL_LED) {
+			/* wavelength LED calibration integration time (0.56660) */
+			if ((dp = m->data->get_doubles(m->data, &count, key2_wlcal_intt)) == NULL
+			                                                                  || count != 1)
+				return I1PRO_HW_CALIBINFO;
+			m->wl_cal_inttime = *dp;
+	
+			/* Wavelength calibration minimum level */
+			if ((ip = m->data->get_ints(m->data, &count, key2_wlcal_minlev)) == NULL
+			                                                                  || count != 1)
+				return I1PRO_HW_CALIBINFO;
+			/* Normalize it to 1.0 seconds (ie. 500/0.56660) */
+			m->wl_cal_min_level = (double)(*ip) / m->wl_cal_inttime;
+	
+			/* wavelength LED measurement expected FWHM in nm */
+			if ((dp = m->data->get_doubles(m->data, &count, key2_wlcal_fwhm)) == NULL
+			                                                                  || count != 1)
+				return I1PRO_HW_CALIBINFO;
+			m->wl_cal_fwhm = *dp;
+	
+			/* wavelength LED measurement FWHM tollerance in nm */
+			if ((dp = m->data->get_doubles(m->data, &count, key2_wlcal_fwhm_tol)) == NULL
+			                                                                  || count != 1)
+				return I1PRO_HW_CALIBINFO;
+			m->wl_cal_fwhm_tol = *dp;
+	
+			/* wavelength LED reference spectrum */
+			if ((m->wl_led_spec = m->data->get_doubles(m->data, &m->wl_led_count, key2_wlcal_spec)) == NULL)
+				return I1PRO_HW_CALIBINFO;
+	
+			/* wavelength LED spectraum reference offset */
+			if ((ip = m->data->get_ints(m->data, &count, key2_wlcal_ooff)) == NULL
+			                                                                  || count != 1)
+				return I1PRO_HW_CALIBINFO;
+			m->wl_led_ref_off = *ip;
+			/* Hmm. this is odd, but it doesn't work correctly otherwise... */
+			m->wl_led_ref_off--;
+	
+			/* wavelength calibration maximum error */
+			if ((dp = m->data->get_doubles(m->data, &count, key2_wlcal_max)) == NULL
+			                                                                  || count != 1)
+				return I1PRO_HW_CALIBINFO;
+			m->wl_err_max = *dp;
+		}
+
+		/* CCD bin to wavelength polinomial */
+		if ((m->wlpoly1 = m->data->get_doubles(m->data, &count, key2_wlpoly_1)) == NULL || count != 4)
+			return I1PRO_HW_CALIBINFO;
+
+		if ((m->wlpoly2 = m->data->get_doubles(m->data, &count, key2_wlpoly_2)) == NULL || count != 4)
+			return I1PRO_HW_CALIBINFO;
+
+		/* Stray light compensation. Note that 16 bit numbers are signed. */
+		if ((sip = m->data->get_shorts(m->data, &count, key2_straylight)) == NULL
+		                                                          || count != (36 * 36))
+			return I1PRO_HW_CALIBINFO;
+
+		/* stray light scale factor */
+		if ((dp = m->data->get_doubles(m->data, &count, key2_straylight_scale)) == NULL
+		                                                                  || count != 1)
+			return I1PRO_HW_CALIBINFO;
+
+		/* Convert from ints to floats */
+		m->straylight[0] = dmatrixz(0, 35, 0, 35);  
+		for (i = 0; i < 36; i++) {
+			for (j = 0; j < 36; j++) {
+				m->straylight[0][i][j] = *dp * sip[i * 36 + j]/32767.0;
+				if (i == j)
+					m->straylight[0][i][j] += 1.0;
+			}
+		
+		}
+
+		if (p->log->debug >= 7) {
+			a1logd(p->log,7,"Stray Light matrix:\n");
+			for(i = 0; i < 36; i++) {
+				double sum = 0.0;
+				for (j = 0; j < 36; j++) {
+					sum += m->straylight[0][i][j];
+					a1logd(p->log,7,"  Wt %d = %f\n",j, m->straylight[0][i][j]);
+				}
+				a1logd(p->log,7,"  Sum = %f\n",sum);
+			}
+		}
+
+#ifdef NEVER
+	/* Plot raw2wav polinomials for Rev E */
+	{
+		double *xx;
+		double *y1, *y2;		/* Rev E poly1 and poly2 */
+		double d1, d2;
+		int i, k;
+
+		xx = dvector(0, m->nraw);		/* X index = raw bin */
+		y1 = dvector(0, m->nraw);		/* Y = nm */
+		y2 = dvector(0, m->nraw);		/* Y = nm */
+		
+		d1 = d2 = 0.0;
+		for (i = 0; i < m->nraw; i++) {
+			double iv, v1, v2;
+			xx[i] = i;
+
+			iv = (double)(128-i);
+	
+			for (v1 = m->wlpoly1[4-1], k = 4-2; k >= 0; k--)
+				v1 = v1 * iv + m->wlpoly1[k];
+			y1[i] = v1;
+			d1 += fabs(y2[i] - yy[i]);
+	
+			for (v2 = m->wlpoly2[4-1], k = 4-2; k >= 0; k--)
+				v2 = v2 * iv + m->wlpoly2[k];
+			y2[i] = v2;
+			d2 += fabs(y3[i] - yy[i]);
+
+//			printf("ix %d, poly1 %f, poly2 %f, del12 %f\n",i, y1[i], y2[i], y2[i] - y1[i]);
+		}
+		printf("Avge del of poly1 = %f, poly2 = %f\n",d1/128.0, d2/128.0);
+
+		printf("CCD bin to wavelength mapping of RevE polinomial:\n");
+		do_plot6(xx, y1, y2, NULL, NULL, NULL, NULL, m->nraw);
+		free_dvector(xx, 0, m->nraw);
+		free_dvector(y1, 0, m->nraw);
+		free_dvector(y2, 0, m->nraw);
+	}
+#endif
+
+	}
+
+	/* Set up the current state of each mode */
+	{
+		int i, j;
+		i1pro_state *s;
+
+		/* First set state to basic configuration */
+		/* (We assume it's been zero'd) */
+		for (i = 0; i < i1p_no_modes; i++) {
+			s = &m->ms[i];
+
+			s->mode = i;
+
+			/* Default to an emissive configuration */
+			s->targoscale = 1.0;	/* Default full scale */
+			s->targmaxitime = 2.0; /* Maximum integration time to aim for */
+			s->targoscale2 = 0.15;	 /* Proportion of targoscale to meed etargmaxitime2 (!higain) */
+			s->gainmode = 0;		/* Normal gain mode */
+
+			s->inttime = 0.5;		/* Integration time */
+			s->lamptime = 0.50;		/* Lamp turn on time (up to 1.0 sec is better, */
+
+			s->wl_valid = 0;
+			s->wl_led_off = m->wl_led_ref_off;
+
+			s->dark_valid = 0;		/* Dark cal invalid */
+			s->dark_data = dvectorz(-1, m->nraw-1);  
+			s->dark_data2 = dvectorz(-1, m->nraw-1);  
+			s->dark_data3 = dvectorz(-1, m->nraw-1);  
+
+			s->cal_valid = 0;		/* Scale cal invalid */
+			s->cal_factor[0] = dvectorz(0, m->nwav[0]-1);
+			s->cal_factor[1] = dvectorz(0, m->nwav[1]-1);
+			s->white_data = dvectorz(-1, m->nraw-1);
+
+			s->idark_valid = 0;		/* Dark cal invalid */
+			s->idark_data = dmatrixz(0, 3, -1, m->nraw-1);  
+
+			s->min_wl = 0.0;		/* No minimum by default */
+
+			s->dark_int_time  = DISP_INTT;	/* 2.0 */
+			s->dark_int_time2 = DISP_INTT2;	/* 0.8 */
+			s->dark_int_time3 = DISP_INTT3;	/* 0.3 */
+
+			s->idark_int_time[0] = s->idark_int_time[2] = m->min_int_time;
+			if (p->itype == instI1Pro2) {
+				s->idark_int_time[1] = s->idark_int_time[3] = ADARKINT_MAX2; /* 4.0 */
+			} else {
+#ifdef USE_HIGH_GAIN_MODE
+				s->idark_int_time[1] = s->idark_int_time[3] = ADARKINT_MAX; /* 2.0 */
+#else
+				s->idark_int_time[1] = s->idark_int_time[3] = ADARKINT_MAX2; /* 4.0 */
+#endif
+			}
+
+			s->want_calib = 1;		/* Do an initial calibration */
+			s->want_dcalib = 1;
+		}
+
+		/* Then add mode specific settings */
+		for (i = 0; i < i1p_no_modes; i++) {
+			s = &m->ms[i];
+			switch(i) {
+				case i1p_refl_spot:
+					s->targoscale = 1.0;		/* Optimised sensor scaling to full */
+					s->reflective = 1;
+					s->adaptive = 1;
+					s->inttime = 0.02366;		/* Should get this from the log ?? */ 
+					s->dark_int_time = s->inttime;
+
+					s->dadaptime = 0.10;
+					s->wadaptime = 0.10;
+#ifdef MATCH_SPOT_OMD
+					s->lamptime = 0.18;			/* Lamp turn on time, close to OMD */
+												/* (Not ideal, but partly compensated by calib.) */
+												/* (The actual value the OMD uses is 0.20332) */
+					s->dcaltime = 0.05;			/* Longer than the original driver for lower */
+												/* noise, and lamptime has been reduces to */
+												/* compensate. (OMD uses 0.014552) */
+					s->wcaltime = 0.05;
+					s->dreadtime = 0.05;
+					s->wreadtime = 0.05;
+#else
+					s->lamptime = 0.5;			/* This should give better accuracy, and better */
+					s->dcaltime = 0.5;			/* match the scan readings. Difference is about */
+					s->wcaltime = 0.5;			/* 0.1 DE though, but would be lost in the */
+					s->dreadtime = 0.5;			/* repeatability noise... */
+					s->wreadtime = 0.5;
+#endif
+					s->maxscantime = 0.0;
+					s->min_wl = HIGHRES_REF_MIN;/* Too much stray light below this */
+												/* given low illumination < 375nm */
+					break;
+				case i1p_refl_scan:
+					s->reflective = 1;
+					s->scan = 1;
+					s->adaptive = 1;
+					s->inttime = m->min_int_time;	/* Maximize scan rate */
+					s->dark_int_time = s->inttime;
+					if (m->fwrev >= 301)			/* (We're not using scan targoscale though) */
+						s->targoscale = 0.25;
+					else
+						s->targoscale = 0.5;
+
+					s->lamptime = 0.5;		/* Lamp turn on time - lots to match scan */
+					s->dadaptime = 0.10;
+					s->wadaptime = 0.10;
+					s->dcaltime = 0.5;
+					s->wcaltime = 0.5;
+					s->dreadtime = 0.10;
+					s->wreadtime = 0.10;
+					s->maxscantime = MAXSCANTIME;
+					s->min_wl = HIGHRES_REF_MIN;	/* Too much stray light below this */
+					break;
+
+				case i1p_emiss_spot_na:			/* Emissive spot not adaptive */
+					s->targoscale = 0.90;		/* Allow extra 10% margine for drift */
+					for (j = 0; j < m->nwav[0]; j++)
+						s->cal_factor[0][j] = EMIS_SCALE_FACTOR * m->emis_coef[0][j];
+					s->cal_valid = 1;
+					s->emiss = 1;
+					s->adaptive = 0;
+
+					s->inttime = DISP_INTT;		/* Default disp integration time (ie. 2.0 sec) */
+					s->lamptime = 0.20;			/* ???? */
+					s->dark_int_time = s->inttime;
+					s->dark_int_time2 = DISP_INTT2;	/* Alternate disp integration time (ie. 0.8) */
+					s->dark_int_time3 = DISP_INTT3;	/* Alternate disp integration time (ie. 0.3) */
+
+					s->dadaptime = 0.0;
+					s->wadaptime = 0.10;
+					s->dcaltime = DISP_INTT;		/* ie. determines number of measurements */
+					s->dcaltime2 = DISP_INTT2 * 2;	/* Make it 1.6 seconds (ie, 2 x 0.8 seconds) */
+					s->dcaltime3 = DISP_INTT3 * 3;	/* Make it 0.9 seconds (ie, 3 x 0.3 seconds) */
+					s->wcaltime = 0.0;
+					s->dreadtime = 0.0;
+					s->wreadtime = DISP_INTT;
+					s->maxscantime = 0.0;
+					break;
+				case i1p_emiss_spot:
+					s->targoscale = 0.90;		/* Allow extra 10% margine for drift */
+					for (j = 0; j < m->nwav[0]; j++)
+						s->cal_factor[0][j] = EMIS_SCALE_FACTOR * m->emis_coef[0][j];
+					s->cal_valid = 1;
+					s->emiss = 1;
+					s->adaptive = 1;
+
+					s->lamptime = 0.20;			/* ???? */
+					s->dadaptime = 0.0;
+					s->wadaptime = 0.10;
+					s->dcaltime = 1.0;
+					s->wcaltime = 0.0;
+					s->dreadtime = 0.0;
+					s->wreadtime = 1.0;
+					s->maxscantime = 0.0;
+					break;
+				case i1p_emiss_scan:
+					for (j = 0; j < m->nwav[0]; j++)
+						s->cal_factor[0][j] = EMIS_SCALE_FACTOR * m->emis_coef[0][j];
+					s->cal_valid = 1;
+					s->emiss = 1;
+					s->scan = 1;
+					s->adaptive = 1;			/* ???? */
+					s->inttime = m->min_int_time;	/* Maximize scan rate */
+					s->lamptime = 0.20;			/* ???? */
+					s->dark_int_time = s->inttime;
+					if (m->fwrev >= 301)
+						s->targoscale = 0.25;		/* (We're not using scan targoscale though) */
+					else
+						s->targoscale = 0.5;
+
+					s->dadaptime = 0.0;
+					s->wadaptime = 0.10;
+					s->dcaltime = 1.0;
+					s->wcaltime = 0.0;
+					s->dreadtime = 0.0;
+					s->wreadtime = 0.10;
+					s->maxscantime = MAXSCANTIME;
+					break;
+
+				case i1p_amb_spot:
+#ifdef FAKE_AMBIENT
+					for (j = 0; j < m->nwav[0]; j++)
+						s->cal_factor[0][j] = EMIS_SCALE_FACTOR * m->emis_coef[0][j];
+					s->cal_valid = 1;
+#else
+					if (m->amb_coef[0] != NULL) {
+						for (j = 0; j < m->nwav[0]; j++)
+							s->cal_factor[0][j] = AMB_SCALE_FACTOR * m->emis_coef[0][j] * m->amb_coef[0][j];
+						s->cal_valid = 1;
+					}
+#endif
+					s->emiss = 1;
+					s->ambient = 1;
+					s->adaptive = 1;
+
+					s->lamptime = 0.20;			/* ???? */
+					s->dadaptime = 0.0;
+					s->wadaptime = 0.10;
+					s->dcaltime = 1.0;
+					s->wcaltime = 0.0;
+					s->dreadtime = 0.0;
+					s->wreadtime = 1.0;
+					s->maxscantime = 0.0;
+					break;
+				case i1p_amb_flash:
+				/* This is intended for measuring flashes */
+#ifdef FAKE_AMBIENT
+					for (j = 0; j < m->nwav[0]; j++)
+						s->cal_factor[0][j] = EMIS_SCALE_FACTOR * m->emis_coef[0][j];
+					s->cal_valid = 1;
+#else
+					if (m->amb_coef[0] != NULL) {
+						for (j = 0; j < m->nwav[0]; j++)
+							s->cal_factor[0][j] = AMB_SCALE_FACTOR * m->emis_coef[0][j] * m->amb_coef[0][j];
+						s->cal_valid = 1;
+					}
+#endif
+					s->emiss = 1;
+					s->ambient = 1;
+					s->scan = 1;
+					s->adaptive = 0;
+					s->flash = 1;
+
+					s->inttime = m->min_int_time;	/* Maximize scan rate */
+					s->lamptime = 0.20;			/* ???? */
+					s->dark_int_time = s->inttime;
+					if (m->fwrev >= 301)
+						s->targoscale = 0.25;		/* (We're not using scan targoscale though) */
+					else
+						s->targoscale = 0.5;
+
+					s->dadaptime = 0.0;
+					s->wadaptime = 0.10;
+					s->dcaltime = 1.0;
+					s->wcaltime = 0.0;
+					s->dreadtime = 0.0;
+					s->wreadtime = 0.12;
+					s->maxscantime = MAXSCANTIME;
+					break;
+
+				case i1p_trans_spot:
+					s->trans = 1;
+					s->adaptive = 1;
+
+					s->lamptime = 0.20;			/* ???? */
+					s->dadaptime = 0.10;
+					s->wadaptime = 0.10;
+					s->dcaltime = 1.0;
+					s->wcaltime = 1.0;
+					s->dreadtime = 0.0;
+					s->wreadtime = 1.0;
+					s->maxscantime = 0.0;
+					s->min_wl = HIGHRES_REF_MIN;	/* Too much stray light below this */
+					break;
+				case i1p_trans_scan:
+					s->trans = 1;
+					s->scan = 1;
+					s->adaptive = 0;
+					s->inttime = m->min_int_time;	/* Maximize scan rate */
+					s->dark_int_time = s->inttime;
+					if (m->fwrev >= 301)			/* (We're not using scan targoscale though) */
+						s->targoscale = 0.25;
+					else
+						s->targoscale = 0.5;
+
+					s->lamptime = 0.20;			/* ???? */
+					s->dadaptime = 0.10;
+					s->wadaptime = 0.10;
+					s->dcaltime = 1.0;
+					s->wcaltime = 1.0;
+					s->dreadtime = 0.00;
+					s->wreadtime = 0.10;
+					s->maxscantime = MAXSCANTIME;
+					s->min_wl = HIGHRES_REF_MIN;	/* Too much stray light below this */
+					break;
+			}
+		}
+	}
+
+	if (p->itype != instI1Monitor		/* Monitor doesn't have reflective cal */
+	 && p->itype != instI1Pro2) {		/* Rev E mode has different calibration */
+		/* Restore the previous reflective spot calibration from the EEProm */
+		/* Get ready to operate the instrument */
+		if ((ev = i1pro_restore_refspot_cal(p)) != I1PRO_OK)
+			return ev; 
+	}
+
+#ifdef ENABLE_NONVCAL
+	/* Restore the all modes calibration from the local system */
+	i1pro_restore_calibration(p);
+	/* Touch it so that we know when the instrument was last opened */
+	i1pro_touch_calibration(p);
+#endif
+	
+	/* Get ready to operate the instrument */
+	if ((ev = i1pro_establish_high_power(p)) != I1PRO_OK)
+		return ev; 
+
+	/* Get the current measurement parameters (why ?) */
+	if ((ev = i1pro_getmeasparams(p, &m->r_intclocks, &m->r_lampclocks, &m->r_nummeas, &m->r_measmodeflags)) != I1PRO_OK)
+		return ev; 
+
+	if (p->log->verb >= 1) {
+		a1logv(p->log,1,"Instrument Type:   %s\n",inst_name(p->itype));
+		a1logv(p->log,1,"Serial Number:     %d\n",m->serno);
+		a1logv(p->log,1,"Firmware version:  %d\n",m->fwrev);
+		a1logv(p->log,1,"CPLD version:      %d\n",m->cpldrev);
+		if (p->itype == instI1Pro2)
+			a1logv(p->log,1,"Chip ID:           %02x-%02x%02x%02x%02x%02x%02x%02x\n",
+			                           m->chipid[0], m->chipid[1], m->chipid[2], m->chipid[3],
+			                           m->chipid[4], m->chipid[5], m->chipid[6], m->chipid[7]);
+		a1logv(p->log,1,"Date manufactured: %d-%d-%d\n",
+		                                 m->dom/1000000, (m->dom/10000) % 100, m->dom % 10000);
+		// Hmm. physfilt == 0x81 for instI1Monitor ???
+		a1logv(p->log,1,"U.V. filter ?:     %s\n",m->physfilt == 0x82 ? "Yes" : "No");
+		a1logv(p->log,1,"Measure Ambient ?: %s\n",m->capabilities & 0x6000 ? "Yes" : "No");
+
+		a1logv(p->log,1,"Tot. Measurement Count:           %d\n",m->meascount);
+		a1logv(p->log,1,"Remission Spot Count:             %d\n",m->rpcount);
+		a1logv(p->log,1,"Remission Scan Count:             %d\n",m->acount);
+		a1logv(p->log,1,"Date of last Remission spot cal:  %s",ctime(&m->caldate));
+		a1logv(p->log,1,"Remission Spot Count at last cal: %d\n",m->calcount);
+		a1logv(p->log,1,"Total lamp usage:                 %f\n",m->lampage);
+	}
+
+#ifdef NEVER
+// ~~99 play with LED settings
+	if (p->itype == instI1Pro2) {
+
+		/* Makes it white */
+		unsigned char b2[] = {
+			0x00, 0x00, 0x00, 0x02,
+
+			0x00, 0x00, 0x00, 0x0a,
+			0x00, 0x00, 0x00, 0x01,
+			0x00, 0x36, 0x00,
+			0x00, 0x00, 0x01,
+
+			0x00, 0x00, 0x00, 0x0a,
+			0xff, 0xff, 0xff, 0xff,
+			0x3f, 0x36, 0x40,
+			0x00, 0x00, 0x01
+		};
+
+		printf("~1 send led sequence length %d\n",sizeof(b2));
+		if ((ev = i1pro2_indLEDseq(p, b2, sizeof(b2))) != I1PRO_OK)
+			return ev;
+	}
+	/* Make sure LED sequence is finished, because it interferes with EEProm read! */
+	if ((ev = i1pro2_indLEDoff(p)) != I1PRO_OK)
+		return ev; 
+#endif
+
+	return ev;
+}
+
+/* Return a pointer to the serial number */
+char *i1pro_imp_get_serial_no(i1pro *p) {
+	i1proimp *m = (i1proimp *)p->m;
+
+	return m->sserno; 
+}
+
+/* Return non-zero if capable of ambient mode */
+int i1pro_imp_ambient(i1pro *p) {
+
+	if (p->inited) {
+		i1proimp *m = (i1proimp *)p->m;
+		if (m->capabilities & 0x6000)		/* Expect ambient calibration */
+			return 1;
+#ifdef FAKE_AMBIENT
+		return 1;
+#endif
+		return 0;
+
+	} else {
+		return 0;
+	}
+}
+
+/* Set the measurement mode. It may need calibrating */
+i1pro_code i1pro_imp_set_mode(
+	i1pro *p,
+	i1p_mode mmode,		/* Operating mode */
+	inst_mode mode		/* Full mode mask for options */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+
+	a1logd(p->log,2,"i1pro_imp_set_mode called with %d\n",mmode);
+	switch(mmode) {
+		case i1p_refl_spot:
+		case i1p_refl_scan:
+			if (p->itype == instI1Monitor)
+				return I1PRO_INT_ILLEGALMODE;		/* i1Monitor */
+			/* Fall through */
+		case i1p_emiss_spot_na:
+		case i1p_emiss_spot:
+		case i1p_emiss_scan:
+		case i1p_amb_spot:
+		case i1p_amb_flash:
+		case i1p_trans_spot:
+		case i1p_trans_scan:
+			m->mmode = mmode;
+			break;
+		default:
+			return I1PRO_INT_ILLEGALMODE;
+	}
+	m->spec_en = (mode & inst_mode_spectral) != 0;
+	m->uv_en = 0;
+
+	if (mmode == i1p_refl_spot
+	 || mmode == i1p_refl_scan)
+		m->uv_en = (mode & inst_mode_ref_uv) != 0;
+
+	return I1PRO_OK;
+}
+
+/* Return needed and available inst_cal_type's */
+i1pro_code i1pro_imp_get_n_a_cals(i1pro *p, inst_cal_type *pn_cals, inst_cal_type *pa_cals) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *cs = &m->ms[m->mmode];
+	time_t curtime = time(NULL);
+	inst_cal_type n_cals = inst_calt_none;
+	inst_cal_type a_cals = inst_calt_none;
+
+	a1logd(p->log,2,"i1pro_imp_get_n_a_cals: checking mode %d\n",m->mmode);
+
+	/* Timout calibrations that are too old */
+	if (m->capabilities2 & I1PRO_CAP2_WL_LED) {
+		if ((curtime - cs->wldate) > WLCALTOUT) {
+			a1logd(p->log,2,"Invalidating wavelength cal as %d secs from last cal\n",curtime - cs->wldate);
+			cs->wl_valid = 0;
+		}
+	}
+	if ((curtime - cs->iddate) > ((p->itype == instI1Pro) ? DCALTOUT2 : DCALTOUT)) {
+		a1logd(p->log,2,"Invalidating adaptive dark cal as %d secs from last cal\n",curtime - cs->iddate);
+		cs->idark_valid = 0;
+	}
+	if ((curtime - cs->ddate) > ((p->itype == instI1Pro) ? DCALTOUT2 : DCALTOUT)) {
+		a1logd(p->log,2,"Invalidating dark cal as %d secs from last cal\n",curtime - cs->ddate);
+		cs->dark_valid = 0;
+	}
+	if (!cs->emiss && (curtime - cs->cfdate) > WCALTOUT) {
+		a1logd(p->log,2,"Invalidating white cal as %d secs from last cal\n",curtime - cs->cfdate);
+		cs->cal_valid = 0;
+	}
+
+#ifdef NEVER
+	printf("~1 reflective = %d, adaptive = %d, emiss = %d, trans = %d, scan = %d\n",
+	cs->reflective, cs->adaptive, cs->emiss, cs->trans, cs->scan);
+	printf("~1 idark_valid = %d, dark_valid = %d, cal_valid = %d\n",
+	cs->idark_valid,cs->dark_valid,cs->cal_valid); 
+	printf("~1 want_calib = %d, want_dcalib = %d, noinitcalib = %d\n",
+	cs->want_calib,cs->want_dcalib, m->noinitcalib); 
+#endif /* NEVER */
+
+	if (m->capabilities2 & I1PRO_CAP2_WL_LED) {
+		if (!cs->wl_valid
+		 || (cs->want_dcalib && !m->noinitcalib))	// ?? want_dcalib ??
+			n_cals |= inst_calt_wavelength;
+		a_cals |= inst_calt_wavelength;
+	}
+	if (cs->reflective) {
+		if (!cs->dark_valid
+		 || (cs->want_dcalib && !m->noinitcalib))
+			n_cals |= inst_calt_ref_dark;
+		a_cals |= inst_calt_ref_dark;
+
+		if (!cs->cal_valid
+		 || (cs->want_calib && !m->noinitcalib))
+			n_cals |= inst_calt_ref_white;
+		a_cals |= inst_calt_ref_white;
+	}
+	if (cs->emiss) {
+		if ((!cs->adaptive && !cs->dark_valid)
+		 || (cs->adaptive && !cs->idark_valid)
+		 || (cs->want_dcalib && !m->noinitcalib))
+			n_cals |= inst_calt_em_dark;
+		a_cals |= inst_calt_em_dark;
+	}
+	if (cs->trans) {
+		if ((!cs->adaptive && !cs->dark_valid)
+		 || (cs->adaptive && !cs->idark_valid)
+	     || (cs->want_dcalib && !m->noinitcalib))
+			n_cals |= inst_calt_trans_dark;
+		a_cals |= inst_calt_trans_dark;
+
+		if (!cs->cal_valid
+	     || (cs->want_calib && !m->noinitcalib))
+			n_cals |= inst_calt_trans_vwhite;
+		a_cals |= inst_calt_trans_vwhite;
+	}
+	if (cs->emiss && !cs->adaptive && !cs->scan) {
+		if (!cs->done_dintsel)
+			n_cals |= inst_calt_emis_int_time;
+		a_cals |= inst_calt_emis_int_time;
+	}
+
+	if (pn_cals != NULL)
+		*pn_cals = n_cals;
+
+	if (pa_cals != NULL)
+		*pa_cals = a_cals;
+
+	a1logd(p->log,3,"i1pro_imp_get_n_a_cals: returning n_cals 0x%x, a_cals 0x%x\n",n_cals, a_cals);
+
+	return I1PRO_OK;
+}
+
+/* - - - - - - - - - - - - - - - - */
+/* Calibrate for the current mode. */
+/* Request an instrument calibration of the current mode. */
+i1pro_code i1pro_imp_calibrate(
+	i1pro *p,
+	inst_cal_type *calt,	/* Calibration type to do/remaining */
+	inst_cal_cond *calc,	/* Current condition/desired condition */
+	char id[CALIDLEN]		/* Condition identifier (ie. white reference ID) */
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	int mmode = m->mmode;
+	i1pro_state *cs = &m->ms[m->mmode];
+	int sx1, sx2, sx;
+	time_t cdate = time(NULL);
+	int nummeas = 0;
+	int ltocmode = 0;			/* 1 = Lamp turn on compensation mode */
+	int i, k;
+    inst_cal_type needed, available;
+
+	a1logd(p->log,2,"i1pro_imp_calibrate called with calt 0x%x, calc 0x%x\n",*calt, *calc);
+
+	if ((ev = i1pro_imp_get_n_a_cals(p, &needed, &available)) != I1PRO_OK)
+		return ev;
+
+	/* Translate inst_calt_all/needed into something specific */
+	if (*calt == inst_calt_all
+	 || *calt == inst_calt_needed
+	 || *calt == inst_calt_available) {
+		if (*calt == inst_calt_all) 
+			*calt = (needed & inst_calt_n_dfrble_mask) | inst_calt_ap_flag;
+		else if (*calt == inst_calt_needed)
+			*calt = needed & inst_calt_n_dfrble_mask;
+		else if (*calt == inst_calt_available)
+			*calt = available & inst_calt_n_dfrble_mask;
+
+		a1logd(p->log,4,"i1pro_imp_calibrate: doing calt 0x%x\n",calt);
+
+		if ((*calt & inst_calt_n_dfrble_mask) == 0)		/* Nothing todo */
+			return I1PRO_OK;
+	}
+
+	/* See if it's a calibration we understand */
+	if (*calt & ~available & inst_calt_all_mask) { 
+		return I1PRO_UNSUPPORTED;
+	}
+
+	if (*calt & inst_calt_ap_flag) {
+		sx1 = 0; sx2 = i1p_no_modes;		/* Go through all the modes */
+	} else {
+		sx1 = m->mmode; sx2 = sx1 + 1;		/* Just current mode */
+	}
+
+	/* Go through the modes we are going to cover */
+	for (sx = sx1; sx < sx2; sx++) {
+		i1pro_state *s = &m->ms[sx];
+		m->mmode = sx;				/* A lot of functions we call rely on this */
+
+		a1logd(p->log,2,"\nCalibrating mode %d\n", s->mode);
+
+		/* Sanity check scan mode settings, in case something strange */
+		/* has been restored from the persistence file. */
+		if (s->scan && s->inttime > (2.1 * m->min_int_time)) {
+			s->inttime = m->min_int_time;	/* Maximize scan rate */
+		}
+	
+		/* Wavelength calibration: */
+		if ((m->capabilities2 & I1PRO_CAP2_WL_LED)
+		 && (*calt & (inst_calt_wavelength | inst_calt_ap_flag))
+		 && (*calc == inst_calc_man_ref_white
+		  || *calc == inst_calc_man_am_dark)) {
+			double *wlraw;
+			double optscale;
+			double *abswav;
+
+			a1logd(p->log,2,"\nDoing wavelength calibration\n");
+
+			wlraw = dvectorz(-1, m->nraw-1);
+
+			if ((ev = i1pro2_wl_measure(p, wlraw, &optscale, &m->wl_cal_inttime, 1.0)) != I1PRO_OK) {
+				a1logd(p->log,2,"i1pro2_wl_measure() failed\n");
+				return ev;
+			}
+
+			/* Find the best fit of the measured values to the reference spectrum */
+			if ((ev = i1pro2_match_wl_meas(p, &cs->wl_led_off, wlraw)) != I1PRO_OK) {
+				a1logd(p->log,2,"i1pro2_match_wl_meas() failed\n");
+				return ev;
+			}
+
+			free_dvector(wlraw, -1, m->nraw-1);
+
+			/* Compute normal res. reflective wavelength corrected filters */
+			if ((ev = i1pro2_compute_wav_filters(p, 1)) != I1PRO_OK) {
+				a1logd(p->log,2,"i1pro2_compute_wav_filters() failed\n");
+				return ev;
+			}
+
+			/* Compute normal res. emissive/transmissive wavelength corrected filters */
+			if ((ev = i1pro2_compute_wav_filters(p, 0)) != I1PRO_OK) {
+				a1logd(p->log,2,"i1pro2_compute_wav_filters() failed\n");
+				return ev;
+			}
+
+			/* Re-compute high res. wavelength corrected filters */
+			if (m->hr_inited && (ev = i1pro_create_hr(p)) != I1PRO_OK) {
+				a1logd(p->log,2,"i1pro_create_hr() failed\n");
+				return ev;
+			}
+
+			cs->wl_valid = 1;
+			cs->wldate = cdate;
+			*calt &= ~inst_calt_wavelength;
+
+			/* Save the calib to all modes */
+			a1logd(p->log,5,"Saving wavelength calib to similar modes\n");
+			for (i = 0; i < i1p_no_modes; i++) {
+				i1pro_state *ss = &m->ms[i];
+				if (ss == cs)
+					continue;
+				ss->wl_valid = cs->wl_valid;
+				ss->wldate = cs->wldate;
+				ss->wl_led_off = cs->wl_led_off;
+			}
+		}
+
+		/* Fixed int. time black calibration: */
+		/* Reflective uses on the fly black, even for adaptive. */
+		/* Emiss and trans can use single black ref only for non-adaptive */
+		/* using the current inttime & gainmode, while display mode */
+		/* does an extra fallback black cal for bright displays. */
+		if ((*calt & (inst_calt_ref_dark
+		            | inst_calt_em_dark
+		            | inst_calt_trans_dark | inst_calt_ap_flag))
+		 && (*calc == inst_calc_man_ref_white		/* Any condition conducive to dark calib */
+		  || *calc == inst_calc_man_em_dark
+		  || *calc == inst_calc_man_am_dark
+		  || *calc == inst_calc_man_trans_dark)
+		 && ( s->reflective
+		  || (s->emiss && !s->adaptive && !s->scan)
+		  || (s->trans && !s->adaptive))) {
+			int stm;
+			int usesdct23 = 0;			/* Is a mode that uses dcaltime2 & 3 */
+
+			if (s->emiss && !s->adaptive && !s->scan)
+				usesdct23 = 1;
+	
+			nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->inttime);
+	
+			a1logd(p->log,2,"\nDoing initial black calibration with dcaltime %f, int_time %f, nummeas %d, gainmode %d\n", s->dcaltime, s->inttime, nummeas, s->gainmode);
+			stm = msec_time();
+			if ((ev = i1pro_dark_measure(p, s->dark_data,
+				                               nummeas, &s->inttime, s->gainmode)) != I1PRO_OK) {
+				m->mmode = mmode;			/* Restore actual mode */
+				return ev;
+			}
+			a1logd(p->log,2,"Execution time of dark calib time %f sec = %d msec\n",s->inttime,msec_time() - stm);
+	
+			/* Special display mode alternate integration time black measurement */
+			if (usesdct23) {
+				nummeas = i1pro_comp_nummeas(p, s->dcaltime2, s->dark_int_time2);
+				a1logd(p->log,2,"Doing 2nd initial black calibration with dcaltime2 %f, dark_int_time2 %f, nummeas %d, gainmode %d\n", s->dcaltime2, s->dark_int_time2, nummeas, s->gainmode);
+				stm = msec_time();
+				if ((ev = i1pro_dark_measure(p, s->dark_data2,
+					                       nummeas, &s->dark_int_time2, s->gainmode)) != I1PRO_OK) {
+					m->mmode = mmode;			/* Restore actual mode */
+					return ev;
+				}
+				a1logd(p->log,2,"Execution time of 2nd dark calib time %f sec = %d msec\n",s->inttime,msec_time() - stm);
+	
+				nummeas = i1pro_comp_nummeas(p, s->dcaltime3, s->dark_int_time3);
+				a1logd(p->log,2,"Doing 3rd initial black calibration with dcaltime3 %f, dark_int_time3 %f, nummeas %d, gainmode %d\n", s->dcaltime3, s->dark_int_time3, nummeas, s->gainmode);
+				nummeas = i1pro_comp_nummeas(p, s->dcaltime3, s->dark_int_time3);
+				stm = msec_time();
+				if ((ev = i1pro_dark_measure(p, s->dark_data3,
+					                       nummeas, &s->dark_int_time3, s->gainmode)) != I1PRO_OK) {
+					m->mmode = mmode;			/* Restore actual mode */
+					return ev;
+				}
+				a1logd(p->log,2,"Execution time of 3rd dark calib time %f sec = %d msec\n",s->inttime,msec_time() - stm);
+			}
+			s->dark_valid = 1;
+			s->want_dcalib = 0;
+			s->ddate = cdate;
+			s->dark_int_time = s->inttime;
+			s->dark_gain_mode = s->gainmode;
+			*calt &= ~(inst_calt_ref_dark
+		             | inst_calt_em_dark
+		             | inst_calt_trans_dark);
+
+			/* Save the calib to all similar modes */
+			for (i = 0; i < i1p_no_modes; i++) {
+				i1pro_state *ss = &m->ms[i];
+				if (ss == s || ss->ddate == cdate)
+					continue;
+				if (( s->reflective
+				  || (ss->emiss && !ss->adaptive && !ss->scan)
+				  || (ss->trans && !ss->adaptive))
+				 && ss->dark_int_time == s->dark_int_time
+				 && ss->dark_gain_mode == s->dark_gain_mode) {
+
+					ss->dark_valid = s->dark_valid;
+					ss->want_dcalib = s->want_dcalib;
+					ss->ddate = s->ddate;
+					ss->dark_int_time = s->dark_int_time;
+					ss->dark_gain_mode = s->dark_gain_mode;
+					for (k = -1; k < m->nraw; k++)
+						ss->dark_data[k] = s->dark_data[k];
+					/* If this is a mode with dark_data2/3, tranfer it too */
+					if (usesdct23 && ss->emiss && !ss->adaptive && !ss->scan) {
+						ss->dark_int_time2 = s->dark_int_time2;
+						ss->dark_int_time3 = s->dark_int_time2;
+						for (k = -1; k < m->nraw; k++) {
+							ss->dark_data2[k] = s->dark_data2[k];
+							ss->dark_data3[k] = s->dark_data3[k];
+						}
+					}
+				}
+			}
+		}
+	
+		/* Emissive scan black calibration: */
+		/* Emsissive scan (flash) uses the fastest possible scan rate (??) */
+		if ((*calt & (inst_calt_em_dark | inst_calt_ap_flag))
+		 && (*calc == inst_calc_man_ref_white		/* Any condition conducive to dark calib */
+		  || *calc == inst_calc_man_em_dark
+		  || *calc == inst_calc_man_am_dark
+		  || *calc == inst_calc_man_trans_dark)
+		 && (s->emiss && !s->adaptive && s->scan)) {
+			int stm;
+	
+			nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->inttime);
+	
+			a1logd(p->log,2,"\nDoing emissive (flash) black calibration with dcaltime %f, int_time %f, nummeas %d, gainmode %d\n", s->dcaltime, s->inttime, nummeas, s->gainmode);
+			stm = msec_time();
+			if ((ev = i1pro_dark_measure(p, s->dark_data,
+				                                 nummeas, &s->inttime, s->gainmode)) != I1PRO_OK) {
+				m->mmode = mmode;			/* Restore actual mode */
+				return ev;
+			}
+			a1logd(p->log,2,"Execution time of dark calib time %f sec = %d msec\n",s->inttime,msec_time() - stm);
+	
+			s->dark_valid = 1;
+			s->want_dcalib = 0;
+			s->ddate = cdate;
+			s->dark_int_time = s->inttime;
+			s->dark_gain_mode = s->gainmode;
+			*calt &= ~inst_calt_em_dark;
+	
+			/* Save the calib to all similar modes */
+			/* We're assuming they have the same int times */
+			a1logd(p->log,5,"Saving emissive scan black calib to similar modes\n");
+			for (i = 0; i < i1p_no_modes; i++) {
+				i1pro_state *ss = &m->ms[i];
+				if (ss == s || ss->ddate == s->ddate)
+					continue;
+				if (ss->emiss && !ss->adaptive && ss->scan) {
+					ss->dark_valid = s->dark_valid;
+					ss->want_dcalib = s->want_dcalib;
+					ss->ddate = s->ddate;
+					ss->dark_int_time = s->dark_int_time;
+					ss->dark_gain_mode = s->dark_gain_mode;
+					for (k = -1; k < m->nraw; k++)
+						ss->dark_data[k] = s->dark_data[k];
+				}
+			}
+		}
+	
+		/* Adaptive black calibration: */
+		/* Deal with an emmissive/transmissive black reference */
+		/* in non-scan mode, where the integration time and gain may vary. */
+		/* The black is interpolated from readings with two extreme integration times */
+		if ((*calt & (inst_calt_ref_dark
+		            | inst_calt_em_dark
+		            | inst_calt_trans_dark | inst_calt_ap_flag))
+		 && (*calc == inst_calc_man_ref_white		/* Any condition conducive to dark calib */
+		  || *calc == inst_calc_man_em_dark
+		  || *calc == inst_calc_man_am_dark
+		  || *calc == inst_calc_man_trans_dark)
+		 && ((s->emiss && s->adaptive && !s->scan)
+		  || (s->trans && s->adaptive && !s->scan))) {
+			int i, j, k;
+	
+			a1logd(p->log,2,"\nDoing emis/trans adapative black calibration\n");
+
+			/* Adaptive where we can't measure the black reference on the fly, */
+			/* so bracket it and interpolate. */
+			/* The black reference is probably temperature dependent, but */
+			/* there's not much we can do about this. */
+	
+			nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->idark_int_time[0]);
+			a1logd(p->log,2,"\nDoing adaptive interpolated black calibration, dcaltime %f, idark_int_time[0] %f, nummeas %d, gainmode %d\n", s->dcaltime, s->idark_int_time[0], nummeas, 0);
+			if ((ev = i1pro_dark_measure(p, s->idark_data[0],
+				                          nummeas, &s->idark_int_time[0], 0)) != I1PRO_OK) {
+				m->mmode = mmode;			/* Restore actual mode */
+				return ev;
+			}
+		
+			nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->idark_int_time[1]);
+			a1logd(p->log,2,"Doing adaptive interpolated black calibration, dcaltime %f, idark_int_time[1] %f, nummeas %d, gainmode %d\n", s->dcaltime, s->idark_int_time[1], nummeas, 0);
+			if ((ev = i1pro_dark_measure(p, s->idark_data[1],
+				                          nummeas, &s->idark_int_time[1], 0)) != I1PRO_OK) {
+				m->mmode = mmode;			/* Restore actual mode */
+				return ev;
+			}
+		
+#ifdef USE_HIGH_GAIN_MODE
+			if (p->itype != instI1Pro2) {	/* Rev E doesn't have high gain mode */
+				nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->idark_int_time[2]);
+				a1logd(p->log,2,"Doing adaptive interpolated black calibration, dcaltime %f, idark_int_time[2] %f, nummeas %d, gainmode %d\n", s->dcaltime, s->idark_int_time[2], nummeas, 1);
+				if ((ev = i1pro_dark_measure(p, s->idark_data[2],
+					                       nummeas, &s->idark_int_time[2], 1)) != I1PRO_OK) {
+					m->mmode = mmode;			/* Restore actual mode */
+					return ev;
+				}
+			
+				a1logd(p->log,2,"Doing adaptive interpolated black calibration, dcaltime %f, idark_int_time[3] %f, nummeas %d, gainmode %d\n", s->dcaltime, s->idark_int_time[3], nummeas, 1);
+				nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->idark_int_time[3]);
+				if ((ev = i1pro_dark_measure(p, s->idark_data[3],
+					                        nummeas, &s->idark_int_time[3], 1)) != I1PRO_OK) {
+					m->mmode = mmode;			/* Restore actual mode */
+					return ev;
+				}
+			}
+#endif /* USE_HIGH_GAIN_MODE */
+		
+			i1pro_prepare_idark(p);
+			s->idark_valid = 1;
+			s->iddate = cdate;
+		
+			if ((ev = i1pro_interp_dark(p, s->dark_data, s->inttime, s->gainmode)) != I1PRO_OK) {
+				m->mmode = mmode;			/* Restore actual mode */
+				return ev;
+			}
+			s->dark_valid = 1;
+			s->want_dcalib = 0;
+			s->ddate = s->iddate;
+			s->dark_int_time = s->inttime;
+			s->dark_gain_mode = s->gainmode;
+			*calt &= ~(inst_calt_ref_dark
+		            | inst_calt_em_dark
+		            | inst_calt_trans_dark);
+	
+			/* Save the calib to all similar modes */
+			/* We're assuming they have the same int times */
+			a1logd(p->log,5,"Saving adaptive black calib to similar modes\n");
+			for (i = 0; i < i1p_no_modes; i++) {
+				i1pro_state *ss = &m->ms[i];
+				if (ss == s || ss->iddate == s->iddate)
+					continue;
+				if ((ss->emiss || ss->trans) && ss->adaptive && !ss->scan) {
+					ss->idark_valid = s->idark_valid;
+					ss->want_dcalib = s->want_dcalib;
+					ss->iddate = s->iddate;
+					ss->dark_int_time = s->dark_int_time;
+					ss->dark_gain_mode = s->dark_gain_mode;
+#ifdef USE_HIGH_GAIN_MODE
+					for (j = 0; j < (p->itype != instI1Pro2) ? 4 : 2; j++)
+#else
+					for (j = 0; j < 2; j++)
+#endif
+					{
+						ss->idark_int_time[j] = s->idark_int_time[j];
+						for (k = -1; k < m->nraw; k++)
+							ss->idark_data[j][k] = s->idark_data[j][k];
+					}
+				}
+			}
+	
+			a1logd(p->log,5,"Done adaptive interpolated black calibration\n");
+	
+			/* Test accuracy of dark level interpolation */
+#ifdef TEST_DARK_INTERP
+			{
+				double tinttime;
+				double ref[128], interp[128];
+				
+	//			fprintf(stderr,"Normal gain offsets:\n");
+	//			plot_raw(s->idark_data[0]);
+	//			fprintf(stderr,"Normal gain multiplier:\n");
+	//			plot_raw(s->idark_data[1]);
+				
+#ifdef DUMP_DARKM
+				extern int ddumpdarkm;
+				ddumpdarkm = 1;
+#endif
+				for (tinttime = m->min_int_time; ; tinttime *= 2.0) {
+					if (tinttime >= m->max_int_time)
+						tinttime = m->max_int_time;
+					nummeas = i1pro_comp_nummeas(p, s->dcaltime, tinttime);
+					if ((ev = i1pro_dark_measure(p, ref, nummeas, &tinttime, 0)) != I1PRO_OK) {
+						m->mmode = mmode;			/* Restore actual mode */
+						return ev;
+					}
+					i1pro_interp_dark(p, interp, tinttime, 0);
+#ifdef DEBUG
+					fprintf(stderr,"Low gain ref vs. interp dark offset for inttime %f:\n",tinttime);
+					plot_raw2(ref, interp);
+#endif
+					if ((tinttime * 1.1) > m->max_int_time)
+						break;
+				}
+#ifdef DUMP_DARKM
+				ddumpdarkm = 0;
+#endif
+				
+#ifdef USE_HIGH_GAIN_MODE
+				if (p->itype != instI1Pro2) {	/* Rev E doesn't have high gain mode */
+	//				fprintf(stderr,"High gain offsets:\n");
+	//				plot_raw(s->idark_data[2]);
+	//				fprintf(stderr,"High gain multiplier:\n");
+	//				plot_raw(s->idark_data[3]);
+				
+					for (tinttime = m->min_int_time; ; tinttime *= 2.0) {
+						if (tinttime >= m->max_int_time)
+							tinttime = m->max_int_time;
+						nummeas = i1pro_comp_nummeas(p, s->dcaltime, tinttime);
+						if ((ev = i1pro_dark_measure(p, ref, nummeas, &tinttime, 1)) != I1PRO_OK) {
+							m->mmode = mmode;			/* Restore actual mode */
+							return ev;
+						}
+						i1pro_interp_dark(p, interp, tinttime, 1);
+#ifdef DEBUG
+						fprintf(stderr,"High gain ref vs. interp dark offset for inttime %f:\n",tinttime);
+						plot_raw2(ref, interp);
+#endif
+						if ((tinttime * 1.1) > m->max_int_time)
+							break;
+					}
+				}
+#endif /* USE_HIGH_GAIN_MODE */
+			}
+#endif	/* NEVER */
+	
+		}
+	
+		/* Deal with an emissive/transmisive adaptive black reference */
+		/* when in scan mode. */
+		if ((*calt & (inst_calt_ref_dark
+		            | inst_calt_em_dark
+		            | inst_calt_trans_dark | inst_calt_ap_flag))
+		 && (*calc == inst_calc_man_ref_white		/* Any condition conducive to dark calib */
+		  || *calc == inst_calc_man_em_dark
+		  || *calc == inst_calc_man_am_dark
+		  || *calc == inst_calc_man_trans_dark)
+		 && ((s->emiss && s->adaptive && s->scan)
+		  || (s->trans && s->adaptive && s->scan))) {
+			int j;
+
+			a1logd(p->log,2,"\nDoing emis/trans adapative scan mode black calibration\n");
+
+			/* We know scan is locked to the minimum integration time, */
+			/* so we can measure the dark data at that integration time, */
+			/* but we don't know what gain mode will be used, so measure both, */
+			/* and choose the appropriate one on the fly. */
+	
+			s->idark_int_time[0] = s->inttime;
+			nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->idark_int_time[0]);
+			a1logd(p->log,2,"\nDoing adaptive scan black calibration, dcaltime %f, idark_int_time[0] %f, nummeas %d, gainmode %d\n", s->dcaltime, s->idark_int_time[0], nummeas, s->gainmode);
+			if ((ev = i1pro_dark_measure(p, s->idark_data[0],
+				                                  nummeas, &s->idark_int_time[0], 0)) != I1PRO_OK) {
+				m->mmode = mmode;			/* Restore actual mode */
+				return ev;
+			}
+		
+#ifdef USE_HIGH_GAIN_MODE
+			if (p->itype != instI1Pro2) {	/* Rev E doesn't have high gain mode */
+				s->idark_int_time[2] = s->inttime;
+				nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->idark_int_time[2]);
+				a1logd(p->log,2,"Doing adaptive scan black calibration, dcaltime %f, idark_int_time[2] %f, nummeas %d, gainmode %d\n", s->dcaltime, s->idark_int_time[2], nummeas, s->gainmode);
+				if ((ev = i1pro_dark_measure(p, s->idark_data[2],
+					                           nummeas, &s->idark_int_time[2], 1)) != I1PRO_OK) {
+					m->mmode = mmode;			/* Restore actual mode */
+					return ev;
+				}
+			}
+#endif
+		
+			s->idark_valid = 1;
+			s->iddate = cdate;
+	
+#ifdef USE_HIGH_GAIN_MODE
+		   	if (s->gainmode) {
+				for (j = -1; j < m->nraw; j++)
+					s->dark_data[j] = s->idark_data[2][j];
+			} else
+#endif
+			{
+				for (j = -1; j < m->nraw; j++)
+					s->dark_data[j] = s->idark_data[0][j];
+			}
+			s->dark_valid = 1;
+			s->want_dcalib = 0;
+			s->ddate = s->iddate;
+			s->dark_int_time = s->inttime;
+			s->dark_gain_mode = s->gainmode;
+			*calt &= ~(inst_calt_ref_dark
+		            | inst_calt_em_dark
+		            | inst_calt_trans_dark);
+	
+			a1logd(p->log,2,"Done adaptive scan black calibration\n");
+	
+			/* Save the calib to all similar modes */
+			/* We're assuming they have the same int times */
+			a1logd(p->log,5,"Saving adaptive scan black calib to similar modes\n");
+			for (i = 0; i < i1p_no_modes; i++) {
+				i1pro_state *ss = &m->ms[i];
+				if (ss == s || ss->iddate == s->iddate)
+					continue;
+				if ((ss->emiss || ss->trans) && ss->adaptive && s->scan) {
+					ss->idark_valid = s->idark_valid;
+					ss->want_dcalib = s->want_dcalib;
+					ss->iddate = s->iddate;
+					ss->dark_int_time = s->dark_int_time;
+					ss->dark_gain_mode = s->dark_gain_mode;
+#ifdef USE_HIGH_GAIN_MODE
+					for (j = 0; j < (p->itype != instI1Pro2) ? 4 : 2; j += 2)
+#else
+					for (j = 0; j < 2; j += 2)
+#endif
+					{
+						ss->idark_int_time[j] = s->idark_int_time[j];
+						for (k = -1; k < m->nraw; k++)
+							ss->idark_data[j][k] = s->idark_data[j][k];
+					}
+				}
+			}
+		}
+	
+		/* If we are doing a white reference calibrate */
+		if ((*calt & (inst_calt_ref_white
+		            | inst_calt_trans_vwhite | inst_calt_ap_flag))
+		 && ((*calc == inst_calc_man_ref_white && s->reflective)
+		  || (*calc == inst_calc_man_trans_white && s->trans))) {
+			double scale;
+	
+			a1logd(p->log,2,"\nDoing initial white calibration with current inttime %f, gainmode %d\n",
+			                                                               s->inttime, s->gainmode);
+			nummeas = i1pro_comp_nummeas(p, s->wcaltime, s->inttime);
+			ev = i1pro_whitemeasure(p, s->cal_factor[0], s->cal_factor[1], s->white_data, &scale, nummeas,
+			           &s->inttime, s->gainmode, s->scan ? 1.0 : s->targoscale, 0);
+			if (ev == I1PRO_RD_SENSORSATURATED) {
+				scale = 0.0;			/* Signal it this way */
+				ev = I1PRO_OK;
+			}
+			if (ev != I1PRO_OK) {
+				m->mmode = mmode;			/* Restore actual mode */
+				return ev;
+			}
+	
+			/* For non-scan modes, we adjust the integration time to avoid saturation, */
+			/* and to try and match the target optimal sensor value */
+			if (!s->scan) {
+				/* If it's adaptive and not good, or if it's not adaptive and even worse, */
+				/* or if we're using lamp dynamic compensation for reflective scan, */
+				/* change the parameters until the white is optimal. */
+				if ((s->adaptive && (scale < 0.95 || scale > 1.05))
+				 || (scale < 0.3 || scale > 2.0)) {
+			
+					/* Need to have done adaptive black measure to change inttime/gain params */
+					if (*calc != inst_calc_man_ref_white && !s->idark_valid) {
+						m->mmode = mmode;			/* Restore actual mode */
+						return I1PRO_RD_TRANSWHITERANGE;
+					}
+	
+					if (scale == 0.0) {		/* If sensor was saturated */
+						s->inttime = m->min_int_time;
+						s->gainmode = 0;
+						s->dark_valid = 0;
+						if (!s->emiss)
+							s->cal_valid = 0;
+	
+						if (*calc == inst_calc_man_ref_white) {
+							nummeas = i1pro_comp_nummeas(p, s->dadaptime, s->inttime);
+							a1logd(p->log,2,"Doing another black calibration with dadaptime %f, min inttime %f, nummeas %d, gainmode %d\n", s->dadaptime, s->inttime, nummeas, s->gainmode);
+							if ((ev = i1pro_dark_measure(p, s->dark_data,
+								             nummeas, &s->inttime, s->gainmode)) != I1PRO_OK) {
+								m->mmode = mmode;			/* Restore actual mode */
+								return ev;
+							}
+	
+						} else if (s->idark_valid) {
+							/* compute interpolated dark refence for chosen inttime & gainmode */
+							a1logd(p->log,2,"Interpolate dark calibration reference\n");
+							if ((ev = i1pro_interp_dark(p, s->dark_data,
+								                       s->inttime, s->gainmode)) != I1PRO_OK) {
+								m->mmode = mmode;			/* Restore actual mode */
+								return ev;
+							}
+							s->dark_valid = 1;
+							s->ddate = s->iddate;
+							s->dark_int_time = s->inttime;
+							s->dark_gain_mode = s->gainmode;
+						} else {
+							m->mmode = mmode;			/* Restore actual mode */
+							return I1PRO_INT_NOINTERPDARK;
+						}
+						a1logd(p->log,2,"Doing another white calibration with min inttime %f, gainmode %d\n",
+						                                                  s->inttime,s->gainmode);
+						nummeas = i1pro_comp_nummeas(p, s->wadaptime, s->inttime);
+						if ((ev = i1pro_whitemeasure(p, s->cal_factor[0], s->cal_factor[1], s->white_data,
+						   &scale, nummeas, &s->inttime, s->gainmode, s->targoscale, 0))
+							                                                != I1PRO_OK) {
+							m->mmode = mmode;			/* Restore actual mode */
+							return ev;
+						}
+					}
+	
+					/* Compute a new integration time and gain mode */
+					/* in order to optimise the sensor values. Error if can't get */
+					/* scale we want. */
+					if ((ev = i1pro_optimise_sensor(p, &s->inttime, &s->gainmode, 
+					         s->inttime, s->gainmode, s->trans, 0, s->targoscale, scale)) != I1PRO_OK) {
+						m->mmode = mmode;			/* Restore actual mode */
+						return ev;
+					}
+					a1logd(p->log,2,"Computed optimal white inttime %f and gainmode %d\n",
+					                                                      s->inttime,s->gainmode);
+				
+					if (*calc == inst_calc_man_ref_white) {
+						nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->inttime);
+						a1logd(p->log,2,"Doing final black calibration with dcaltime %f, opt inttime %f, nummeas %d, gainmode %d\n", s->dcaltime, s->inttime, nummeas, s->gainmode);
+						if ((ev = i1pro_dark_measure(p, s->dark_data,
+								                   nummeas, &s->inttime, s->gainmode)) != I1PRO_OK) {
+							m->mmode = mmode;			/* Restore actual mode */
+							return ev;
+						}
+						s->dark_valid = 1;
+						s->ddate = cdate;
+						s->dark_int_time = s->inttime;
+						s->dark_gain_mode = s->gainmode;
+	
+					} else if (s->idark_valid) {
+						/* compute interpolated dark refence for chosen inttime & gainmode */
+						a1logd(p->log,2,"Interpolate dark calibration reference\n");
+						if ((ev = i1pro_interp_dark(p, s->dark_data,
+							                             s->inttime, s->gainmode)) != I1PRO_OK) {
+							m->mmode = mmode;			/* Restore actual mode */
+							return ev;
+						}
+						s->dark_valid = 1;
+						s->ddate = s->iddate;
+						s->dark_int_time = s->inttime;
+						s->dark_gain_mode = s->gainmode;
+					} else {
+						m->mmode = mmode;			/* Restore actual mode */
+						return I1PRO_INT_NOINTERPDARK;
+					}
+				
+					a1logd(p->log,2,"Doing final white calibration with opt int_time %f, gainmode %d\n",
+					                                                 s->inttime,s->gainmode);
+					nummeas = i1pro_comp_nummeas(p, s->wcaltime, s->inttime);
+					if ((ev = i1pro_whitemeasure(p, s->cal_factor[0], s->cal_factor[1], s->white_data,
+					  &scale, nummeas, &s->inttime, s->gainmode, s->targoscale, ltocmode)) != I1PRO_OK) {
+						m->mmode = mmode;			/* Restore actual mode */
+						return ev;
+					}
+				}
+	
+			/* For scan we take a different approach. We try and use the minimum possible */
+			/* integration time so as to maximize sampling rate, and adjust the gain */
+			/* if necessary. */
+			} else if (s->adaptive) {
+				int j;
+				if (scale == 0.0) {		/* If sensor was saturated */
+					a1logd(p->log,3,"Scan illuminant is saturating sensor\n");
+					if (s->gainmode == 0) {
+						m->mmode = mmode;			/* Restore actual mode */
+						return I1PRO_RD_SENSORSATURATED;		/* Nothing we can do */
+					}
+					a1logd(p->log,3,"Switching to low gain mode\n");
+					s->gainmode = 0;
+					/* Measure white again with low gain */
+					nummeas = i1pro_comp_nummeas(p, s->wcaltime, s->inttime);
+					if ((ev = i1pro_whitemeasure(p, s->cal_factor[0], s->cal_factor[1], s->white_data,
+					   &scale, nummeas, &s->inttime, s->gainmode, 1.0, 0)) != I1PRO_OK) {
+						m->mmode = mmode;			/* Restore actual mode */
+						return ev;
+					}
+				} else if (p->itype != instI1Pro2 && s->gainmode == 0 && scale > m->highgain) {
+#ifdef USE_HIGH_GAIN_MODE
+					a1logd(p->log,3,"Scan signal is so low we're switching to high gain mode\n");
+					s->gainmode = 1;
+					/* Measure white again with high gain */
+					nummeas = i1pro_comp_nummeas(p, s->wcaltime, s->inttime);
+					if ((ev = i1pro_whitemeasure(p, s->cal_factor[0], s->cal_factor[1], s->white_data,
+					   &scale, nummeas, &s->inttime, s->gainmode, 1.0, 0)) != I1PRO_OK) {
+						m->mmode = mmode;			/* Restore actual mode */
+						return ev;
+					}
+#endif /* USE_HIGH_GAIN_MODE */
+				}
+	
+				a1logd(p->log,2,"After scan gain adaption scale = %f\n",scale);
+				if (scale > 6.0) {
+					m->transwarn |= 2;
+					a1logd(p->log,2, "scan white reference is not bright enough by %f\n",scale);
+				}
+	
+				if (*calc == inst_calc_man_ref_white) {
+					nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->inttime);
+					a1logd(p->log,2,"Doing final black calibration with dcaltime %f, opt inttime %f, nummeas %d, gainmode %d\n", s->dcaltime, s->inttime, nummeas, s->gainmode);
+					if ((ev = i1pro_dark_measure(p, s->dark_data,
+						              nummeas, &s->inttime, s->gainmode)) != I1PRO_OK) {
+						m->mmode = mmode;			/* Restore actual mode */
+						return ev;
+					}
+					s->dark_valid = 1;
+					s->ddate = cdate;
+					s->dark_int_time = s->inttime;
+					s->dark_gain_mode = s->gainmode;
+	
+				} else if (s->idark_valid) {
+					/* compute interpolated dark refence for chosen inttime & gainmode */
+					a1logd(p->log,2,"Interpolate dark calibration reference\n");
+					if (s->gainmode) {
+						for (j = -1; j < m->nraw; j++)
+							s->dark_data[j] = s->idark_data[2][j];
+					} else {
+						for (j = -1; j < m->nraw; j++)
+							s->dark_data[j] = s->idark_data[0][j];
+					}
+					s->dark_valid = 1;
+					s->ddate = s->iddate;
+					s->dark_int_time = s->inttime;
+					s->dark_gain_mode = s->gainmode;
+				} else {
+					m->mmode = mmode;			/* Restore actual mode */
+					return I1PRO_INT_NOINTERPDARK;
+				}
+				a1logd(p->log,2,"Doing final white calibration with opt int_time %f, gainmode %d\n",
+				                                                 s->inttime,s->gainmode);
+			}
+	
+			/* We've settled on the inttime and gain mode to get a good white reference. */
+			if (s->reflective) {	/* We read the white reference - check it */
+				/* Check a reflective white measurement, and check that */
+				/* it seems reasonable. Return I1PRO_OK if it is, error if not. */
+				/* (Using cal_factor[] as temp.) */
+				a1logd(p->log,2,"Checking white reference\n");
+				if ((ev = i1pro_check_white_reference1(p, s->cal_factor[0])) != I1PRO_OK) {
+					m->mmode = mmode;			/* Restore actual mode */
+					return ev;
+				}
+				/* Compute a calibration factor given the reading of the white reference. */
+				i1pro_compute_white_cal(p, s->cal_factor[0], m->white_ref[0], s->cal_factor[0],
+				                           s->cal_factor[1], m->white_ref[1], s->cal_factor[1]);
+	
+			} else {
+				/* Compute a calibration factor given the reading of the white reference. */
+				m->transwarn |= i1pro_compute_white_cal(p, s->cal_factor[0], NULL, s->cal_factor[0],
+				                                       s->cal_factor[1], NULL, s->cal_factor[1]);
+			}
+			s->cal_valid = 1;
+			s->cfdate = cdate;
+			s->want_calib = 0;
+			*calt &= ~(inst_calt_ref_white
+			         | inst_calt_trans_vwhite);
+		}
+	
+		/* Deal with a display integration time selection */
+		if ((*calt & (inst_calt_emis_int_time | inst_calt_ap_flag))
+		 && *calc == inst_calc_emis_white
+		 && (s->emiss && !s->adaptive && !s->scan)) {
+			double scale;
+			double *data;
+			double *tt, tv;
+	
+			data = dvectorz(-1, m->nraw-1);
+	
+			a1logd(p->log,2,"\nDoing display integration time calibration\n");
+	
+			/* Undo any previous swaps */
+			if (s->dispswap == 1) {
+				tv = s->inttime; s->inttime = s->dark_int_time2; s->dark_int_time2 = tv;
+				tt = s->dark_data; s->dark_data = s->dark_data2; s->dark_data2 = tt;
+			} else if (s->dispswap == 2) {
+				tv = s->inttime; s->inttime = s->dark_int_time3; s->dark_int_time3 = tv;
+				tt = s->dark_data; s->dark_data = s->dark_data3; s->dark_data3 = tt;
+			}
+			s->dispswap = 0;
+
+			/* Simply measure the full display white, and if it's close to */
+			/* saturation, switch to the alternate display integration time */
+			nummeas = i1pro_comp_nummeas(p, s->wreadtime, s->inttime);
+			ev = i1pro_whitemeasure(p, NULL, NULL, data , &scale, nummeas,
+			           &s->inttime, s->gainmode, s->targoscale, 0);
+			/* Switch to the alternate if things are too bright */
+			/* We do this simply by swapping the alternate values in. */
+			if (ev == I1PRO_RD_SENSORSATURATED || scale < 1.0) {
+				a1logd(p->log,2,"Switching to alternate display integration time %f seconds\n",s->dark_int_time2);
+				tv = s->inttime; s->inttime = s->dark_int_time2; s->dark_int_time2 = tv;
+				tt = s->dark_data; s->dark_data = s->dark_data2; s->dark_data2 = tt;
+				s->dispswap = 1;
+	
+				/* Do another measurement of the full display white, and if it's close to */
+				/* saturation, switch to the 3rd alternate display integration time */
+				nummeas = i1pro_comp_nummeas(p, s->wreadtime, s->inttime);
+				ev = i1pro_whitemeasure(p, NULL, NULL, data , &scale, nummeas,
+				           &s->inttime, s->gainmode, s->targoscale, 0);
+				/* Switch to the 3rd alternate if things are too bright */
+				/* We do this simply by swapping the alternate values in. */
+				if (ev == I1PRO_RD_SENSORSATURATED || scale < 1.0) {
+					a1logd(p->log,2,"Switching to 3rd alternate display integration time %f seconds\n",s->dark_int_time3);
+					/* Undo previous swap */
+					tv = s->inttime; s->inttime = s->dark_int_time2; s->dark_int_time2 = tv;
+					tt = s->dark_data; s->dark_data = s->dark_data2; s->dark_data2 = tt;
+					/* swap in 2nd alternate */
+					tv = s->inttime; s->inttime = s->dark_int_time3; s->dark_int_time3 = tv;
+					tt = s->dark_data; s->dark_data = s->dark_data3; s->dark_data3 = tt;
+					s->dispswap = 2;
+				}
+			}
+			free_dvector(data, -1, m->nraw-1);
+			if (ev != I1PRO_OK) {
+				m->mmode = mmode;			/* Restore actual mode */
+				return ev;
+			}
+			s->done_dintsel = 1;
+			s->diseldate = cdate;
+			*calt &= ~inst_calt_emis_int_time;
+	
+			a1logd(p->log,5,"Done display integration time calibration\n");
+		}
+
+	}	/* Look at next mode */
+	m->mmode = mmode;			/* Restore actual mode */
+
+	/* Make sure there's the right condition for any remaining calibrations */
+	if (*calt & inst_calt_wavelength) {		/* Wavelength calibration */
+		if (cs->emiss && cs->ambient) {
+			id[0] = '\000';
+			if (*calc != inst_calc_man_am_dark) {
+				*calc = inst_calc_man_am_dark;	/* Calibrate using ambient adapter */
+				return I1PRO_CAL_SETUP;
+			}
+		} else {
+			sprintf(id, "Serial no. %d",m->serno);
+			if (*calc != inst_calc_man_ref_white) {
+				*calc = inst_calc_man_ref_white;	/* Calibrate using white tile */
+				return I1PRO_CAL_SETUP;
+			}
+		}
+	} else if (*calt & (inst_calt_ref_dark | inst_calt_ref_white)) {
+		sprintf(id, "Serial no. %d",m->serno);
+		if (*calc != inst_calc_man_ref_white) {
+			*calc = inst_calc_man_ref_white;	/* Calibrate using white tile */
+			return I1PRO_CAL_SETUP;
+		}
+	} else if (*calt & inst_calt_em_dark) {		/* Emissive Dark calib */
+		id[0] = '\000';
+		if (*calc != inst_calc_man_em_dark) {
+			*calc = inst_calc_man_em_dark;		/* Any sort of dark reference */
+			return I1PRO_CAL_SETUP;
+		}
+	} else if (*calt & inst_calt_trans_dark) {	/* Transmissvice dark */
+		id[0] = '\000';
+		if (*calc != inst_calc_man_trans_dark) {
+			*calc = inst_calc_man_trans_dark;
+			return I1PRO_CAL_SETUP;
+		}
+	} else if (*calt & inst_calt_trans_vwhite) {/* Transmissvice white for emulated transmission */
+		id[0] = '\000';
+		if (*calc != inst_calc_man_trans_white) {
+			*calc = inst_calc_man_trans_white;
+			return I1PRO_CAL_SETUP;
+		}
+	} else if (*calt & inst_calt_emis_int_time) {
+		id[0] = '\000';
+		if (*calc != inst_calc_emis_white) {
+			*calc = inst_calc_emis_white;
+			return I1PRO_CAL_SETUP;
+		}
+	}
+
+	/* Go around again if we've still got calibrations to do */
+	if (*calt & inst_calt_all_mask) {
+		return I1PRO_CAL_SETUP;
+	}
+
+	/* We must be done */
+
+	/* Update and write the EEProm log if the is a refspot calibration */
+	if (cs->reflective && !cs->scan && cs->dark_valid && cs->cal_valid) {
+		m->calcount = m->rpcount;
+		m->caldate = cdate;
+		if ((ev = i1pro_update_log(p)) != I1PRO_OK) {
+			a1logd(p->log,2,"i1pro_update_log: Updating the cal and log parameters"
+			                                               " to EEProm failed\n");
+		}
+	}
+	
+#ifdef ENABLE_NONVCAL
+	/* Save the calibration to a file */
+	i1pro_save_calibration(p);
+#endif
+
+	if (m->transwarn) {
+		*calc = inst_calc_message;
+		if (m->transwarn & 2)
+			strcpy(id, "Warning: Transmission light source is too low for accuracy!");
+		else
+			strcpy(id, "Warning: Transmission light source is low at some wavelengths!");
+		m->transwarn = 0;
+	}
+
+	a1logd(p->log,2,"Finished cal with dark_valid = %d, cal_valid = %d\n",cs->dark_valid, cs->cal_valid);
+
+	return I1PRO_OK; 
+}
+
+/* Interpret an icoms error into a I1PRO error */
+int icoms2i1pro_err(int se) {
+	if (se != ICOM_OK)
+		return I1PRO_COMS_FAIL;
+	return I1PRO_OK;
+}
+
+/* - - - - - - - - - - - - - - - - */
+/* Measure a patch or strip in the current mode. */
+/* To try and speed up the reaction time between */
+/* triggering a scan measurement and being able to */
+/* start moving the instrument, we pre-allocate */
+/* all the buffers and arrays, and pospone processing */
+/* until after the scan is complete. */
+i1pro_code i1pro_imp_measure(
+	i1pro *p,
+	ipatch *vals,		/* Pointer to array of instrument patch value */
+	int nvals,			/* Number of values */	
+	instClamping clamp	/* Clamp XYZ/Lab to be +ve */
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	unsigned char *buf = NULL;	/* Raw USB reading buffer for reflection dark cal */
+	unsigned int bsize;
+	unsigned char *mbuf = NULL;	/* Raw USB reading buffer for measurement */
+	unsigned int mbsize;
+	int nummeas = 0, maxnummeas = 0;
+	int nmeasuered = 0;			/* Number actually measured */
+	double **specrd = NULL;		/* Cooked spectral patch values */
+	double duration = 0.0;		/* Possible flash duration value */
+	int user_trig = 0;
+
+	a1logd(p->log,2,"i1pro_imp_measure: Taking %d measurments in %s%s%s%s%s%s mode called\n", nvals,
+		        s->emiss ? "Emission" : s->trans ? "Trans" : "Refl", 
+		        s->emiss && s->ambient ? " Ambient" : "",
+		        s->scan ? " Scan" : "",
+		        s->flash ? " Flash" : "",
+		        s->adaptive ? " Adaptive" : "",
+		        m->uv_en ? " UV" : "");
+
+
+	if ((s->emiss && s->adaptive && !s->idark_valid)
+	 || ((!s->emiss || !s->adaptive) && !s->dark_valid)
+	 || !s->cal_valid) {
+		a1logd(p->log,3,"emis %d, adaptive %d, idark_valid %d\n",s->emiss,s->adaptive,s->idark_valid);
+		a1logd(p->log,3,"dark_valid %d, cal_valid %d\n",s->dark_valid,s->cal_valid);
+		a1logd(p->log,3,"i1pro_imp_measure need calibration\n");
+		return I1PRO_RD_NEEDS_CAL;
+	}
+		
+	if (nvals <= 0
+	 || (!s->scan && nvals > 1)) {
+		a1logd(p->log,2,"i1pro_imp_measure wrong number of patches\n");
+		return I1PRO_INT_WRONGPATCHES;
+	}
+
+	/* Notional number of measurements, befor adaptive and not counting scan */
+	nummeas = i1pro_comp_nummeas(p, s->wreadtime, s->inttime);
+
+	/* Allocate buf for pre-measurement dark calibration */
+	if (s->reflective) {
+		bsize = m->nsen * 2 * nummeas;
+		if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+			a1logd(p->log,1,"i1pro_imp_measure malloc %d bytes failed (5)\n",bsize);
+			return I1PRO_INT_MALLOC;
+		}
+	}
+
+	/* Allocate buffer for measurement */
+	maxnummeas = i1pro_comp_nummeas(p, s->maxscantime, s->inttime);
+	if (maxnummeas < nummeas)
+		maxnummeas = nummeas;
+	mbsize = m->nsen * 2 * maxnummeas;
+	if ((mbuf = (unsigned char *)malloc(sizeof(unsigned char) * mbsize)) == NULL) {
+		if (buf != NULL)
+			free(buf);
+		a1logd(p->log,1,"i1pro_imp_measure malloc %d bytes failed (6)\n",mbsize);
+		return I1PRO_INT_MALLOC;
+	}
+	specrd = dmatrix(0, nvals-1, 0, m->nwav[m->highres]-1);
+
+	if (m->trig == inst_opt_trig_user_switch) {
+		m->hide_switch = 1;						/* Supress switch events */
+
+#ifdef USE_THREAD
+		{
+			int currcount = m->switch_count;		/* Variable set by thread */
+			while (currcount == m->switch_count) {
+				inst_code rc;
+				int cerr;
+
+				/* Don't trigger on user key if scan, only trigger */
+				/* on instrument switch */
+				if (p->uicallback != NULL
+				 && (rc = p->uicallback(p->uic_cntx, inst_armed)) != inst_ok) {
+					if (rc == inst_user_abort) {
+						ev = I1PRO_USER_ABORT;
+						break;						/* Abort */
+					}
+					if (!s->scan && rc == inst_user_trig) {
+						ev = I1PRO_USER_TRIG;
+						user_trig = 1;
+						break;						/* Trigger */
+					}
+				}
+				msec_sleep(100);
+			}
+		}
+#else
+		/* Throw one away in case the switch was pressed prematurely */
+		i1pro_waitfor_switch_th(p, 0.01);
+
+		for (;;) {
+			inst_code rc;
+			int cerr;
+
+			if ((ev = i1pro_waitfor_switch_th(p, 0.1)) != I1PRO_OK
+			 && ev != I1PRO_INT_BUTTONTIMEOUT)
+				break;			/* Error */
+
+			if (ev == I1PRO_OK)
+				break;			/* switch triggered */
+
+			/* Don't trigger on user key if scan, only trigger */
+			/* on instrument switch */
+			if (p->uicallback != NULL
+			 && (rc = p->uicallback(p->uic_cntx, inst_armed)) != inst_ok) {
+				if (rc == inst_user_abort) {
+					ev = I1PRO_USER_ABORT;
+					break;						/* Abort */
+				}
+				if (!s->scan && rc == inst_user_trig) {
+					ev = I1PRO_USER_TRIG;
+					user_trig = 1;
+					break;						/* Trigger */
+				}
+			}
+		}
+#endif
+		a1logd(p->log,3,"############# triggered ##############\n");
+		if (p->uicallback)	/* Notify of trigger */
+			p->uicallback(p->uic_cntx, inst_triggered); 
+
+		m->hide_switch = 0;						/* Enable switch events again */
+
+	} else if (m->trig == inst_opt_trig_user) {
+		if (p->uicallback == NULL) {
+			a1logd(p->log, 1, "hcfr: inst_opt_trig_user but no uicallback function set!\n");
+			ev = I1PRO_UNSUPPORTED;
+
+		} else {
+
+			for (;;) {
+				inst_code rc;
+				if ((rc = p->uicallback(p->uic_cntx, inst_armed)) != inst_ok) {
+					if (rc == inst_user_abort) {
+						ev = I1PRO_USER_ABORT;	/* Abort */
+						break;
+					}
+					if (rc == inst_user_trig) {
+						ev = I1PRO_USER_TRIG;
+						user_trig = 1;
+						break;						/* Trigger */
+					}
+				}
+				msec_sleep(200);
+			}
+		}
+		a1logd(p->log,3,"############# triggered ##############\n");
+		if (p->uicallback)	/* Notify of trigger */
+			p->uicallback(p->uic_cntx, inst_triggered); 
+
+	/* Progromatic Trigger */
+	} else {
+		/* Check for abort */
+		if (p->uicallback != NULL
+		 && (ev = p->uicallback(p->uic_cntx, inst_armed)) == inst_user_abort)
+			ev = I1PRO_USER_ABORT;	/* Abort */
+	}
+
+	if (ev != I1PRO_OK && ev != I1PRO_USER_TRIG) {
+		free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+		free(mbuf);
+		if (buf != NULL)
+			free(buf);
+		a1logd(p->log,2,"i1pro_imp_measure user aborted, terminated, command, or failure\n");
+		return ev;		/* User abort, term, command or failure */
+	}
+
+	if (s->emiss && !s->scan && s->adaptive) {
+		int saturated = 0;
+		double optscale = 1.0;
+		s->inttime = 0.25;
+		s->gainmode = 0;
+		s->dark_valid = 0;
+
+		a1logd(p->log,2,"Trial measure emission with inttime %f, gainmode %d\n",s->inttime,s->gainmode);
+
+		/* Take a trial measurement reading using the current mode. */
+		/* Used to determine if sensor is saturated, or not optimal */
+//		nummeas = i1pro_comp_nummeas(p, s->wreadtime, s->inttime);
+		nummeas = 1;
+		if ((ev = i1pro_trialmeasure(p, &saturated, &optscale, nummeas, &s->inttime, s->gainmode,
+		                                                            s->targoscale)) != I1PRO_OK) {
+			free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+			free(mbuf);
+			a1logd(p->log,2,"i1pro_imp_measure trial measure failed\n");
+			return ev;  
+		}
+
+		if (saturated) {
+			s->inttime = m->min_int_time;
+
+			a1logd(p->log,2,"2nd trial measure emission with inttime %f, gainmode %d\n",
+			                                         s->inttime,s->gainmode);
+			/* Take a trial measurement reading using the current mode. */
+			/* Used to determine if sensor is saturated, or not optimal */
+			nummeas = i1pro_comp_nummeas(p, 0.25, s->inttime);
+			if ((ev = i1pro_trialmeasure(p, &saturated, &optscale, nummeas, &s->inttime, 
+			                                          s->gainmode, s->targoscale)) != I1PRO_OK) {
+				free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+				free(mbuf);
+				a1logd(p->log,2,"i1pro_imp_measure trial measure failed\n");
+				return ev;  
+			}
+		}
+
+		a1logd(p->log,2,"Compute optimal integration time\n");
+		/* For adaptive mode, compute a new integration time and gain mode */
+		/* in order to optimise the sensor values. */
+		if ((ev = i1pro_optimise_sensor(p, &s->inttime, &s->gainmode, 
+		         s->inttime, s->gainmode, 1, 1, s->targoscale, optscale)) != I1PRO_OK) {
+			free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+			free(mbuf);
+			a1logd(p->log,2,"i1pro_imp_measure optimise sensor failed\n");
+			return ev;
+		}
+		a1logd(p->log,2,"Computed optimal emiss inttime %f and gainmode %d\n",s->inttime,s->gainmode);
+
+		a1logd(p->log,2,"Interpolate dark calibration reference\n");
+		if ((ev = i1pro_interp_dark(p, s->dark_data, s->inttime, s->gainmode)) != I1PRO_OK) {
+			free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+			free(mbuf);
+			a1logd(p->log,2,"i1pro_imp_measure interplate dark ref failed\n");
+			return ev;
+		}
+		s->dark_valid = 1;
+		s->dark_int_time = s->inttime;
+		s->dark_gain_mode = s->gainmode;
+
+		/* Recompute number of measurements and realloc measurement buffer */
+		free(mbuf);
+		nummeas = i1pro_comp_nummeas(p, s->wreadtime, s->inttime);
+		maxnummeas = i1pro_comp_nummeas(p, s->maxscantime, s->inttime);
+		if (maxnummeas < nummeas)
+			maxnummeas = nummeas;
+		mbsize = m->nsen * 2 * maxnummeas;
+		if ((mbuf = (unsigned char *)malloc(sizeof(unsigned char) * mbsize)) == NULL) {
+			free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+			a1logd(p->log,1,"i1pro_imp_measure malloc %d bytes failed (7)\n",mbsize);
+			return I1PRO_INT_MALLOC;
+		}
+
+	} else if (s->reflective) {
+
+		DISDPLOT
+
+		a1logd(p->log,2,"Doing on the fly black calibration_1 with nummeas %d int_time %f, gainmode %d\n",
+		                                                   nummeas, s->inttime, s->gainmode);
+
+		if ((ev = i1pro_dark_measure_1(p, nummeas, &s->inttime, s->gainmode, buf, bsize))
+		                                                                           != I1PRO_OK) {
+			free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+			free(buf);
+			free(mbuf);
+			a1logd(p->log,2,"i1pro_imp_measure dak measure 1 failed\n");
+			return ev;
+		}
+
+		ENDPLOT
+	}
+	/* Take a measurement reading using the current mode. */
+	/* Converts to completely processed output readings. */
+
+	a1logd(p->log,2,"Do main measurement reading\n");
+
+	/* Indicate to the user that they can now scan the instrument, */
+	/* after a little delay that allows for the instrument reaction time. */
+	if (s->scan) {
+		/* 500msec delay, 1KHz for 200 msec */
+		msec_beep(200 + (int)(s->lamptime * 1000.0 + 0.5), 1000, 200);
+	}
+
+	/* Retry loop for certaing cases */
+	for (;;) {
+
+		/* Trigger measure and gather raw readings */
+		if ((ev = i1pro_read_patches_1(p, nummeas, maxnummeas, &s->inttime, s->gainmode,
+		                                       &nmeasuered, mbuf, mbsize)) != I1PRO_OK) {
+			free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+			if (buf != NULL)
+				free(buf);
+			free(mbuf);
+			a1logd(p->log,2,"i1pro_imp_measure failed at i1pro_read_patches_1\n");
+			return ev;
+		}
+
+		/* Complete reflective black reference measurement */
+		if (s->reflective) {
+			a1logd(p->log,3,"Calling black calibration_2 calc with nummeas %d, inttime %f, gainmode %d\n", nummeas, s->inttime,s->gainmode);
+			if ((ev = i1pro_dark_measure_2(p, s->dark_data,
+				            nummeas, s->inttime, s->gainmode, buf, bsize)) != I1PRO_OK) {
+				free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+				free(buf);
+				free(mbuf);
+				a1logd(p->log,2,"i1pro_imp_measure failed at i1pro_dark_measure_2\n");
+				return ev;
+			}
+			s->dark_valid = 1;
+			s->dark_int_time = s->inttime;
+			s->dark_gain_mode = s->gainmode;
+			free(buf);
+		}
+
+		/* Process the raw measurement readings into final spectral readings */
+		ev = i1pro_read_patches_2(p, &duration, specrd, nvals, s->inttime, s->gainmode,
+		                                              nmeasuered, mbuf, mbsize);
+		/* Special case display mode read. If the sensor is saturated, and */
+		/* we haven't already done so, switch to the alternate integration time */
+		/* and try again. */
+		if (s->emiss && !s->scan && !s->adaptive
+		 && ev == I1PRO_RD_SENSORSATURATED
+		 && s->dispswap < 2) {
+			double *tt, tv;
+
+			if (s->dispswap == 0) {
+				a1logd(p->log,2,"Switching to alternate display integration time %f seconds\n",s->dark_int_time2);
+				tv = s->inttime; s->inttime = s->dark_int_time2; s->dark_int_time2 = tv;
+				tt = s->dark_data; s->dark_data = s->dark_data2; s->dark_data2 = tt;
+				s->dispswap = 1;
+			} else if (s->dispswap == 1) {
+				a1logd(p->log,2,"Switching to 2nd alternate display integration time %f seconds\n",s->dark_int_time3);
+				/* Undo first swap */
+				tv = s->inttime; s->inttime = s->dark_int_time2; s->dark_int_time2 = tv;
+				tt = s->dark_data; s->dark_data = s->dark_data2; s->dark_data2 = tt;
+				/* Do 2nd swap */
+				tv = s->inttime; s->inttime = s->dark_int_time3; s->dark_int_time3 = tv;
+				tt = s->dark_data; s->dark_data = s->dark_data3; s->dark_data3 = tt;
+				s->dispswap = 2;
+			}
+			/* Recompute number of measurements and realloc measurement buffer */
+			free(mbuf);
+			nummeas = i1pro_comp_nummeas(p, s->wreadtime, s->inttime);
+			maxnummeas = i1pro_comp_nummeas(p, s->maxscantime, s->inttime);
+			if (maxnummeas < nummeas)
+				maxnummeas = nummeas;
+			mbsize = m->nsen * 2 * maxnummeas;
+			if ((mbuf = (unsigned char *)malloc(sizeof(unsigned char) * mbsize)) == NULL) {
+				free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+				a1logd(p->log,1,"i1pro_imp_measure malloc %d bytes failed (7)\n",mbsize);
+				return I1PRO_INT_MALLOC;
+			}
+			continue;			/* Do the measurement again */
+		}
+
+		if (ev != I1PRO_OK) {
+			free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+			free(mbuf);
+			a1logd(p->log,2,"i1pro_imp_measure failed at i1pro_read_patches_2\n");
+			return ev;
+		}
+		break;		/* Don't repeat */
+	}
+	free(mbuf);
+
+	/* Transfer spectral and convert to XYZ */
+	if ((ev = i1pro_conv2XYZ(p, vals, nvals, specrd, clamp)) != I1PRO_OK) {
+		free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+		a1logd(p->log,2,"i1pro_imp_measure failed at i1pro_conv2XYZ\n");
+		return ev;
+	}
+	free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+	
+	if (nvals > 0)
+		vals[0].duration = duration;	/* Possible flash duration */
+	
+	/* Update log counters */
+	if (s->reflective) {
+		if (s->scan)
+			m->acount++;
+		else {
+			m->rpinttime = s->inttime;
+			m->rpcount++;
+		}
+	}
+	
+	a1logd(p->log,3,"i1pro_imp_measure sucessful return\n");
+	if (user_trig)
+		return I1PRO_USER_TRIG;
+	return ev; 
+}
+
+/* - - - - - - - - - - - - - - - - */
+/*
+
+	Determining the refresh rate for a refresh type display.
+
+	This is easy when the max sample rate of the i1 is above
+	the nyquist of the display, and will always be the case
+	for the range we are prepared to measure (up to 100Hz)
+	when using an Rev B, D or E, but is a problem for the
+	rev A and ColorMunki, which can only sample at 113Hz.
+
+	We work around this problem by detecting when
+	we are measuring an alias of the refresh rate, and
+	average the aliasing corrected measurements.
+
+	If there is no aparent refresh, or the refresh rate is not determinable,
+	return a period of 0.0 and inst_ok;
+*/
+
+i1pro_code i1pro_measure_rgb(i1pro *p, double *inttime, double *rgb);
+
+#ifndef PSRAND32L 
+# define PSRAND32L(S) ((S) * 1664525L + 1013904223L)
+#endif
+#undef FREQ_SLOW_PRECISE	/* [und] Interpolate then autocorrelate, else autc & filter */
+#define NFSAMPS 80		/* Number of samples to read */
+#define NFMXTIME 6.0	/* Maximum time to take (2000 == 6) */
+#define PBPMS 20		/* bins per msec */
+#define PERMIN ((1000 * PBPMS)/40)	/* 40 Hz */
+#define PERMAX ((1000 * PBPMS)/4)	/* 4 Hz*/
+#define NPER (PERMAX - PERMIN + 1)
+#define PWIDTH (8 * PBPMS)			/* 8 msec bin spread to look for peak in */
+#define MAXPKS 20					/* Number of peaks to find */
+#define TRIES 8	 					/* Number of different sample rates to try */
+
+i1pro_code i1pro_imp_meas_refrate(
+	i1pro *p,
+	double *ref_rate
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	int i, j, k, mm;
+	double **multimeas;			/* Spectral measurements */
+	int nummeas;
+	double rgbw[3] = { 610.0, 520.0, 460.0 };
+	double ucalf = 1.0;				/* usec_time calibration factor */
+	double inttime;
+	static unsigned int randn = 0x12345678;
+	struct {
+		double sec;
+		double rgb[3];
+	} samp[NFSAMPS * 2];
+	int nfsamps;			/* Actual samples read */
+	double minv[3];			/* Minimum reading */
+	double maxv[3];			/* Maximum reading */
+	double maxt;			/* Time range */
+#ifdef FREQ_SLOW_PRECISE
+	int nbins;
+	double *bins[3];		/* PBPMS sample bins */
+#else
+	double tcorr[NPER];		/* Temp for initial autocorrelation */
+	int ntcorr[NPER];		/* Number accumulated */
+#endif
+	double corr[NPER];		/* Filtered correlation for each period value */
+	double mincv, maxcv;	/* Max and min correlation values */
+	double crange;			/* Correlation range */
+	double peaks[MAXPKS];	/* Peak wavelength */
+	double peakh[MAXPKS];	/* Peak heighheight */
+	int npeaks;				/* Number of peaks */
+	double pval;			/* Period value */
+	double rfreq[TRIES];	/* Computed refresh frequency for each try */
+	double rsamp[TRIES];	/* Sampling rate used to measure frequency */
+	int tix = 0;			/* try index */
+
+	a1logd(p->log,2,"i1pro_imp_meas_refrate called\n");
+
+	if (!s->emiss) {
+		a1logd(p->log,2,"i1pro_imp_meas_refrate not in emissive mode\n");
+		return I1PRO_UNSUPPORTED;
+	}
+
+	for (mm = 0; mm < TRIES; mm++) {
+		rfreq[mm] = 0.0;
+		npeaks = 0;			/* Number of peaks */
+		nummeas = NFSAMPS;
+		multimeas = dmatrix(0, nummeas-1, -1, m->nwav[m->highres]-1);
+
+		if (mm == 0)
+			inttime = m->min_int_time;
+		else {
+			double rval, dmm;
+			randn = PSRAND32L(randn);
+			rval = (double)randn/4294967295.0;
+			dmm = ((double)mm + rval - 0.5)/(TRIES - 0.5);
+			inttime = m->min_int_time * (1.0 + dmm * 0.80);
+		}
+
+		if ((ev = i1pro_read_patches_all(p, multimeas, nummeas, &inttime, 0)) != inst_ok) {
+			free_dmatrix(multimeas, 0, nummeas-1, 0, m->nwav[m->highres]-1);
+			return ev;
+		} 
+
+		rsamp[tix] = 1.0/inttime;
+
+		/* Convert the samples to RGB */
+		for (i = 0; i < nummeas && i < NFSAMPS; i++) {
+			samp[i].sec = i * inttime;
+			samp[i].rgb[0] = samp[i].rgb[1] = samp[i].rgb[2] = 0.0;
+			for (j = 0; j < m->nwav[m->highres]; j++) {
+				double wl = XSPECT_WL(m->wl_short[m->highres], m->wl_long[m->highres], m->nwav[m->highres], j);
+
+//printf("~1 multimeas %d %d = %f\n",i, j, multimeas[i][j]);
+				for (k = 0; k < 3; k++) {
+					double tt = (double)(wl - rgbw[k]);
+					tt = (40.0 - fabs(tt))/40.0;
+					if (tt < 0.0)
+						tt = 0.0;
+					samp[i].rgb[k] += tt * multimeas[i][j];
+				}
+			}
+		}
+		nfsamps = i;
+
+		a1logd(p->log, 3, "i1pro_measure_refresh: Read %d samples for refresh calibration\n",nfsamps);
+
+#ifdef NEVER
+		/* Plot the raw sensor values */
+		{
+			double xx[NFSAMPS];
+			double y1[NFSAMPS];
+			double y2[NFSAMPS];
+			double y3[NFSAMPS];
+
+			for (i = 0; i < nfsamps; i++) {
+				xx[i] = samp[i].sec;
+				y1[i] = samp[i].rgb[0];
+				y2[i] = samp[i].rgb[1];
+				y3[i] = samp[i].rgb[2];
+//			printf("%d: %f -> %f\n",i,samp[i].sec, samp[i].rgb[0]);
+			}
+			printf("Fast scan sensor values and time (sec)\n");
+			do_plot6(xx, y1, y2, y3, NULL, NULL, NULL, nfsamps);
+		}
+#endif
+
+		/* Locate the smallest values and maximum time */
+		maxt = -1e6;
+		minv[0] = minv[1] = minv[2] = 1e20;
+		maxv[0] = maxv[1] = maxv[2] = -11e20;
+		for (i = nfsamps-1; i >= 0; i--) {
+			if (samp[i].sec > maxt)
+				maxt = samp[i].sec;
+			for (j = 0; j < 3; j++) {
+				if (samp[i].rgb[j] < minv[j])
+					minv[j] = samp[i].rgb[j]; 
+				if (samp[i].rgb[j] > maxv[j])
+					maxv[j] = samp[i].rgb[j]; 
+			}
+		}
+		/* Re-zero the sample times, and normalise the readings */
+		for (i = nfsamps-1; i >= 0; i--) {
+			samp[i].sec -= samp[0].sec; 
+			samp[i].sec *= ucalf;
+			if (samp[i].sec > maxt)
+				maxt = samp[i].sec;
+			for (j = 0; j < 3; j++) {
+				samp[i].rgb[j] -= minv[j];
+			}
+		}
+
+#ifdef FREQ_SLOW_PRECISE	/* Interp then autocorrelate */
+
+		/* Create PBPMS bins and interpolate readings into them */
+		nbins = 1 + (int)(maxt * 1000.0 * PBPMS + 0.5);
+		for (j = 0; j < 3; j++) {
+			if ((bins[j] = (double *)calloc(sizeof(double), nbins)) == NULL) {
+				a1loge(p->log, inst_internal_error, "i1pro_measure_refresh: malloc failed\n");
+				return I1PRO_INT_MALLOC;
+			}
+		}
+
+		/* Do the interpolation */
+		for (k = 0; k < (nfsamps-1); k++) {
+			int sbin, ebin;
+			sbin = (int)(samp[k].sec * 1000.0 * PBPMS + 0.5);
+			ebin = (int)(samp[k+1].sec * 1000.0 * PBPMS + 0.5);
+			for (i = sbin; i <= ebin; i++) {
+				double bl;
+#if defined(__APPLE__) && defined(__POWERPC__)
+				gcc_bug_fix(i);
+#endif
+				bl = (i - sbin)/(double)(ebin - sbin);	/* 0.0 to 1.0 */
+				for (j = 0; j < 3; j++) {
+					bins[j][i] = (1.0 - bl) * samp[k].rgb[j] + bl * samp[k+1].rgb[j];
+				}
+			} 
+		}
+
+#ifdef NEVER
+
+		/* Plot interpolated values */
+		{
+			double *xx;
+			double *y1;
+			double *y2;
+			double *y3;
+
+			xx = malloc(sizeof(double) * nbins);
+			y1 = malloc(sizeof(double) * nbins);
+			y2 = malloc(sizeof(double) * nbins);
+			y3 = malloc(sizeof(double) * nbins);
+
+			if (xx == NULL || y1 == NULL || y2 == NULL || y3 == NULL) {
+				a1loge(p->log, inst_internal_error, "i1pro_measure_refresh: malloc failed\n");
+				for (j = 0; j < 3; j++)
+					free(bins[j]);
+				return I1PRO_INT_MALLOC;
+			}
+			for (i = 0; i < nbins; i++) {
+				xx[i] = i / (double)PBPMS;			/* msec */
+				y1[i] = bins[0][i];
+				y2[i] = bins[1][i];
+				y3[i] = bins[2][i];
+			}
+			printf("Interpolated fast scan sensor values and time (msec) for inttime %f\n",inttime);
+			do_plot6(xx, y1, y2, y3, NULL, NULL, NULL, nbins);
+
+			free(xx);
+			free(y1);
+			free(y2);
+			free(y3);
+		}
+#endif /* PLOT_REFRESH */
+
+		/* Compute auto-correlation at 1/PBPMS msec intervals */
+		/* from 25 msec (40Hz) to 100msec (10 Hz) */
+		mincv = 1e48, maxcv = -1e48;
+		for (i = 0; i < NPER; i++) {
+			int poff = PERMIN + i;		/* Offset to corresponding sample */
+
+			corr[i] = 0;
+			for (k = 0; (k + poff) < nbins; k++) {
+				corr[i] += bins[0][k] * bins[0][k + poff]
+				        +  bins[1][k] * bins[1][k + poff]
+				        +  bins[2][k] * bins[2][k + poff];
+			}
+			corr[i] /= (double)k;		/* Normalize */
+
+			if (corr[i] > maxcv)
+				maxcv = corr[i];
+			if (corr[i] < mincv)
+				mincv = corr[i];
+		}
+		/* Free the bins */
+		for (j = 0; j < 3; j++)
+			free(bins[j]);
+
+#else /* !FREQ_SLOW_PRECISE  Fast - autocorrellate then filter */
+
+	/* Upsample by a factor of 2 */
+	for (i = nfsamps-1; i >= 0; i--) {
+		j = 2 * i;
+		samp[j].sec = samp[i].sec;
+		samp[j].rgb[0] = samp[i].rgb[0];
+		samp[j].rgb[1] = samp[i].rgb[1];
+		samp[j].rgb[2] = samp[i].rgb[2];
+		if (i > 0) {
+			j--;
+			samp[j].sec = 0.5 * (samp[i].sec + samp[i-1].sec);
+			samp[j].rgb[0] = 0.5 * (samp[i].rgb[0] + samp[i-1].rgb[0]);
+			samp[j].rgb[1] = 0.5 * (samp[i].rgb[1] + samp[i-1].rgb[1]);
+			samp[j].rgb[2] = 0.5 * (samp[i].rgb[2] + samp[i-1].rgb[2]);
+		}
+	}
+	nfsamps = 2 * nfsamps - 1;
+
+	/* Do point by point correllation of samples */
+	for (i = 0; i < NPER; i++) {
+		tcorr[i] = 0.0;
+		ntcorr[i] = 0;
+	}
+
+	for (j = 0; j < (nfsamps-1); j++) {
+
+		for (k = j+1; k < nfsamps; k++) {
+			double del, cor;
+			int bix;
+
+			del = samp[k].sec - samp[j].sec;
+			bix = (int)(del * 1000.0 * PBPMS + 0.5);
+			if (bix < PERMIN)
+				continue;
+			if (bix > PERMAX)
+				break;
+			bix -= PERMIN;
+		
+			cor = samp[j].rgb[0] * samp[k].rgb[0]
+	            + samp[j].rgb[1] * samp[k].rgb[1]
+	            + samp[j].rgb[2] * samp[k].rgb[2];
+
+//printf("~1 j %d k %d, del %f bix %d cor %f\n",j,k,del,bix,cor);
+			tcorr[bix] += cor;
+			ntcorr[bix]++;
+		} 
+	}
+	/* Divide out count and linearly interpolate */
+	j = 0;
+	for (i = 0; i < NPER; i++) {
+		if (ntcorr[i] > 0) {
+			tcorr[i] /= ntcorr[i];
+			if ((i - j) > 1) {
+				if (j == 0) {
+					for (k = j; k < i; k++)
+						tcorr[k] = tcorr[i];
+
+				} else {		/* Linearly interpolate from last value */
+					double ww = (double)i-j;
+					for (k = j+1; k < i; k++) {
+						double bl = (k-j)/ww;
+						tcorr[k] = (1.0 - bl) * tcorr[j] + bl * tcorr[i];
+					}
+				}
+			}
+			j = i;
+		}
+	}
+	if (j < (NPER-1)) {
+		for (k = j+1; k < NPER; k++) {
+			tcorr[k] = tcorr[j];
+		}
+	}
+
+#ifdef PLOT_REFRESH
+	/* Plot unfiltered auto correlation */
+	{
+		double xx[NPER];
+		double y1[NPER];
+
+		for (i = 0; i < NPER; i++) {
+			xx[i] = (i + PERMIN) / (double)PBPMS;			/* msec */
+			y1[i] = tcorr[i];
+		}
+		printf("Unfiltered auto correlation (msec)\n");
+		do_plot6(xx, y1, NULL, NULL, NULL, NULL, NULL, NPER);
+	}
+#endif /* PLOT_REFRESH */
+
+	/* Apply a gausian filter */
+#define FWIDTH 100
+	{
+		double gaus_[2 * FWIDTH * PBPMS + 1];
+		double *gaus = &gaus_[FWIDTH * PBPMS];
+		double bb = 1.0/pow(2, 5.0);
+		double fw = inttime * 1000.0;
+		int ifw;
+
+//printf("~1 sc = %f = %f msec\n",1.0/inttime, fw);
+//printf("~1 fw = %f, ifw = %d\n",fw,ifw);
+
+		fw *= 0.9;
+		ifw = (int)ceil(fw * PBPMS);
+		if (ifw > FWIDTH * PBPMS)
+			error("i1pro: Not enough space for lanczos 2 filter");
+		for (j = -ifw; j <= ifw; j++) {
+			double x, y;
+			x = j/(PBPMS * fw);
+			if (fabs(x) > 1.0)
+				y = 0.0;
+			else
+				y = 1.0/pow(2, 5.0 * x * x) - bb;
+			gaus[j] = y;
+//printf("~1 gaus[%d] = %f\n",j,y);
+		}
+
+		for (i = 0; i < NPER; i++) {
+			double sum = 0.0;
+			double wght = 0.0;
+			
+			for (j = -ifw; j <= ifw; j++) {
+				double w;
+				int ix = i + j;
+				if (ix < 0)
+					ix = -ix;
+				if (ix > (NPER-1))
+					ix = 2 * NPER-1 - ix;
+				w = gaus[j];
+				sum += w * tcorr[ix];
+				wght += w;
+			}
+//printf("~1 corr[%d] wgt = %f\n",i,wght);
+			corr[i] = sum / wght;
+		}
+	}
+
+	/* Compute min & max */
+	mincv = 1e48, maxcv = -1e48;
+	for (i = 0; i < NPER; i++) {
+		if (corr[i] > maxcv)
+			maxcv = corr[i];
+		if (corr[i] < mincv)
+			mincv = corr[i];
+	}
+
+#endif /* !FREQ_SLOW_PRECISE  Fast - autocorrellate then filter */
+
+		crange = maxcv - mincv;
+		a1logd(p->log,3,"Correlation value range %f - %f = %f = %f%%\n",mincv, maxcv,crange, 100.0 * (maxcv-mincv)/maxcv);
+
+#ifdef PLOT_REFRESH
+		/* Plot this measuremnts auto correlation */
+		{
+			double xx[NPER];
+			double y1[NPER];
+		
+			for (i = 0; i < NPER; i++) {
+				xx[i] = (i + PERMIN) / (double)PBPMS;			/* msec */
+				y1[i] = corr[i];
+			}
+			printf("Auto correlation (msec)\n");
+			do_plot6(xx, y1, NULL, NULL, NULL, NULL, NULL, NPER);
+		}
+#endif /* PLOT_REFRESH */
+
+#define PFDB 4	// normally 4
+		/* If there is sufficient level and distict correlations */
+		if (crange/maxcv >= 0.1) {
+
+			a1logd(p->log,PFDB,"Searching for peaks\n");
+
+			/* Locate all the peaks starting at the longest correllation */
+			for (i = (NPER-1-PWIDTH); i >= 0 && npeaks < MAXPKS; i--) {
+				double v1, v2, v3;
+				v1 = corr[i];
+				v2 = corr[i + PWIDTH/2];	/* Peak */
+				v3 = corr[i + PWIDTH];
+
+				if (fabs(v3 - v1)/crange < 0.05
+				 && (v2 - v1)/crange > 0.025
+				 && (v2 - v3)/crange > 0.025
+				 && (v2 - mincv)/crange > 0.5) {
+					double pkv;			/* Peak value */
+					int pki;			/* Peak index */
+					double ii, bl;
+
+#ifdef PLOT_REFRESH
+					a1logd(p->log,PFDB,"Max between %f and %f msec\n",
+					       (i + PERMIN)/(double)PBPMS,(i + PWIDTH + PERMIN)/(double)PBPMS);
+#endif
+
+					/* Locate the actual peak */
+					pkv = -1.0;
+					pki = 0;
+					for (j = i; j < (i + PWIDTH); j++) {
+						if (corr[j] > pkv) {
+							pkv = corr[j];
+							pki = j;
+						}
+					}
+#ifdef PLOT_REFRESH
+					a1logd(p->log,PFDB,"Peak is at %f msec, %f corr\n", (pki + PERMIN)/(double)PBPMS, pkv);
+#endif
+
+					/* Interpolate the peak value for higher precision */
+					/* j = bigest */
+					if (corr[pki-1] > corr[pki+1])  {
+						j = pki-1;
+						k = pki+1;
+					} else {
+						j = pki+1;
+						k = pki-1;
+					}
+					bl = (corr[pki] - corr[j])/(corr[pki] - corr[k]);
+					bl = (bl + 1.0)/2.0;
+					ii = bl * pki + (1.0 - bl) * j;
+					pval = (ii + PERMIN)/(double)PBPMS;
+#ifdef PLOT_REFRESH
+					a1logd(p->log,PFDB,"Interpolated peak is at %f msec\n", pval);
+#endif
+					peaks[npeaks] = pval;
+					peakh[npeaks] = corr[pki];
+					npeaks++;
+
+					i -= PWIDTH;
+				}
+#ifdef NEVER
+				if (v2 > v1 && v2 > v3) {
+					printf("Peak rehjected:\n");
+					printf("(v3 - v1)/crange = %f < 0.05 ?\n",fabs(v3 - v1)/crange);
+					printf("(v2 - v1)/crange = %f > 0.025 ?\n",(v2 - v1)/crange);
+					printf("(v2 - v3)/crange = %f > 0.025 ?\n",(v2 - v3)/crange);
+					printf("(v2 - mincv)/crange = %f > 0.5 ?\n",(v2 - mincv)/crange);
+				}
+#endif
+			}
+			a1logd(p->log,3,"Number of peaks located = %d\n",npeaks);
+
+		} else {
+			a1logd(p->log,3,"All rejected, crange/maxcv = %f < 0.06\n",crange/maxcv);
+		}
+#undef PFDB
+
+		a1logd(p->log,3,"Number of peaks located = %d\n",npeaks);
+
+		if (npeaks > 1) {		/* Compute aparent refresh rate */
+			int nfails;
+			double div, avg, ano;
+			/* Try and locate a common divisor amongst all the peaks. */
+			/* This is likely to be the underlying refresh rate. */
+			for (k = 0; k < npeaks; k++) {
+				for (j = 1; j < 25; j++) {
+					avg = ano = 0.0;
+					div = peaks[k]/(double)j;
+					if (div < 5.0)
+						continue;		/* Skip anything higher than 200Hz */ 
+//printf("~1 trying %f Hz\n",1000.0/div);
+					for (nfails = i = 0; i < npeaks; i++) {
+						double rem, cnt;
+	
+						rem = peaks[i]/div;
+						cnt = floor(rem + 0.5);
+						rem = fabs(rem - cnt);
+	
+#ifdef PLOT_REFRESH
+						a1logd(p->log, 3, "remainder for peak %d = %f\n",i,rem);
+#endif
+						if (rem > 0.06) {
+							if (++nfails > 2)
+								break;				/* Fail this divisor */
+						} else {
+							avg += peaks[i];		/* Already weighted by cnt */
+							ano += cnt;
+						}
+					}
+	
+					if (nfails == 0 || (nfails <= 2 && npeaks >= 6))
+						break;		/* Sucess */
+					/* else go and try a different divisor */
+				}
+				if (j < 25)
+					break;			/* Success - found common divisor */
+			}
+			if (k >= npeaks) {
+				a1logd(p->log,3,"Failed to locate common divisor\n");
+			
+			} else {
+				pval = 0.001 * avg/ano;
+				if (pval < inttime) {
+					a1logd(p->log,3,"Discarding frequency %f > sample rate %f\n",1.0/pval, 1.0/inttime);
+				} else {
+					pval = 1.0/pval;		/* Convert to frequency */
+					rfreq[tix++] = pval;
+					a1logd(p->log,3,"Located frequency %f sum %f dif %f\n",pval, pval + 1.0/inttime, fabs(pval - 1.0/inttime));
+				}
+			}
+		}
+	}
+
+	if (tix >= 3) {
+
+		for (mm = 0; mm < tix; mm++) {
+			a1logd(p->log, 3, "Try %d, samp %f Hz, Meas %f Hz, Sum %f Hz, Dif %f Hz\n",mm,rsamp[mm],rfreq[mm], rsamp[mm] + rfreq[mm], fabs(rsamp[mm] - rfreq[mm]));
+		}
+	
+		/* Decide if we are above the nyquist, or whether */
+		/* we have aliases of the fundamental */
+		{
+			double brange = 1e38;
+			double brate = 0.0;
+			int bsplit = -1;
+			double min, max, avg, range;
+			int split, mul, niia;
+			
+			/* Compute fundamental and sub aliases at all possible splits. */
+			/* Skip the reading at the split. */
+			for (split = tix; split >= -1; split--) {
+				min = 1e38; max = -1e38; avg = 0.0; niia = 0;
+				for (mm = 0; mm < tix; mm++) {
+					double alias;
+
+					if (mm == split)
+						continue;
+					if (mm < split)
+						alias = rfreq[mm];
+					else
+						alias = fabs(rsamp[mm] - rfreq[mm]);
+
+					avg += alias;
+					niia++;
+	
+					if (alias < min)
+						min = alias;
+					if (alias > max)
+						max = alias;
+				}
+				avg /= (double)niia;
+				range = (max - min)/(max + min);
+//printf("~1 split %d avg = %f, range = %f\n",split,avg,range);
+				if (range < brange) {
+					brange = range;
+					brate = avg;
+					bsplit = split;
+				}
+			}
+
+			/* Compute sub and add aliases at all possible splits */
+			/* Skip the reading at the split. */
+			for (split = tix; split >= -1; split--) {
+				min = 1e38; max = -1e38; avg = 0.0; niia = 0;
+				for (mm = 0; mm < tix; mm++) {
+					double alias;
+
+					if (mm == split)
+						continue;
+					if (mm < split)
+						alias = fabs(rsamp[mm] - rfreq[mm]);
+					else
+						alias = rsamp[mm] + rfreq[mm];
+
+					avg += alias;
+					niia++;
+	
+					if (alias < min)
+						min = alias;
+					if (alias > max)
+						max = alias;
+				}
+				avg /= (double)niia;
+				range = (max - min)/(max + min);
+//printf("~1 split %d avg = %f, range = %f\n",100 + split,avg,range);
+				if (range < brange) {
+					brange = range;
+					brate = avg;
+					bsplit = 100 + split;
+				}
+			}
+
+			a1logd(p->log, 3, "Selected split %d range %f\n",bsplit,brange);
+			
+			/* Hmm. Could reject result and re-try if brange is too large ? ( > 0.005 ?) */
+		
+			if (brange > 0.05) {
+				a1logd(p->log, 3, "Readings are too inconsistent (brange %.1f%%) - should retry ?\n",brange * 100.0);
+			} else { 
+				if (ref_rate != NULL)
+					*ref_rate = brate;
+		
+				/* Error against my 85Hz CRT - GWG */
+//				a1logd(p->log, 1, "Refresh rate %f Hz, error = %.4f%%\n",brate,100.0 * fabs(brate - 85.0)/(85.0));
+				return I1PRO_OK;
+			}
+		}
+	} else {
+		a1logd(p->log, 3, "Not enough tries suceeded to determine refresh rate\n");
+	}
+
+	if (ref_rate != NULL)
+		*ref_rate = 0.0;
+
+	return I1PRO_RD_NOREFR_FOUND; 
+}
+#undef NFSAMPS 
+#undef PBPMS
+#undef PERMIN
+#undef PERMAX
+#undef NPER
+#undef PWIDTH
+
+/* - - - - - - - - - - - - - - - - - - - - - - */
+/* i1 refspot calibration/log stored on instrument */
+/* RevA..D only! */
+
+/* Restore the reflective spot calibration information from the EEPRom */
+/* Always returns success, even if the restore fails, */
+/* which may happen for an instrument that's never been used or had calibration */
+/* written to its EEProm */
+/* RevA..D only! */
+i1pro_code i1pro_restore_refspot_cal(i1pro *p) {
+	int chsum1, *chsum2;
+	int *ip, i;
+	unsigned int count;
+	double *dp;
+	unsigned char buf[256];
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[i1p_refl_spot];		/* NOT current mode, refspot mode */
+	i1key offst = 0;							/* Offset to copy to use */
+	i1pro_code ev = I1PRO_OK;
+	int o_nsen;									/* Actual nsen data */
+
+	a1logd(p->log,2,"Doing Restoring reflective spot calibration information from the EEProm\n");
+
+	chsum1 = m->data->checksum(m->data, 0);
+	if ((chsum2 = m->data->get_int(m->data, key_checksum, 0)) == NULL || chsum1 != *chsum2) {
+		offst = key_2logoff;
+		chsum1 = m->data->checksum(m->data, key_2logoff);
+		if ((chsum2 = m->data->get_int(m->data, key_checksum + key_2logoff, 0)) == NULL
+		     || chsum1 != *chsum2) {
+			a1logd(p->log,2,"Neither EEPRom checksum was valid\n");
+			return I1PRO_OK;
+		}
+	}
+
+	/* Get the calibration gain mode */
+	if ((ip = m->data->get_ints(m->data, &count, key_gainmode + offst)) == NULL || count < 1) {
+		a1logd(p->log,2,"Failed to read calibration gain mode from EEPRom\n");
+		return I1PRO_OK;
+	}
+	if (ip[0] == 0) {
+#ifdef USE_HIGH_GAIN_MODE
+		s->gainmode = 1;
+#else
+		s->gainmode = 0;
+		a1logd(p->log,2,"Calibration gain mode was high, and high gain not compiled in\n");
+		return I1PRO_OK;
+#endif /* !USE_HIGH_GAIN_MODE */
+	} else
+		s->gainmode = 0;
+
+	/* Get the calibration integrattion time */
+	if ((dp = m->data->get_doubles(m->data, &count, key_inttime + offst)) == NULL || count < 1) {
+		a1logd(p->log,2,"Failed to read calibration integration time from EEPRom\n");
+		return I1PRO_OK;
+	}
+	s->inttime = dp[0];
+	if (s->inttime < m->min_int_time)	/* Hmm. EEprom is occasionaly screwed up */
+		s->inttime = m->min_int_time;
+
+	/* Get the dark data */
+	if ((ip = m->data->get_ints(m->data, &count, key_darkreading + offst)) == NULL
+	                                                              || count != 128) {
+		a1logv(p->log,1,"Failed to read calibration dark data from EEPRom\n");
+		return I1PRO_OK;
+	}
+
+	/* Convert back to a single raw big endian instrument readings */
+	for (i = 0; i < 128; i++) {
+		buf[i * 2 + 0] = (ip[i] >> 8) & 0xff;
+		buf[i * 2 + 1] = ip[i] & 0xff;
+	}
+
+	/* Convert to calibration data */
+	a1logd(p->log,3,"Calling black calibration_2 calc with nummeas %d, inttime %f, gainmode %d\n", 1, s->inttime,s->gainmode);
+	o_nsen = m->nsen;
+	m->nsen = 128;		/* Assume EEprom cal data is <= Rev D format */
+	if ((ev = i1pro_dark_measure_2(p, s->dark_data, 1, s->inttime, s->gainmode,
+		                                                 buf, 256)) != I1PRO_OK) {
+		a1logd(p->log,2,"Failed to convert EEProm dark data to calibration\n");
+		m->nsen = o_nsen;
+		return I1PRO_OK;
+	}
+
+	/* We've sucessfully restored the dark calibration */
+	s->dark_valid = 1;
+	s->ddate = m->caldate;
+
+	/* Get the white calibration data */
+	if ((ip = m->data->get_ints(m->data, &count, key_whitereading + offst)) == NULL
+	                                                               || count != 128) {
+		a1logd(p->log,2,"Failed to read calibration white data from EEPRom\n");
+		m->nsen = o_nsen;
+		return I1PRO_OK;
+	}
+
+	/* Convert back to a single raw big endian instrument readings */
+	for (i = 0; i < 128; i++) {
+		buf[i * 2 + 0] = (ip[i] >> 8) & 0xff;
+		buf[i * 2 + 1] = ip[i] & 0xff;
+	}
+
+	/* Convert to calibration data */
+	m->nsen = 128;		/* Assume EEprom cal data is <= Rev D format */
+	if ((ev = i1pro_whitemeasure_buf(p, s->cal_factor[0], s->cal_factor[1], s->white_data,
+	                s->inttime, s->gainmode, buf)) != I1PRO_OK) {
+		/* This may happen for an instrument that's never been used */
+		a1logd(p->log,2,"Failed to convert EEProm white data to calibration\n");
+		m->nsen = o_nsen;
+		return I1PRO_OK;
+	}
+	m->nsen = o_nsen;
+
+	/* Check a reflective white measurement, and check that */
+	/* it seems reasonable. Return I1PRO_OK if it is, error if not. */
+	/* (Using cal_factor[] as temp.) */
+	if ((ev = i1pro_check_white_reference1(p, s->cal_factor[0])) != I1PRO_OK) {
+		/* This may happen for an instrument that's never been used */
+		a1logd(p->log,2,"Failed to convert EEProm white data to calibration\n");
+		return I1PRO_OK;
+	}
+	/* Compute a calibration factor given the reading of the white reference. */
+	i1pro_compute_white_cal(p, s->cal_factor[0], m->white_ref[0], s->cal_factor[0],
+	                           s->cal_factor[1], m->white_ref[1], s->cal_factor[1]);
+
+	/* We've sucessfully restored the calibration */
+	s->cal_valid = 1;
+	s->cfdate = m->caldate;
+
+	return I1PRO_OK;
+}
+
+/* Save the reflective spot calibration information to the EEPRom data object. */
+/* Note we don't actually write to the EEProm here! */
+/* For RevA..D only! */
+static i1pro_code i1pro_set_log_data(i1pro *p) {
+	int *ip, i;
+	unsigned int count;
+	double *dp;
+	double absmeas[128];
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[i1p_refl_spot];		/* NOT current mode, refspot mode */
+	i1key offst = 0;							/* Offset to copy to use */
+	i1pro_code ev = I1PRO_OK;
+
+	a1logd(p->log,3,"i1pro_set_log_data called\n");
+
+	if (s->dark_valid == 0 || s->cal_valid == 0)
+		return I1PRO_INT_NO_CAL_TO_SAVE;
+
+	/* Set the calibration gain mode */
+	if ((ip = m->data->get_ints(m->data, &count, key_gainmode + offst)) == NULL || count < 1) {
+		a1logd(p->log,2,"Failed to access calibration gain mode from EEPRom\n");
+		return I1PRO_INT_EEPROM_DATA_MISSING;
+	}
+	if (s->gainmode == 0)
+		ip[0] = 1;
+	else
+		ip[0] = 0;
+
+	/* Set the calibration integration time */
+	if ((dp = m->data->get_doubles(m->data, &count, key_inttime + offst)) == NULL || count < 1) {
+		a1logd(p->log,2,"Failed to read calibration integration time from EEPRom\n");
+		return I1PRO_INT_EEPROM_DATA_MISSING;
+	}
+	dp[0] = s->inttime;
+
+	/* Set the dark data */
+	if ((ip = m->data->get_ints(m->data, &count, key_darkreading + offst)) == NULL
+	                                                              || count != 128) {
+		a1logd(p->log,2,"Failed to access calibration dark data from EEPRom\n");
+		return I1PRO_INT_EEPROM_DATA_MISSING;
+	}
+
+	/* Convert abs dark_data to raw data */
+	if ((ev = i1pro_absraw_to_meas(p, ip, s->dark_data, s->inttime, s->gainmode)) != I1PRO_OK)
+		return ev;
+
+	/* Add back black level to white data */
+	for (i = 0; i < 128; i++)
+		absmeas[i] = s->white_data[i] + s->dark_data[i];
+
+	/* Get the white data */
+	if ((ip = m->data->get_ints(m->data, &count, key_whitereading + offst)) == NULL
+	                                                               || count != 128) {
+		a1logd(p->log,2,"Failed to access calibration white data from EEPRom\n");
+		return I1PRO_INT_EEPROM_DATA_MISSING;
+	}
+
+	/* Convert abs white_data to raw data */
+	if ((ev = i1pro_absraw_to_meas(p, ip, absmeas, s->inttime, s->gainmode)) != I1PRO_OK)
+		return ev;
+
+	/* Set all the log counters */
+
+	/* Total Measure (Emis/Remis/Ambient/Trans/Cal) count */
+	if ((ip = m->data->get_ints(m->data, &count, key_meascount)) == NULL || count < 1) {
+		a1logd(p->log,2,"Failed to access meascount log counter from EEPRom\n");
+		return I1PRO_INT_EEPROM_DATA_MISSING;
+	}
+	ip[0] = m->meascount;
+
+	/* Remspotcal last calibration date */
+	if ((ip = m->data->get_ints(m->data, &count, key_caldate)) == NULL || count < 1) {
+		a1logd(p->log,2,"Failed to access caldate log counter from EEPRom\n");
+		return I1PRO_INT_EEPROM_DATA_MISSING;
+	}
+	ip[0] = m->caldate;
+
+	/* Remission spot measure count at last Remspotcal. */
+	if ((ip = m->data->get_ints(m->data, &count, key_calcount)) == NULL || count < 1) {
+		a1logd(p->log,2,"Failed to access calcount log counter from EEPRom\n");
+		return I1PRO_INT_EEPROM_DATA_MISSING;
+	}
+	ip[0] = m->calcount;
+
+	/* Last remision spot reading integration time */
+	if ((dp = m->data->get_doubles(m->data, &count, key_rpinttime)) == NULL || count < 1) {
+		a1logd(p->log,2,"Failed to access rpinttime log counter from EEPRom\n");
+		return I1PRO_INT_EEPROM_DATA_MISSING;
+	}
+	dp[0] = m->rpinttime;
+
+	/* Remission spot measure count */
+	if ((ip = m->data->get_ints(m->data, &count, key_rpcount)) == NULL || count < 1) {
+		a1logd(p->log,2,"Failed to access rpcount log counter from EEPRom\n");
+		return I1PRO_INT_EEPROM_DATA_MISSING;
+	}
+	ip[0] = m->rpcount;
+
+	/* Remission scan measure count (??) */
+	if ((ip = m->data->get_ints(m->data, &count, key_acount)) == NULL || count < 1) {
+		a1logd(p->log,2,"Failed to access acount log counter from EEPRom\n");
+		return I1PRO_INT_EEPROM_DATA_MISSING;
+	}
+	ip[0] = m->acount;
+
+	/* Total lamp usage time in seconds (??) */
+	if ((dp = m->data->get_doubles(m->data, &count, key_lampage)) == NULL || count < 1) {
+		a1logd(p->log,2,"Failed to access lampage log counter from EEPRom\n");
+		return I1PRO_INT_EEPROM_DATA_MISSING;
+	}
+	dp[0] = m->lampage;
+
+	a1logd(p->log,5,"i1pro_set_log_data done\n");
+
+	return I1PRO_OK;
+}
+
+/* Update the single remission calibration and instrument usage log */
+/* For RevA..D only! */
+i1pro_code i1pro_update_log(i1pro *p) {
+	i1pro_code ev = I1PRO_OK;
+#ifdef ENABLE_WRITE
+	i1proimp *m = (i1proimp *)p->m;
+	unsigned char *buf;		/* Buffer to write to EEProm */
+	unsigned int len;
+
+	a1logd(p->log,5,"i1pro_update_log:\n");
+
+	/* Copy refspot calibration and log data to EEProm data store */ 
+	if ((ev = i1pro_set_log_data(p)) != I1PRO_OK) {
+		a1logd(p->log,2,"i1pro_update_log i1pro_set_log_data failed\n");
+		return ev;
+	}
+
+	/* Compute checksum and serialise into buffer ready to write */
+	if ((ev = m->data->prep_section1(m->data, &buf, &len)) != I1PRO_OK) {
+		a1logd(p->log,2,"i1pro_update_log prep_section1 failed\n");
+		return ev;
+	}
+
+	/* First copy of log */
+	if ((ev = i1pro_writeEEProm(p, buf, 0x0000, len)) != I1PRO_OK) {
+		a1logd(p->log,2,"i1pro_update_log i1pro_writeEEProm 0x0000 failed\n");
+		return ev;
+	}
+	/* Second copy of log */
+	if ((ev = i1pro_writeEEProm(p, buf, 0x0800, len)) != I1PRO_OK) {
+		a1logd(p->log,2,"i1pro_update_log i1pro_writeEEProm 0x0800 failed\n");
+		return ev;
+	}
+	free(buf);
+
+	a1logd(p->log,5,"i1pro_update_log done\n");
+#else
+	a1logd(p->log,5,"i1pro_update_log: skipped as EPRom write is disabled\n");
+#endif
+
+	return ev;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Save the calibration for all modes, stored on local system */
+
+#ifdef ENABLE_NONVCAL
+
+/* non-volatile save/restor state */
+typedef struct {
+	int ef;					/* Error flag, 1 = write failed, 2 = close failed */
+	unsigned int chsum;		/* Checksum */
+	int nbytes;				/* Number of bytes checksummed */
+} i1pnonv;
+
+static void update_chsum(i1pnonv *x, unsigned char *p, int nn) {
+	int i;
+	for (i = 0; i < nn; i++, p++)
+		x->chsum = ((x->chsum << 13) | (x->chsum >> (32-13))) + *p;
+	x->nbytes += nn;
+}
+
+/* Write an array of ints to the file. Set the error flag to nz on error */
+static void write_ints(i1pnonv *x, FILE *fp, int *dp, int n) {
+
+	if (fwrite((void *)dp, sizeof(int), n, fp) != n) {
+		x->ef = 1;
+	} else {
+		update_chsum(x, (unsigned char *)dp, n * sizeof(int));
+	}
+}
+
+/* Write an array of doubles to the file. Set the error flag to nz on error */
+static void write_doubles(i1pnonv *x, FILE *fp, double *dp, int n) {
+
+	if (fwrite((void *)dp, sizeof(double), n, fp) != n) {
+		x->ef = 1;
+	} else {
+		update_chsum(x, (unsigned char *)dp, n * sizeof(double));
+	}
+}
+
+/* Write an array of time_t's to the file. Set the error flag to nz on error */
+/* (This will cause file checksum fail if different executables on the same */
+/*  system have different time_t values) */
+static void write_time_ts(i1pnonv *x, FILE *fp, time_t *dp, int n) {
+
+	if (fwrite((void *)dp, sizeof(time_t), n, fp) != n) {
+		x->ef = 1;
+	} else {
+		update_chsum(x, (unsigned char *)dp, n * sizeof(time_t));
+	}
+}
+
+/* Read an array of ints from the file. Set the error flag to nz on error */
+static void read_ints(i1pnonv *x, FILE *fp, int *dp, int n) {
+
+	if (fread((void *)dp, sizeof(int), n, fp) != n) {
+		x->ef = 1;
+	} else {
+		update_chsum(x, (unsigned char *)dp, n * sizeof(int));
+	}
+}
+
+/* Read an array of doubles from the file. Set the error flag to nz on error */
+static void read_doubles(i1pnonv *x, FILE *fp, double *dp, int n) {
+
+	if (fread((void *)dp, sizeof(double), n, fp) != n) {
+		x->ef = 1;
+	} else {
+		update_chsum(x, (unsigned char *)dp, n * sizeof(double));
+	}
+}
+
+/* Read an array of time_t's from the file. Set the error flag to nz on error */
+/* (This will cause file checksum fail if different executables on the same */
+/*  system have different time_t values) */
+static void read_time_ts(i1pnonv *x, FILE *fp, time_t *dp, int n) {
+
+	if (fread((void *)dp, sizeof(time_t), n, fp) != n) {
+		x->ef = 1;
+	} else {
+		update_chsum(x, (unsigned char *)dp, n * sizeof(time_t));
+	}
+}
+
+i1pro_code i1pro_save_calibration(i1pro *p) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_code ev = I1PRO_OK;
+	i1pro_state *s;
+	int i;
+	char nmode[10];
+	char cal_name[100];		/* Name */
+	char **cal_paths = NULL;
+	int no_paths = 0;
+	FILE *fp;
+	i1pnonv x;
+	int ss;
+	int argyllversion = ARGYLL_VERSION;
+
+	strcpy(nmode, "w");
+#if !defined(O_CREAT) && !defined(_O_CREAT)
+# error "Need to #include fcntl.h!"
+#endif
+#if defined(O_BINARY) || defined(_O_BINARY)
+	strcat(nmode, "b");
+#endif
+
+	/* Create the file name */
+	sprintf(cal_name, "ArgyllCMS/.i1p_%d.cal", m->serno);
+	if ((no_paths = xdg_bds(NULL, &cal_paths, xdg_cache, xdg_write, xdg_user, cal_name)) < 1) {
+		a1logd(p->log,1,"i1pro_save_calibration xdg_bds returned no paths\n");
+		return I1PRO_INT_CAL_SAVE;
+	}
+
+	a1logd(p->log,2,"i1pro_save_calibration saving to file '%s'\n",cal_paths[0]);
+
+	if (create_parent_directories(cal_paths[0])
+	 || (fp = fopen(cal_paths[0], nmode)) == NULL) {
+		a1logd(p->log,2,"i1pro_save_calibration failed to open file for writing\n");
+		xdg_free(cal_paths, no_paths);
+		return I1PRO_INT_CAL_SAVE;
+	}
+	
+	x.ef = 0;
+	x.chsum = 0;
+	x.nbytes = 0;
+
+	/* A crude structure signature */
+	ss = sizeof(i1pro_state) + sizeof(i1proimp);
+
+	/* Some file identification */
+	write_ints(&x, fp, &argyllversion, 1);
+	write_ints(&x, fp, &ss, 1);
+	write_ints(&x, fp, &m->serno, 1);
+	write_ints(&x, fp, (int *)&m->nraw, 1);
+	write_ints(&x, fp, (int *)&m->nwav[0], 1);
+	write_ints(&x, fp, (int *)&m->nwav[1], 1);
+
+	/* For each mode, save the calibration if it's valid */
+	for (i = 0; i < i1p_no_modes; i++) {
+		s = &m->ms[i];
+
+		/* Mode identification */
+		write_ints(&x, fp, &s->emiss, 1);
+		write_ints(&x, fp, &s->trans, 1);
+		write_ints(&x, fp, &s->reflective, 1);
+		write_ints(&x, fp, &s->scan, 1);
+		write_ints(&x, fp, &s->flash, 1);
+		write_ints(&x, fp, &s->ambient, 1);
+		write_ints(&x, fp, &s->adaptive, 1);
+
+		/* Configuration calibration is valid for */
+		write_ints(&x, fp, &s->gainmode, 1);
+		write_doubles(&x, fp, &s->inttime, 1);
+
+		/* Calibration information */
+		write_ints(&x, fp, &s->wl_valid, 1);
+		write_time_ts(&x, fp, &s->wldate, 1);
+		write_doubles(&x, fp, &s->wl_led_off, 1);
+		write_ints(&x, fp, &s->dark_valid, 1);
+		write_time_ts(&x, fp, &s->ddate, 1);
+		write_doubles(&x, fp, &s->dark_int_time, 1);
+		write_doubles(&x, fp, s->dark_data-1, m->nraw+1);
+		write_doubles(&x, fp, &s->dark_int_time2, 1);
+		write_doubles(&x, fp, s->dark_data2-1, m->nraw+1);
+		write_doubles(&x, fp, &s->dark_int_time3, 1);
+		write_doubles(&x, fp, s->dark_data3-1, m->nraw+1);
+		write_ints(&x, fp, &s->dark_gain_mode, 1);
+
+		if (!s->emiss) {
+			write_ints(&x, fp, &s->cal_valid, 1);
+			write_time_ts(&x, fp, &s->cfdate, 1);
+			write_doubles(&x, fp, s->cal_factor[0], m->nwav[0]);
+			write_doubles(&x, fp, s->cal_factor[1], m->nwav[1]);
+			write_doubles(&x, fp, s->white_data-1, m->nraw+1);
+		}
+		
+		write_ints(&x, fp, &s->idark_valid, 1);
+		write_time_ts(&x, fp, &s->iddate, 1);
+		write_doubles(&x, fp, s->idark_int_time, 4);
+		write_doubles(&x, fp, s->idark_data[0]-1, m->nraw+1);
+		write_doubles(&x, fp, s->idark_data[1]-1, m->nraw+1);
+		write_doubles(&x, fp, s->idark_data[2]-1, m->nraw+1);
+		write_doubles(&x, fp, s->idark_data[3]-1, m->nraw+1);
+	}
+
+	a1logd(p->log,3,"nbytes = %d, Checkum = 0x%x\n",x.nbytes,x.chsum);
+	write_ints(&x, fp, (int *)&x.chsum, 1);
+
+	if (fclose(fp) != 0)
+		x.ef = 2;
+
+	if (x.ef != 0) {
+		a1logd(p->log,2,"Writing calibration file failed with %d\n",x.ef);
+		delete_file(cal_paths[0]);
+		return I1PRO_INT_CAL_SAVE;
+	} else {
+		a1logd(p->log,2,"Writing calibration file succeeded\n");
+	}
+	xdg_free(cal_paths, no_paths);
+
+	return ev;
+}
+
+/* Restore the all modes calibration from the local system */
+i1pro_code i1pro_restore_calibration(i1pro *p) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_code ev = I1PRO_OK;
+	i1pro_state *s, ts;
+	int i, j;
+	char nmode[10];
+	char cal_name[100];		/* Name */
+	char **cal_paths = NULL;
+	int no_paths = 0;
+	FILE *fp;
+	i1pnonv x;
+	int argyllversion;
+	int ss, serno, nraw, nwav0, nwav1, nbytes, chsum1, chsum2;
+
+	strcpy(nmode, "r");
+#if !defined(O_CREAT) && !defined(_O_CREAT)
+# error "Need to #include fcntl.h!"
+#endif
+#if defined(O_BINARY) || defined(_O_BINARY)
+	strcat(nmode, "b");
+#endif
+	/* Create the file name */
+	sprintf(cal_name, "ArgyllCMS/.i1p_%d.cal" SSEPS "color/.i1p_%d.cal", m->serno, m->serno);
+	if ((no_paths = xdg_bds(NULL, &cal_paths, xdg_cache, xdg_read, xdg_user, cal_name)) < 1) {
+		a1logd(p->log,2,"i1pro_restore_calibration xdg_bds failed to locate file'\n");
+		return I1PRO_INT_CAL_RESTORE;
+	}
+
+	a1logd(p->log,2,"i1pro_restore_calibration restoring from file '%s'\n",cal_paths[0]);
+
+	/* Check the last modification time */
+	{
+		struct sys_stat sbuf;
+
+		if (sys_stat(cal_paths[0], &sbuf) == 0) {
+			m->lo_secs = time(NULL) - sbuf.st_mtime;
+			a1logd(p->log,2,"i1pro_restore_calibration: %d secs from instrument last open\n",m->lo_secs);
+		} else {
+			a1logd(p->log,2,"i1pro_restore_calibration: stat on file failed\n");
+		}
+	}
+
+	if ((fp = fopen(cal_paths[0], nmode)) == NULL) {
+		a1logd(p->log,2,"i1pro_restore_calibration failed to open file for reading\n");
+		xdg_free(cal_paths, no_paths);
+		return I1PRO_INT_CAL_RESTORE;
+	}
+
+	x.ef = 0;
+	x.chsum = 0;
+	x.nbytes = 0;
+
+	/* Check the file identification */
+	read_ints(&x, fp, &argyllversion, 1);
+	read_ints(&x, fp, &ss, 1);
+	read_ints(&x, fp, &serno, 1);
+	read_ints(&x, fp, &nraw, 1);
+	read_ints(&x, fp, &nwav0, 1);
+	read_ints(&x, fp, &nwav1, 1);
+	if (x.ef != 0
+	 || argyllversion != ARGYLL_VERSION
+	 || ss != (sizeof(i1pro_state) + sizeof(i1proimp))
+	 || serno != m->serno
+	 || nraw != m->nraw
+	 || nwav0 != m->nwav[0]
+	 || nwav1 != m->nwav[1]) {
+		a1logd(p->log,2,"Identification didn't verify\n");
+		goto reserr;
+	}
+
+	/* Do a dummy read to check the checksum */
+	for (i = 0; i < i1p_no_modes; i++) {
+		int di;
+		double dd;
+		time_t dt;
+		int emiss, trans, reflective, ambient, scan, flash, adaptive;
+
+		s = &m->ms[i];
+
+		/* Mode identification */
+		read_ints(&x, fp, &emiss, 1);
+		read_ints(&x, fp, &trans, 1);
+		read_ints(&x, fp, &reflective, 1);
+		read_ints(&x, fp, &scan, 1);
+		read_ints(&x, fp, &flash, 1);
+		read_ints(&x, fp, &ambient, 1);
+		read_ints(&x, fp, &adaptive, 1);
+
+		/* Configuration calibration is valid for */
+		read_ints(&x, fp, &di, 1);
+		read_doubles(&x, fp, &dd, 1);
+
+		/* Calibration information */
+		read_ints(&x, fp, &di, 1);
+		read_time_ts(&x, fp, &dt, 1);
+		read_doubles(&x, fp, &dd, 1);
+
+		read_ints(&x, fp, &di, 1);
+		read_time_ts(&x, fp, &dt, 1);
+		read_doubles(&x, fp, &dd, 1);
+		for (j = -1; j < m->nraw; j++)
+			read_doubles(&x, fp, &dd, 1);
+		read_doubles(&x, fp, &dd, 1);
+		for (j = -1; j < m->nraw; j++)
+			read_doubles(&x, fp, &dd, 1);
+		read_doubles(&x, fp, &dd, 1);
+		for (j = -1; j < m->nraw; j++)
+			read_doubles(&x, fp, &dd, 1);
+		read_ints(&x, fp, &di, 1);
+
+		if (!s->emiss) {
+			read_ints(&x, fp, &di, 1);
+			read_time_ts(&x, fp, &dt, 1);
+			for (j = 0; j < m->nwav[0]; j++)
+				read_doubles(&x, fp, &dd, 1);
+			for (j = 0; j < m->nwav[1]; j++)
+				read_doubles(&x, fp, &dd, 1);
+			for (j = -1; j < m->nraw; j++)
+				read_doubles(&x, fp, &dd, 1);
+		}
+		
+		read_ints(&x, fp, &di, 1);
+		read_time_ts(&x, fp, &dt, 1);
+		for (j = 0; j < 4; j++)
+			read_doubles(&x, fp, &dd, 1);
+		for (j = -1; j < m->nraw; j++)
+			read_doubles(&x, fp, &dd, 1);
+		for (j = -1; j < m->nraw; j++)
+			read_doubles(&x, fp, &dd, 1);
+		for (j = -1; j < m->nraw; j++)
+			read_doubles(&x, fp, &dd, 1);
+		for (j = -1; j < m->nraw; j++)
+			read_doubles(&x, fp, &dd, 1);
+	}
+
+	chsum1 = x.chsum;
+	nbytes = x.nbytes;
+	read_ints(&x, fp, &chsum2, 1);
+	
+	if (x.ef != 0
+	 || chsum1 != chsum2) {
+		a1logd(p->log,2,"Checksum didn't verify, bytes %d, got 0x%x, expected 0x%x\n",nbytes,chsum1, chsum2);
+		goto reserr;
+	}
+
+	rewind(fp);
+	x.ef = 0;
+	x.chsum = 0;
+	x.nbytes = 0;
+
+	/* Allocate space in temp structure */
+
+	ts.dark_data = dvectorz(-1, m->nraw-1);  
+	ts.dark_data2 = dvectorz(-1, m->nraw-1);  
+	ts.dark_data3 = dvectorz(-1, m->nraw-1);  
+	ts.cal_factor[0] = dvectorz(0, m->nwav[0]-1);
+	ts.cal_factor[1] = dvectorz(0, m->nwav[1]-1);
+	ts.white_data = dvectorz(-1, m->nraw-1);
+	ts.idark_data = dmatrixz(0, 3, -1, m->nraw-1);  
+
+	/* Read the identification */
+	read_ints(&x, fp, &argyllversion, 1);
+	read_ints(&x, fp, &ss, 1);
+	read_ints(&x, fp, &m->serno, 1);
+	read_ints(&x, fp, (int *)&m->nraw, 1);
+	read_ints(&x, fp, (int *)&m->nwav[0], 1);
+	read_ints(&x, fp, (int *)&m->nwav[1], 1);
+
+	/* For each mode, restore the calibration if it's valid */
+	for (i = 0; i < i1p_no_modes; i++) {
+		s = &m->ms[i];
+
+		/* Mode identification */
+		read_ints(&x, fp, &ts.emiss, 1);
+		read_ints(&x, fp, &ts.trans, 1);
+		read_ints(&x, fp, &ts.reflective, 1);
+		read_ints(&x, fp, &ts.scan, 1);
+		read_ints(&x, fp, &ts.flash, 1);
+		read_ints(&x, fp, &ts.ambient, 1);
+		read_ints(&x, fp, &ts.adaptive, 1);
+
+		/* Configuration calibration is valid for */
+		read_ints(&x, fp, &ts.gainmode, 1);
+		read_doubles(&x, fp, &ts.inttime, 1);
+
+		/* Calibration information: */
+
+		/* Wavelength */
+		read_ints(&x, fp, &ts.wl_valid, 1);
+		read_time_ts(&x, fp, &ts.wldate, 1);
+		read_doubles(&x, fp, &ts.wl_led_off, 1);
+
+		/* Static Dark */
+		read_ints(&x, fp, &ts.dark_valid, 1);
+		read_time_ts(&x, fp, &ts.ddate, 1);
+		read_doubles(&x, fp, &ts.dark_int_time, 1);
+		read_doubles(&x, fp, ts.dark_data-1, m->nraw+1);
+		read_doubles(&x, fp, &ts.dark_int_time2, 1);
+		read_doubles(&x, fp, ts.dark_data2-1, m->nraw+1);
+		read_doubles(&x, fp, &ts.dark_int_time3, 1);
+		read_doubles(&x, fp, ts.dark_data3-1, m->nraw+1);
+		read_ints(&x, fp, &ts.dark_gain_mode, 1);
+
+		if (!ts.emiss) {
+			/* Reflective */
+			read_ints(&x, fp, &ts.cal_valid, 1);
+			read_time_ts(&x, fp, &ts.cfdate, 1);
+			read_doubles(&x, fp, ts.cal_factor[0], m->nwav[0]);
+			read_doubles(&x, fp, ts.cal_factor[1], m->nwav[1]);
+			read_doubles(&x, fp, ts.white_data-1, m->nraw+1);
+		}
+		
+		/* Adaptive Dark */
+		read_ints(&x, fp, &ts.idark_valid, 1);
+		read_time_ts(&x, fp, &ts.iddate, 1);
+		read_doubles(&x, fp, ts.idark_int_time, 4);
+		read_doubles(&x, fp, ts.idark_data[0]-1, m->nraw+1);
+		read_doubles(&x, fp, ts.idark_data[1]-1, m->nraw+1);
+		read_doubles(&x, fp, ts.idark_data[2]-1, m->nraw+1);
+		read_doubles(&x, fp, ts.idark_data[3]-1, m->nraw+1);
+
+		/* If the configuration for this mode matches */
+		/* that of the calibration, restore the calibration */
+		/* for this mode. */
+		if (x.ef == 0				/* No read error */
+		 &&	s->emiss == ts.emiss
+		 && s->trans == ts.trans
+		 && s->reflective == ts.reflective
+		 && s->scan == ts.scan
+		 && s->flash == ts.flash
+		 && s->ambient == ts.ambient
+		 && s->adaptive == ts.adaptive
+		 && (s->adaptive || fabs(s->inttime - ts.inttime) < 0.01)
+		 && (s->adaptive || fabs(s->dark_int_time - ts.dark_int_time) < 0.01)
+		 && (s->adaptive || fabs(s->dark_int_time2 - ts.dark_int_time2) < 0.01)
+		 && (s->adaptive || fabs(s->dark_int_time3 - ts.dark_int_time3) < 0.01)
+		 && (!s->adaptive || fabs(s->idark_int_time[0] - ts.idark_int_time[0]) < 0.01)
+		 && (!s->adaptive || fabs(s->idark_int_time[1] - ts.idark_int_time[1]) < 0.01)
+		 && (!s->adaptive || fabs(s->idark_int_time[2] - ts.idark_int_time[2]) < 0.01)
+		 && (!s->adaptive || fabs(s->idark_int_time[3] - ts.idark_int_time[3]) < 0.01)
+		) {
+			/* Copy all the fields read above */
+			s->emiss = ts.emiss;
+			s->trans = ts.trans;
+			s->reflective = ts.reflective;
+			s->scan = ts.scan;
+			s->flash = ts.flash;
+			s->ambient = ts.ambient;
+			s->adaptive = ts.adaptive;
+
+			s->gainmode = ts.gainmode;
+			s->inttime = ts.inttime;
+
+			s->wl_valid = ts.wl_valid;
+			s->wldate = ts.wldate;
+			s->wl_led_off = ts.wl_led_off;
+
+			s->dark_valid = ts.dark_valid;
+			s->ddate = ts.ddate;
+			s->dark_int_time = ts.dark_int_time;
+			for (j = -1; j < m->nraw; j++)
+				s->dark_data[j] = ts.dark_data[j];
+			s->dark_int_time2 = ts.dark_int_time2;
+			for (j = -1; j < m->nraw; j++)
+				s->dark_data2[j] = ts.dark_data2[j];
+			s->dark_int_time3 = ts.dark_int_time3;
+			for (j = -1; j < m->nraw; j++)
+				s->dark_data3[j] = ts.dark_data3[j];
+			s->dark_gain_mode = ts.dark_gain_mode;
+			if (!ts.emiss) {
+				s->cal_valid = ts.cal_valid;
+				s->cfdate = ts.cfdate;
+				for (j = 0; j < m->nwav[0]; j++)
+					s->cal_factor[0][j] = ts.cal_factor[0][j];
+				for (j = 0; j < m->nwav[1]; j++)
+					s->cal_factor[1][j] = ts.cal_factor[1][j];
+				for (j = -1; j < m->nraw; j++)
+					s->white_data[j] = ts.white_data[j];
+			}
+			s->idark_valid = ts.idark_valid;
+			s->iddate = ts.iddate;
+			for (j = 0; j < 4; j++)
+				s->idark_int_time[j] = ts.idark_int_time[j];
+			for (j = -1; j < m->nraw; j++)
+				s->idark_data[0][j] = ts.idark_data[0][j];
+			for (j = -1; j < m->nraw; j++)
+				s->idark_data[1][j] = ts.idark_data[1][j];
+			for (j = -1; j < m->nraw; j++)
+				s->idark_data[2][j] = ts.idark_data[2][j];
+			for (j = -1; j < m->nraw; j++)
+				s->idark_data[3][j] = ts.idark_data[3][j];
+
+		} else {
+			a1logd(p->log,2,"Not restoring cal for mode %d since params don't match:\n",i);
+			a1logd(p->log,2,"emis = %d : %d, trans = %d : %d, ref = %d : %d\n",s->emiss,ts.emiss,s->trans,ts.trans,s->reflective,ts.reflective);
+			a1logd(p->log,2,"scan = %d : %d, flash = %d : %d, ambi = %d : %d, adapt = %d : %d\n",s->scan,ts.scan,s->flash,ts.flash,s->ambient,ts.ambient,s->adaptive,ts.adaptive);
+			a1logd(p->log,2,"inttime = %f : %f\n",s->inttime,ts.inttime);
+			a1logd(p->log,2,"darkit1 = %f : %f, 2 = %f : %f, 3 = %f : %f\n",s->dark_int_time,ts.dark_int_time,s->dark_int_time2,ts.dark_int_time2,s->dark_int_time3,ts.dark_int_time3);
+			a1logd(p->log,2,"idarkit0 = %f : %f, 1 = %f : %f, 2 = %f : %f, 3 = %f : %f\n",s->idark_int_time[0],ts.idark_int_time[0],s->idark_int_time[1],ts.idark_int_time[1],s->idark_int_time[2],ts.idark_int_time[2],s->idark_int_time[3],ts.idark_int_time[3]);
+		}
+	}
+
+	/* Free up temporary space */
+	free_dvector(ts.dark_data, -1, m->nraw-1);  
+	free_dvector(ts.dark_data2, -1, m->nraw-1);  
+	free_dvector(ts.dark_data3, -1, m->nraw-1);  
+	free_dvector(ts.white_data, -1, m->nraw-1);
+	free_dmatrix(ts.idark_data, 0, 3, -1, m->nraw-1);  
+
+	free_dvector(ts.cal_factor[0], 0, m->nwav[0]-1);
+	free_dvector(ts.cal_factor[1], 0, m->nwav[1]-1);
+
+	a1logd(p->log,5,"i1pro_restore_calibration done\n");
+ reserr:;
+
+	fclose(fp);
+	xdg_free(cal_paths, no_paths);
+
+	return ev;
+}
+
+i1pro_code i1pro_touch_calibration(i1pro *p) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_code ev = I1PRO_OK;
+	char cal_name[100];		/* Name */
+	char **cal_paths = NULL;
+	int no_paths = 0;
+	int rv;
+
+	/* Locate the file name */
+	sprintf(cal_name, "ArgyllCMS/.i1p_%d.cal" SSEPS "color/.i1p_%d.cal", m->serno, m->serno);
+	if ((no_paths = xdg_bds(NULL, &cal_paths, xdg_cache, xdg_read, xdg_user, cal_name)) < 1) {
+		a1logd(p->log,2,"i1pro_restore_calibration xdg_bds failed to locate file'\n");
+		return I1PRO_INT_CAL_TOUCH;
+	}
+
+	a1logd(p->log,2,"i1pro_touch_calibration touching file '%s'\n",cal_paths[0]);
+
+	if ((rv = sys_utime(cal_paths[0], NULL)) != 0) {
+		a1logd(p->log,2,"i1pro_touch_calibration failed with %d\n",rv);
+		xdg_free(cal_paths, no_paths);
+		return I1PRO_INT_CAL_TOUCH;
+	}
+	xdg_free(cal_paths, no_paths);
+
+	return ev;
+}
+
+#endif /* ENABLE_NONVCAL */
+
+/* ============================================================ */
+/* Intermediate routines  - composite commands/processing */
+
+/* Some sort of configuration needed get instrument ready. */
+/* Does it have a sleep mode that we need to deal with ?? */
+/* Note this always does a reset. */
+i1pro_code
+i1pro_establish_high_power(i1pro *p) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	int i;
+
+	/* Get the current misc. status */
+	if ((ev = i1pro_getmisc(p, &m->fwrev, NULL, &m->maxpve, NULL, &m->powmode)) != I1PRO_OK)
+		return ev; 
+	
+	if (m->powmode != 8) {		/* In high power mode */
+		if ((ev = i1pro_reset(p, 0x1f)) != I1PRO_OK)
+			return ev;
+
+		return I1PRO_OK;
+	}
+
+	a1logd(p->log,4,"Switching to high power mode\n");
+
+	/* Switch to high power mode */
+	if ((ev = i1pro_reset(p, 1)) != I1PRO_OK)
+		return ev;
+
+	/* Wait up to 1.5 seconds for it return high power indication */
+	for (i = 0; i < 15; i++) {
+
+		/* Get the current misc. status */
+		if ((ev = i1pro_getmisc(p, &m->fwrev, NULL, &m->maxpve, NULL, &m->powmode)) != I1PRO_OK)
+			return ev; 
+		
+		if (m->powmode != 8) {		/* In high power mode */
+			if ((ev = i1pro_reset(p, 0x1f)) != I1PRO_OK)
+				return ev;
+	
+			return I1PRO_OK;
+		}
+
+		msec_sleep(100);
+	}
+
+	/* Failed to switch into high power mode */
+	return I1PRO_HW_HIGHPOWERFAIL;
+}
+
+/* Take a dark reference measurement - part 1 */
+i1pro_code i1pro_dark_measure_1(
+	i1pro *p,
+	int nummeas,			/* Number of readings to take */
+	double *inttime, 		/* Integration time to use/used */
+	int gainmode,			/* Gain mode to use, 0 = normal, 1 = high */
+	unsigned char *buf,		/* USB reading buffer to use */
+	unsigned int bsize		/* Size of buffer */
+) {
+	i1pro_code ev = I1PRO_OK;
+
+	if (nummeas <= 0)
+		return I1PRO_INT_ZEROMEASURES;
+		
+	if ((ev = i1pro_trigger_one_measure(p, nummeas, inttime, gainmode, i1p_dark_cal)) != I1PRO_OK)
+		return ev;
+
+	if ((ev = i1pro_readmeasurement(p, nummeas, 0, buf, bsize, NULL, i1p_dark_cal)) != I1PRO_OK)
+		return ev;
+
+	return ev;
+}
+
+/* Take a dark reference measurement - part 2 */
+i1pro_code i1pro_dark_measure_2(
+	i1pro *p,
+	double *absraw,			/* Return array [-1 nraw] of absraw values */
+	int nummeas,			/* Number of readings to take */
+	double inttime, 		/* Integration time to use/used */
+	int gainmode,			/* Gain mode to use, 0 = normal, 1 = high */
+	unsigned char *buf,		/* raw USB reading buffer to process */
+	unsigned int bsize		/* Buffer size to process */
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	double **multimes;		/* Multiple measurement results */
+	double sensavg;			/* Overall average of sensor readings */
+	double satthresh;		/* Saturation threshold */
+	double darkthresh;		/* Dark threshold */
+	int rv;
+
+	multimes = dmatrix(0, nummeas-1, -1, m->nraw-1);	/* -1 is RevE shielded cells values */
+
+	if (gainmode == 0)
+		satthresh = m->sens_sat0;
+	else
+		satthresh = m->sens_sat1;
+
+	darkthresh = m->sens_dark + inttime * 900.0;
+	if (gainmode)
+		darkthresh *= m->highgain;
+
+	/* Take a buffer full of raw readings, and convert them to */
+	/* absolute linearised sensor values. */
+	if ((ev = i1pro_sens_to_absraw(p, multimes, buf, nummeas, inttime, gainmode, &darkthresh))
+		                                                                          != I1PRO_OK) {
+		return ev;
+	}
+
+	satthresh = i1pro_raw_to_absraw(p, satthresh, inttime, gainmode);  
+	darkthresh = i1pro_raw_to_absraw(p, darkthresh, inttime, gainmode);  
+
+	/* Average a set of measurements into one. */
+	/* Return zero if readings are consistent and not saturated. */
+	/* Return nz with bit 1 set if the readings are not consistent */
+	/* Return nz with bit 2 set if the readings are saturated */
+	/* Return the highest individual element. */
+	/* Return the overall average. */
+	rv = i1pro_average_multimeas(p, absraw, multimes, nummeas, NULL, &sensavg,
+	                                                       satthresh, darkthresh);     
+	free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+
+#ifdef PLOT_DEBUG
+	printf("Average absolute sensor readings, average = %f, satthresh %f:\n",sensavg, satthresh);
+	plot_raw(absraw);
+#endif
+
+	if (rv & 1)
+		return I1PRO_RD_DARKREADINCONS;
+
+	if (rv & 2)
+		return I1PRO_RD_SENSORSATURATED;
+
+	a1logd(p->log,3,"Dark threshold = %f\n",darkthresh);
+
+	if (sensavg > (2.0 * darkthresh))
+		return I1PRO_RD_DARKNOTVALID;
+
+	return ev;
+}
+
+#ifdef DUMP_DARKM
+int ddumpdarkm = 0;
+#endif
+
+/* Take a dark reference measurement (combined parts 1 & 2) */
+i1pro_code i1pro_dark_measure(
+	i1pro *p,
+	double *absraw,			/* Return array [-1 nraw] of absraw values */
+	int nummeas,			/* Number of readings to take */
+	double *inttime, 		/* Integration time to use/used */
+	int gainmode			/* Gain mode to use, 0 = normal, 1 = high */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_code ev = I1PRO_OK;
+	unsigned char *buf;		/* Raw USB reading buffer */
+	unsigned int bsize;
+
+	bsize = m->nsen * 2  * nummeas;
+	if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+		a1logd(p->log,1,"i1pro_dark_measure malloc %d bytes failed (8)\n",bsize);
+		return I1PRO_INT_MALLOC;
+	}
+
+	if ((ev = i1pro_dark_measure_1(p, nummeas, inttime, gainmode, buf, bsize)) != I1PRO_OK) {
+		free(buf);
+		return ev;
+	}
+
+	if ((ev = i1pro_dark_measure_2(p, absraw,
+		                 nummeas, *inttime, gainmode, buf, bsize)) != I1PRO_OK) {
+		free(buf);
+		return ev;
+	}
+	free(buf);
+
+#ifdef DUMP_DARKM
+	/* Dump raw dark readings to a file "i1pddump.txt" */
+	if (ddumpdarkm) {
+		int j;
+		FILE *fp;
+		
+		if ((fp = fopen("i1pddump.txt", "a")) == NULL)
+			a1logw(p->log,"Unable to open debug file i1pddump.txt\n");
+		else {
+
+			fprintf(fp, "\nDark measure: nummeas %d, inttime %f, gainmode %d, darkcells %f\n",nummeas,*inttime,gainmode, absraw[-1]);
+			fprintf(fp,"\t\t\t{ ");
+			for (j = 0; j < (m->nraw-1); j++)
+				fprintf(fp, "%f, ",absraw[j]);
+			fprintf(fp, "%f },\n",absraw[j]);
+			fclose(fp);
+		}
+	}
+#endif
+
+	return ev;
+}
+
+
+/* Take a white reference measurement */
+/* (Subtracts black and processes into wavelenths) */
+i1pro_code i1pro_whitemeasure(
+	i1pro *p,
+	double *abswav0,		/* Return array [nwav[0]] of abswav values (may be NULL) */
+	double *abswav1,		/* Return array [nwav[1]] of abswav values (if hr_init, may be NULL) */
+	double *absraw,			/* Return array [-1 nraw] of absraw values */
+	double *optscale,		/* Factor to scale gain/int time by to make optimal (may be NULL) */
+	int nummeas,			/* Number of readings to take */
+	double *inttime, 		/* Integration time to use/used */
+	int gainmode,			/* Gain mode to use, 0 = normal, 1 = high */
+	double targoscale,		/* Optimal reading scale factor */
+	int ltocmode			/* 1 = Lamp turn on compensation mode */ 
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	unsigned char *buf;		/* Raw USB reading buffer */
+	unsigned int bsize;
+	double **multimes;		/* Multiple measurement results */
+	double darkthresh;		/* Consitency threshold scale limit */
+	int rv;
+
+	a1logd(p->log,3,"i1pro_whitemeasure called \n");
+
+	darkthresh = m->sens_dark + *inttime * 900.0;		/* Default */
+	if (gainmode)
+		darkthresh *= m->highgain;
+
+	if (nummeas <= 0)
+		return I1PRO_INT_ZEROMEASURES;
+		
+	/* Allocate temporaries up front to avoid delay between trigger and read */
+	bsize = m->nsen * 2 * nummeas;
+	if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+		a1logd(p->log,1,"i1pro_whitemeasure malloc %d bytes failed (10)\n",bsize);
+		return I1PRO_INT_MALLOC;
+	}
+	multimes = dmatrix(0, nummeas-1, -1, m->nraw-1);
+
+	a1logd(p->log,3,"Triggering measurement cycle, nummeas %d, inttime %f, gainmode %d\n",
+	                                              nummeas, *inttime, gainmode);
+
+	if ((ev = i1pro_trigger_one_measure(p, nummeas, inttime, gainmode, i1p_cal)) != I1PRO_OK) {
+		free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+		free(buf);
+		return ev;
+	}
+
+	a1logd(p->log,4,"Gathering readings\n");
+
+	if ((ev = i1pro_readmeasurement(p, nummeas, 0, buf, bsize, NULL, i1p_cal)) != I1PRO_OK) {
+		free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+		free(buf);
+		return ev;
+	}
+
+	/* Take a buffer full of raw readings, and convert them to */
+	/* absolute linearised sensor values. */
+	if ((ev = i1pro_sens_to_absraw(p, multimes, buf, nummeas, *inttime, gainmode, &darkthresh))
+		                                                                          != I1PRO_OK) {
+		return ev;
+	}
+
+#ifdef PLOT_DEBUG
+	printf("Dark data:\n");
+	plot_raw(s->dark_data);
+#endif
+
+	/* Subtract the black level */
+	i1pro_sub_absraw(p, nummeas, *inttime, gainmode, multimes, s->dark_data);
+
+	/* Convert linearised white value into output wavelength white reference */
+	ev = i1pro_whitemeasure_3(p, abswav0, abswav1, absraw, optscale, nummeas,
+	                                      *inttime, gainmode, targoscale, multimes, darkthresh);
+
+	free(buf);
+	free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+
+	return ev;
+}
+
+/* Process a single raw white reference measurement */
+/* (Subtracts black and processes into wavelenths) */
+/* Used for restoring calibration from the EEProm */
+i1pro_code i1pro_whitemeasure_buf(
+	i1pro *p,
+	double *abswav0,		/* Return array [nwav[0]] of abswav values (may be NULL) */
+	double *abswav1,		/* Return array [nwav[1]] of abswav values (if hr_init, may be NULL) */
+	double *absraw,			/* Return array [-1 nraw] of absraw values */
+	double inttime, 		/* Integration time to used */
+	int gainmode,			/* Gain mode to use, 0 = normal, 1 = high */
+	unsigned char *buf		/* Raw buffer */
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	double *meas;			/* Multiple measurement results */
+	double darkthresh;		/* Consitency threshold scale limit */
+
+	a1logd(p->log,3,"i1pro_whitemeasure_buf called \n");
+
+	meas = dvector(-1, m->nraw-1);
+	
+	darkthresh = m->sens_dark + inttime * 900.0;	/* Default */
+	if (gainmode)
+		darkthresh *= m->highgain;
+
+	/* Take a buffer full of raw readings, and convert them to */
+	/* absolute linearised sensor values. */
+	if ((ev = i1pro_sens_to_absraw(p, &meas, buf, 1, inttime, gainmode, &darkthresh))
+		                                                                != I1PRO_OK) {
+		return ev;
+	}
+
+	/* Subtract the black level */
+	i1pro_sub_absraw(p, 1, inttime, gainmode, &meas, s->dark_data);
+
+	/* Convert linearised white value into output wavelength white reference */
+	ev = i1pro_whitemeasure_3(p, abswav0, abswav1, absraw, NULL, 1, inttime, gainmode,
+	                                                           0.0, &meas, darkthresh);
+
+	free_dvector(meas, -1, m->nraw-1);
+
+	return ev;
+}
+
+/* Take a white reference measurement - part 3 */
+/* Average, check, and convert to output wavelengths */
+i1pro_code i1pro_whitemeasure_3(
+	i1pro *p,
+	double *abswav0,		/* Return array [nwav[0]] of abswav values (may be NULL) */
+	double *abswav1,		/* Return array [nwav[1]] of abswav values (if hr_init, may be NULL) */
+	double *absraw,			/* Return array [-1 nraw] of absraw values */
+	double *optscale,		/* Factor to scale gain/int time by to make optimal (may be NULL) */
+	int nummeas,			/* Number of readings to take */
+	double inttime, 		/* Integration time to use/used */
+	int gainmode,			/* Gain mode to use, 0 = normal, 1 = high */
+	double targoscale,		/* Optimal reading scale factor */
+	double **multimes,		/* Multiple measurement results */
+	double darkthresh		/* Raw dark threshold */
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	double highest;			/* Highest of sensor readings */
+	double sensavg;			/* Overall average of sensor readings */
+	double satthresh;		/* Saturation threshold */
+	double opttarget;		/* Optimal sensor target */
+	int rv;
+
+	a1logd(p->log,3,"i1pro_whitemeasure_3 called \n");
+
+	if (gainmode == 0)
+		satthresh = m->sens_sat0;
+	else
+		satthresh = m->sens_sat1;
+	satthresh = i1pro_raw_to_absraw(p, satthresh, inttime, gainmode);  
+
+	darkthresh = i1pro_raw_to_absraw(p, darkthresh, inttime, gainmode);  
+
+	/* Average a set of measurements into one. */
+	/* Return zero if readings are consistent and not saturated. */
+	/* Return nz with bit 1 set if the readings are not consistent */
+	/* Return nz with bit 2 set if the readings are saturated */
+	/* Return the highest individual element. */
+	/* Return the overall average. */
+	rv = i1pro_average_multimeas(p, absraw, multimes, nummeas, &highest, &sensavg,
+	                                                           satthresh, darkthresh);     
+#ifdef PLOT_DEBUG
+	printf("Average absolute sensor readings, average = %f, satthresh %f:\n",sensavg, satthresh);
+	plot_raw(absraw);
+#endif
+
+#ifndef IGNORE_WHITE_INCONS
+	if (rv & 1) {
+		return I1PRO_RD_WHITEREADINCONS;
+	}
+#endif /* IGNORE_WHITE_INCONS */
+
+	if (rv & 2) {
+		return I1PRO_RD_SENSORSATURATED;
+	}
+
+	/* Convert an absraw array from raw wavelengths to output wavelenths */
+	if (abswav0 != NULL) {
+		i1pro_absraw_to_abswav(p, 0, s->reflective, 1, &abswav0, &absraw);
+
+#ifdef PLOT_DEBUG
+		printf("Converted to wavelengths std res:\n");
+		plot_wav(m, 0, abswav0);
+#endif
+	}
+
+#ifdef HIGH_RES
+	if (abswav1 != NULL && m->hr_inited) {
+		i1pro_absraw_to_abswav(p, 1, s->reflective, 1, &abswav1, &absraw);
+
+#ifdef PLOT_DEBUG
+		printf("Converted to wavelengths high res:\n");
+		plot_wav(m, 1, abswav1);
+#endif
+	}
+#endif /* HIGH_RES */
+
+	if (optscale != NULL) {
+		double lhighest = highest;
+
+		if (lhighest < 1.0)
+			lhighest = 1.0;
+
+		/* Compute correction factor to make sensor optimal */
+		opttarget = i1pro_raw_to_absraw(p, (double)m->sens_target, inttime, gainmode);  
+		opttarget *= targoscale;
+	
+	
+		a1logd(p->log,3,"Optimal target = %f, amount to scale = %f\n",opttarget, opttarget/lhighest);
+
+		*optscale = opttarget/lhighest; 
+	}
+
+	return ev;
+}
+
+/* Take a wavelength reference measurement */
+/* (Measure and subtracts black and convert to absraw) */
+i1pro_code i1pro2_wl_measure(
+	i1pro *p,
+	double *absraw,			/* Return array [-1 nraw] of absraw values */
+	double *optscale,		/* Factor to scale gain/int time by to make optimal (may be NULL) */
+	double *inttime, 		/* Integration time to use/used */
+	double targoscale		/* Optimal reading scale factor */
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	int nummeas = 1;		/* Number of measurements to take */
+	int gainmode = 0;		/* Gain mode to use, 0 = normal, 1 = high */
+	unsigned char *buf;		/* Raw USB reading buffer */
+	unsigned int bsize;
+	double *dark;			/* Dark reading */
+	double **multimes;		/* Measurement results */
+	double darkthresh;		/* Consitency threshold scale limit/reading dark cell values */
+	double highest;			/* Highest of sensor readings */
+	double sensavg;			/* Overall average of sensor readings */
+	double satthresh;		/* Saturation threshold */
+	double opttarget;		/* Optimal sensor target */
+	int rv;
+
+	a1logd(p->log,3,"i1pro2_wl_measure called \n");
+
+	/* Allocate temporaries up front to avoid delay between trigger and read */
+	bsize = m->nsen * 2;
+	if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+		a1logd(p->log,1,"i1pro2_wl_measure malloc %d bytes failed (10)\n",bsize);
+		return I1PRO_INT_MALLOC;
+	}
+
+	/* Do a dark reading at our integration time */
+	dark = dvector(-1, m->nraw-1);
+	multimes = dmatrix(0, nummeas-1, -1, m->nraw-1);
+
+	if ((ev = i1pro_dark_measure(p, dark, nummeas, inttime, gainmode)) != I1PRO_OK) {
+		free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+		free_dvector(dark, -1, m->nraw-1);
+		free(buf);
+		return ev;
+	}
+
+#ifdef PLOT_DEBUG
+	printf("Absraw dark data:\n");
+	plot_raw(dark);
+#endif
+
+	a1logd(p->log,3,"Triggering wl measurement cycle, inttime %f\n", *inttime);
+
+	if ((ev = i1pro_trigger_one_measure(p, nummeas, inttime, gainmode, i1p2_wl_cal)) != I1PRO_OK) {
+		free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+		free_dvector(dark, -1, m->nraw-1);
+		free(buf);
+		return ev;
+	}
+
+	a1logd(p->log,4,"Gathering readings\n");
+
+	if ((ev = i1pro_readmeasurement(p, nummeas, 0, buf, bsize, NULL, i1p2_wl_cal)) != I1PRO_OK) {
+		free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+		free_dvector(dark, -1, m->nraw-1);
+		free(buf);
+		return ev;
+	}
+
+	/* Take a buffer full of raw readings, and convert them to */
+	/* absolute linearised sensor values. */
+	if ((ev = i1pro_sens_to_absraw(p, multimes, buf, nummeas, *inttime, gainmode, &darkthresh))
+		                                                                           != I1PRO_OK) {
+		return ev;
+	}
+
+	/* Convert satthresh and darkthresh/dark_cell values to abs */
+	if (gainmode == 0)
+		satthresh = m->sens_sat0;
+	else
+		satthresh = m->sens_sat1;
+	satthresh = i1pro_raw_to_absraw(p, satthresh, *inttime, gainmode);  
+	darkthresh = i1pro_raw_to_absraw(p, darkthresh, *inttime, gainmode);  
+
+#ifdef PLOT_DEBUG
+	printf("Absraw WL data:\n");
+	plot_raw(multimes[0]);
+#endif
+
+	/* Subtract the black level */
+	i1pro_sub_absraw(p, nummeas, *inttime, gainmode, multimes, dark);
+
+#ifdef PLOT_DEBUG
+	printf("Absraw WL - black data:\n");
+	plot_raw(multimes[0]);
+#endif
+
+	/* Average a set of measurements into one. */
+	/* Return zero if readings are consistent and not saturated. */
+	/* Return nz with bit 1 set if the readings are not consistent */
+	/* Return nz with bit 2 set if the readings are saturated */
+	/* Return the highest individual element. */
+	/* Return the overall average. */
+	rv = i1pro_average_multimeas(p, absraw, multimes, 1, &highest, &sensavg,
+	                                                           satthresh, darkthresh);     
+#ifdef PLOT_DEBUG
+	printf("Average absolute sensor readings, average = %f, satthresh %f, absraw WL result:\n",sensavg, satthresh);
+	plot_raw(absraw);
+#endif
+
+#ifndef IGNORE_WHITE_INCONS
+	if (rv & 1) {
+		return I1PRO_RD_WHITEREADINCONS;
+	}
+#endif /* IGNORE_WHITE_INCONS */
+
+	if (rv & 2) {
+		return I1PRO_RD_SENSORSATURATED;
+	}
+
+	if (optscale != NULL) {
+		double lhighest = highest;
+
+		if (lhighest < 1.0)
+			lhighest = 1.0;
+
+		/* Compute correction factor to make sensor optimal */
+		opttarget = i1pro_raw_to_absraw(p, (double)m->sens_target, *inttime, gainmode);  
+		opttarget *= targoscale;
+	
+	
+		a1logd(p->log,3,"Optimal target = %f, amount to scale = %f\n",opttarget, opttarget/lhighest);
+
+		*optscale = opttarget/lhighest; 
+	}
+
+	free(buf);
+	free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+	free_dvector(dark, -1, m->nraw-1);
+
+	return ev;
+}
+
+/* Take a measurement reading using the current mode, part 1 */
+/* Converts to completely processed output readings. */
+/* (NOTE:- this can't be used for calibration, as it implements uv mode) */
+i1pro_code i1pro_read_patches_1(
+	i1pro *p,
+	int minnummeas,			/* Minimum number of measurements to take */
+	int maxnummeas,			/* Maximum number of measurements to allow for */
+	double *inttime, 		/* Integration time to use/used */
+	int gainmode,			/* Gain mode to use, 0 = normal, 1 = high */
+	int *nmeasuered,		/* Number actually measured */
+	unsigned char *buf,		/* Raw USB reading buffer */
+	unsigned int bsize
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	i1p_mmodif mmod = i1p_norm;
+	int rv = 0;
+
+	if (minnummeas <= 0)
+		return I1PRO_INT_ZEROMEASURES;
+	if (minnummeas > maxnummeas)
+		maxnummeas = minnummeas;
+		
+	if (m->uv_en)
+		mmod = i1p2_UV;
+
+	a1logd(p->log,3,"Triggering & gathering cycle, minnummeas %d, inttime %f, gainmode %d\n",
+	                                              minnummeas, *inttime, gainmode);
+
+	if ((ev = i1pro_trigger_one_measure(p, minnummeas, inttime, gainmode, mmod)) != I1PRO_OK) {
+		return ev;
+	}
+
+	if ((ev = i1pro_readmeasurement(p, minnummeas, m->c_measmodeflags & I1PRO_MMF_SCAN,
+	                                             buf, bsize, nmeasuered, mmod)) != I1PRO_OK) {
+		return ev;
+	}
+
+	return ev;
+}
+
+/* Take a measurement reading using the current mode, part 2 */
+/* Converts to completely processed output readings. */
+i1pro_code i1pro_read_patches_2(
+	i1pro *p,
+	double *duration,		/* Return flash duration */
+	double **specrd,		/* Return array [numpatches][nwav] of spectral reading values */
+	int numpatches,			/* Number of patches to return */
+	double inttime, 		/* Integration time to used */
+	int gainmode,			/* Gain mode useed, 0 = normal, 1 = high */
+	int nmeasuered,			/* Number actually measured */
+	unsigned char *buf,		/* Raw USB reading buffer */
+	unsigned int bsize
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	double **multimes;		/* Multiple measurement results [maxnummeas|nmeasuered][-1 nraw]*/
+	double **absraw;		/* Linearsised absolute sensor raw values [numpatches][-1 nraw]*/
+	double satthresh;		/* Saturation threshold */
+	double darkthresh;		/* Dark threshold for consistency scaling limit */
+	int rv = 0;
+
+	if (duration != NULL)
+		*duration = 0.0;	/* default value */
+
+	darkthresh = m->sens_dark + inttime * 900.0;		/* Default */
+	if (gainmode)
+		darkthresh *= m->highgain;
+
+	/* Allocate temporaries */
+	multimes = dmatrix(0, nmeasuered-1, -1, m->nraw-1);
+	absraw = dmatrix(0, numpatches-1, -1, m->nraw-1);
+
+	/* Take a buffer full of raw readings, and convert them to */
+	/* absolute linearised sensor values. */
+	if ((ev = i1pro_sens_to_absraw(p, multimes, buf, nmeasuered, inttime, gainmode, &darkthresh))
+		                                                                           != I1PRO_OK) {
+		return ev;
+	}
+
+	/* Subtract the black level */
+	i1pro_sub_absraw(p, nmeasuered, inttime, gainmode, multimes, s->dark_data);
+
+#ifdef DUMP_SCANV
+	/* Dump raw scan readings to a file "i1pdump.txt" */
+	{
+		int i, j;
+		FILE *fp;
+		
+		if ((fp = fopen("i1pdump.txt", "w")) == NULL)
+			a1logw(p->log,"Unable to open debug file i1pdump.txt\n");
+		else {
+			for (i = 0; i < nmeasuered; i++) {
+				fprintf(fp, "%d	",i);
+				for (j = 0; j < m->nraw; j++) {
+					fprintf(fp, "%f	",multimes[i][j]);
+				}
+				fprintf(fp,"\n");
+			}
+			fclose(fp);
+		}
+	}
+#endif
+	if (gainmode == 0)
+		satthresh = m->sens_sat0;
+	else
+		satthresh = m->sens_sat1;
+	satthresh = i1pro_raw_to_absraw(p, satthresh, inttime, gainmode);  
+
+	darkthresh = i1pro_raw_to_absraw(p, darkthresh, inttime, gainmode);  
+
+	if (!s->scan) {
+		if (numpatches != 1) {
+			free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+			free_dmatrix(multimes, 0, nmeasuered-1, -1, m->nraw-1);
+			a1logd(p->log,2,"i1pro_read_patches_2 spot read failed because numpatches != 1\n");
+			return I1PRO_INT_WRONGPATCHES;
+		}
+
+		/* Average a set of measurements into one. */
+		/* Return zero if readings are consistent and not saturated. */
+		/* Return nz with bit 1 set if the readings are not consistent */
+		/* Return nz with bit 2 set if the readings are saturated */
+		/* Return the highest individual element. */
+		/* Return the overall average. */
+		rv = i1pro_average_multimeas(p, absraw[0], multimes, nmeasuered, NULL, NULL,
+	                                                            satthresh, darkthresh);     
+	} else {
+		if (s->flash) {
+
+			if (numpatches != 1) {
+				free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+				free_dmatrix(multimes, 0, nmeasuered-1, -1, m->nraw-1);
+				a1logd(p->log,2,"i1pro_read_patches_2 spot read failed because numpatches != 1\n");
+				return I1PRO_INT_WRONGPATCHES;
+			}
+			if ((ev = i1pro_extract_patches_flash(p, &rv, duration, absraw[0], multimes,
+			                                                 nmeasuered, inttime)) != I1PRO_OK) {
+				free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+				free_dmatrix(multimes, 0, nmeasuered-1, -1, m->nraw-1);
+				a1logd(p->log,2,"i1pro_read_patches_2 spot read failed at i1pro_extract_patches_flash\n");
+				return ev;
+			}
+
+		} else {
+			a1logd(p->log,3,"Number of patches measured = %d\n",nmeasuered);
+
+			/* Recognise the required number of ref/trans patch locations, */
+			/* and average the measurements within each patch. */
+			if ((ev = i1pro_extract_patches_multimeas(p, &rv, absraw, numpatches, multimes,
+			                            nmeasuered, NULL, satthresh, inttime)) != I1PRO_OK) {
+				free_dmatrix(multimes, 0, nmeasuered-1, -1, m->nraw-1);
+				free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+				a1logd(p->log,2,"i1pro_read_patches_2 spot read failed at i1pro_extract_patches_multimeas\n");
+				return ev;
+			}
+		}
+	}
+
+	if (rv & 1) {
+		free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+		a1logd(p->log,3,"i1pro_read_patches_2 spot read failed with inconsistent readings\n");
+		return I1PRO_RD_READINCONS;
+	}
+
+	if (rv & 2) {
+		free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+		a1logd(p->log,3,"i1pro_read_patches_2 spot read failed with sensor saturated\n");
+		return I1PRO_RD_SENSORSATURATED;
+	}
+
+	/* Convert an absraw array from raw wavelengths to output wavelenths */
+	i1pro_absraw_to_abswav(p, m->highres, s->reflective, numpatches, specrd, absraw);
+	free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+
+#ifdef APPEND_MEAN_EMMIS_VAL
+	/* Append averaged emission reading to file "i1pdump.txt" */
+	{
+		int i, j;
+		FILE *fp;
+		
+		/* Create wavelegth label */
+		if ((fp = fopen("i1pdump.txt", "r")) == NULL) {
+			if ((fp = fopen("i1pdump.txt", "w")) == NULL)
+				a1logw(p->log,"Unable to reate debug file i1pdump.txt\n");
+			else {
+				for (j = 0; j < m->nwav[m->highres]; j++)
+					fprintf(fp,"%f ",XSPECT_WL(m->wl_short[m->highres], m->wl_long[m->highres], m->nwav[m->highres], j));
+				fprintf(fp,"\n");
+				fclose(fp);
+			}
+		}
+		if ((fp = fopen("i1pdump.txt", "a")) == NULL) {
+			a1logw(p->log,"Unable to open debug file i1pdump.txt\n");
+		else {
+			for (j = 0; j < m->nwav[m->highres]; j++)
+				fprintf(fp, "%f	",specrd[0][j] * m->emis_coef[j]);
+			fprintf(fp,"\n");
+			fclose(fp);
+		}
+	}
+#endif
+
+#ifdef PLOT_DEBUG
+	printf("Converted to wavelengths:\n");
+	plot_wav(m, m->highres, specrd[0]);
+#endif
+
+	/* Scale to the calibrated output values */
+	i1pro_scale_specrd(p, specrd, numpatches, specrd);
+
+#ifdef PLOT_DEBUG
+	printf("Calibrated measuerment spectra:\n");
+	plot_wav(m, m->highres, specrd[0]);
+#endif
+
+	return ev;
+}
+
+/* Take a measurement reading using the current mode, part 2a */
+/* Converts to completely processed output readings, */
+/* but don't average together or extract patches or flash. */
+/* (! Note that we aren't currently detecting saturation here!) */
+i1pro_code i1pro_read_patches_2a(
+	i1pro *p,
+	double **specrd,		/* Return array [numpatches][nwav] of spectral reading values */
+	int numpatches,			/* Number of patches measured and to return */
+	double inttime, 		/* Integration time to used */
+	int gainmode,			/* Gain mode useed, 0 = normal, 1 = high */
+	unsigned char *buf,		/* Raw USB reading buffer */
+	unsigned int bsize
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	double **absraw;		/* Linearsised absolute sensor raw values [numpatches][-1 nraw]*/
+	double satthresh;		/* Saturation threshold */
+	double darkthresh;		/* Dark threshold for consistency scaling limit */
+
+	darkthresh = m->sens_dark + inttime * 900.0;		/* Default */
+	if (gainmode)
+		darkthresh *= m->highgain;
+
+	/* Allocate temporaries */
+	absraw = dmatrix(0, numpatches-1, -1, m->nraw-1);
+
+	/* Take a buffer full of raw readings, and convert them to */
+	/* absolute linearised sensor values. */
+	if ((ev = i1pro_sens_to_absraw(p, absraw, buf, numpatches, inttime, gainmode, &darkthresh))
+		                                                                           != I1PRO_OK) {
+		free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+		return ev;
+	}
+
+	/* Subtract the black level */
+	i1pro_sub_absraw(p, numpatches, inttime, gainmode, absraw, s->dark_data);
+
+	if (gainmode == 0)
+		satthresh = m->sens_sat0;
+	else
+		satthresh = m->sens_sat1;
+	satthresh = i1pro_raw_to_absraw(p, satthresh, inttime, gainmode);  
+
+	darkthresh = i1pro_raw_to_absraw(p, darkthresh, inttime, gainmode);  
+
+	a1logd(p->log,3,"Number of patches measured = %d\n",numpatches);
+
+	/* Convert an absraw array from raw wavelengths to output wavelenths */
+	i1pro_absraw_to_abswav(p, m->highres, s->reflective, numpatches, specrd, absraw);
+	free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+
+#ifdef PLOT_DEBUG
+	printf("Converted to wavelengths:\n");
+	plot_wav(m, m->highres, specrd[0]);
+#endif
+
+	/* Scale to the calibrated output values */
+	i1pro_scale_specrd(p, specrd, numpatches, specrd);
+
+#ifdef PLOT_DEBUG
+	printf("Calibrated measuerment spectra:\n");
+	plot_wav(m, m->highres, specrd[0]);
+#endif
+
+	return ev;
+}
+
+/* Take a measurement reading using the current mode (combined parts 1 & 2) */
+/* Converts to completely processed output readings. */
+/* (NOTE:- this can't be used for calibration, as it implements uv mode) */
+i1pro_code i1pro_read_patches(
+	i1pro *p,
+	double *duration,		/* Return flash duration */
+	double **specrd,		/* Return array [numpatches][nwav] of spectral reading values */
+	int numpatches,			/* Number of patches to return */
+	int minnummeas,			/* Minimum number of measurements to take */
+	int maxnummeas,			/* Maximum number of measurements to allow for */
+	double *inttime, 		/* Integration time to use/used */
+	int gainmode			/* Gain mode to use, 0 = normal, 1 = high */
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	unsigned char *buf;		/* Raw USB reading buffer */
+	unsigned int bsize;
+	int nmeasuered;			/* Number actually measured */
+	int rv = 0;
+
+	if (minnummeas <= 0)
+		return I1PRO_INT_ZEROMEASURES;
+	if (minnummeas > maxnummeas)
+		maxnummeas = minnummeas;
+		
+	/* Allocate temporaries */
+	bsize = m->nsen * 2 * maxnummeas;
+	if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+		a1logd(p->log,1,"i1pro_read_patches malloc %d bytes failed (11)\n",bsize);
+		return I1PRO_INT_MALLOC;
+	}
+
+	/* Trigger measure and gather raw readings */
+	if ((ev = i1pro_read_patches_1(p, minnummeas, maxnummeas, inttime, gainmode,
+	                                       &nmeasuered, buf, bsize)) != I1PRO_OK) { 
+		free(buf);
+		return ev;
+	}
+
+	/* Process the raw readings */
+	if ((ev = i1pro_read_patches_2(p, duration, specrd, numpatches, *inttime, gainmode,
+	                                              nmeasuered, buf, bsize)) != I1PRO_OK) {
+		free(buf);
+		return ev;
+	}
+	free(buf);
+	return ev;
+}
+
+/* Take a measurement reading using the current mode (combined parts 1 & 2a) */
+/* Converts to completely processed output readings, without averaging or extracting */
+/* sample patches. */
+/* (NOTE:- this can't be used for calibration, as it implements uv mode) */
+i1pro_code i1pro_read_patches_all(
+	i1pro *p,
+	double **specrd,		/* Return array [numpatches][nwav] of spectral reading values */
+	int numpatches,			/* Number of sample to measure */
+	double *inttime, 		/* Integration time to use/used */
+	int gainmode			/* Gain mode to use, 0 = normal, 1 = high */
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	unsigned char *buf;		/* Raw USB reading buffer */
+	unsigned int bsize;
+	int rv = 0;
+
+	bsize = m->nsen * 2 * numpatches;
+	if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+		a1logd(p->log,1,"i1pro_read_patches malloc %d bytes failed (11)\n",bsize);
+		return I1PRO_INT_MALLOC;
+	}
+
+	/* Trigger measure and gather raw readings */
+	if ((ev = i1pro_read_patches_1(p, numpatches, numpatches, inttime, gainmode,
+	                                       NULL, buf, bsize)) != I1PRO_OK) { 
+		free(buf);
+		return ev;
+	}
+
+	/* Process the raw readings without averaging or extraction */
+	if ((ev = i1pro_read_patches_2a(p, specrd, numpatches, *inttime, gainmode,
+	                                                 buf, bsize)) != I1PRO_OK) {
+		free(buf);
+		return ev;
+	}
+	free(buf);
+	return ev;
+}
+
+/* Take a trial measurement reading using the current mode. */
+/* Used to determine if sensor is saturated, or not optimal */
+/* in adaptive emission mode. */
+i1pro_code i1pro_trialmeasure(
+	i1pro *p,
+	int *saturated,			/* Return nz if sensor is saturated */
+	double *optscale,		/* Factor to scale gain/int time by to make optimal (may be NULL) */
+	int nummeas,			/* Number of readings to take */
+	double *inttime, 		/* Integration time to use/used */
+	int gainmode,			/* Gain mode to use, 0 = normal, 1 = high */
+	double targoscale		/* Optimal reading scale factor */
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	unsigned char *buf;		/* Raw USB reading buffer */
+	unsigned int bsize;
+	double **multimes;		/* Multiple measurement results */
+	double *absraw;		/* Linearsised absolute sensor raw values */
+	int nmeasuered;			/* Number actually measured */
+	double highest;			/* Highest of sensor readings */
+	double sensavg;			/* Overall average of sensor readings */
+	double satthresh;		/* Saturation threshold */
+	double darkthresh;		/* Dark threshold */
+	double opttarget;		/* Optimal sensor target */
+	int rv;
+
+	if (nummeas <= 0)
+		return I1PRO_INT_ZEROMEASURES;
+		
+	darkthresh = m->sens_dark + *inttime * 900.0;
+	if (gainmode)
+		darkthresh *= m->highgain;
+
+	/* Allocate up front to avoid delay between trigger and read */
+	bsize = m->nsen * 2 * nummeas;
+	if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+		a1logd(p->log,1,"i1pro_trialmeasure malloc %d bytes failed (12)\n",bsize);
+		return I1PRO_INT_MALLOC;
+	}
+	multimes = dmatrix(0, nummeas-1, -1, m->nraw-1);
+	absraw = dvector(-1, m->nraw-1);
+
+	a1logd(p->log,3,"Triggering measurement cycle, nummeas %d, inttime %f, gainmode %d\n",
+	                                              nummeas, *inttime, gainmode);
+
+	if ((ev = i1pro_trigger_one_measure(p, nummeas, inttime, gainmode, i1p_cal)) != I1PRO_OK) {
+		free_dvector(absraw, -1, m->nraw-1);
+		free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+		free(buf);
+		return ev;
+	}
+
+	a1logd(p->log,4,"Gathering readings\n");
+	if ((ev = i1pro_readmeasurement(p, nummeas, m->c_measmodeflags & I1PRO_MMF_SCAN,
+	                                             buf, bsize, &nmeasuered, i1p_cal)) != I1PRO_OK) {
+		free_dvector(absraw, -1, m->nraw-1);
+		free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+		free(buf);
+		return ev;
+	}
+
+	/* Take a buffer full of raw readings, and convert them to */
+	/* absolute linearised sensor values. */
+	if ((ev = i1pro_sens_to_absraw(p, multimes, buf, nmeasuered, *inttime, gainmode, &darkthresh))
+		                                                                            != I1PRO_OK) {
+		return ev;
+	}
+
+	/* Compute dark subtraction for this trial's parameters */
+	if ((ev = i1pro_interp_dark(p, s->dark_data,
+		                                  s->inttime, s->gainmode)) != I1PRO_OK) {
+		free_dvector(absraw, -1, m->nraw-1);
+		free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+		free(buf);
+		a1logd(p->log,2,"i1pro_trialmeasure interplate dark ref failed\n");
+		return ev;
+	}
+
+	/* Subtract the black level */
+	i1pro_sub_absraw(p, nummeas, *inttime, gainmode, multimes, s->dark_data);
+
+	if (gainmode == 0)
+		satthresh = m->sens_sat0;
+	else
+		satthresh = m->sens_sat1;
+	satthresh = i1pro_raw_to_absraw(p, satthresh, *inttime, gainmode);  
+
+	darkthresh = i1pro_raw_to_absraw(p, darkthresh, *inttime, gainmode);  
+
+	/* Average a set of measurements into one. */
+	/* Return zero if readings are consistent and not saturated. */
+	/* Return nz with bit 1 set if the readings are not consistent */
+	/* Return nz with bit 2 set if the readings are saturated */
+	/* Return the highest individual element. */
+	/* Return the overall average. */
+	rv = i1pro_average_multimeas(p, absraw, multimes, nmeasuered, &highest, &sensavg,
+	                                                            satthresh, darkthresh);     
+#ifdef PLOT_DEBUG
+	printf("Average absolute sensor readings, average = %f, satthresh %f:\n",sensavg, satthresh);
+	plot_raw(absraw);
+#endif
+
+	if (saturated != NULL) {
+		*saturated = 0;
+		if (rv & 2)
+			*saturated = 1;
+	}
+
+	/* Compute correction factor to make sensor optimal */
+	opttarget = (double)m->sens_target * targoscale;
+	opttarget = i1pro_raw_to_absraw(p, opttarget, *inttime, gainmode);  
+
+	if (optscale != NULL) {
+		double lhighest = highest;
+
+		if (lhighest < 1.0)
+			lhighest = 1.0;
+
+		*optscale = opttarget/lhighest; 
+	}
+
+	free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+	free_dvector(absraw, -1, m->nraw-1);
+	free(buf);
+
+	return ev;
+}
+
+/* Trigger a single measurement cycle. This could be a dark calibration, */
+/* a calibration, or a real measurement. This is used to create the */
+/* higher level "calibrate" and "take reading" functions. */
+/* The setup for the operation is in the current mode state. */
+/* Call i1pro_readmeasurement() to collect the results */
+i1pro_code
+i1pro_trigger_one_measure(
+	i1pro *p,
+	int nummeas,			/* Minimum number of measurements to make */
+	double *inttime, 		/* Integration time to use/used */
+	int gainmode,			/* Gain mode to use, 0 = normal, 1 = high */
+	i1p_mmodif mmodif		/* Measurement modifier enum */
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	unsigned int timssinceoff;	/* time in msec since lamp turned off */
+	double dintclocks;
+	int intclocks;		/* Number of integration clocks */
+	double dlampclocks;
+	int lampclocks;		/* Number of lamp turn on sub-clocks */
+	int measmodeflags;	/* Measurement mode command flags */
+	int measmodeflags2;	/* Rev E Measurement mode command flags */
+
+	/* The Rev E measure mode has it's own settings */
+	if (p->itype == instI1Pro2) {
+		m->intclkp = m->intclkp2;		/* From i1pro2_getmeaschar() ? */
+		m->subclkdiv = m->subclkdiv2;
+		m->subtmode = 0;
+
+	} else {
+		/* Set any special hardware up for this sort of read */
+		if (*inttime != m->c_inttime) {		/* integration time is different */
+			int mcmode, maxmcmode;
+			int intclkusec;
+			int subtmodeflags;
+
+			/* Setting for fwrev < 301 */
+			/* (This is what getmcmode() returns for mcmode = 1 on fwrev >= 301) */
+			m->intclkp = 68.0e-6;
+			m->subclkdiv = 130;
+			m->subtmode = 0;
+
+			if (m->fwrev >= 301) {	/* Special hardware in latter versions of instrument */
+
+#ifdef DEBUG
+				/* Show all the available clock modes */
+				for (mcmode = 1;; mcmode++) {
+					int rmcmode, subclkdiv;
+
+					if ((ev = i1pro_setmcmode(p, mcmode)) != I1PRO_OK)
+						break;
+	
+					if ((ev = i1pro_getmcmode(p, &maxmcmode, &rmcmode, &subclkdiv,
+					                             &intclkusec, &subtmodeflags) ) != I1PRO_OK)
+						break;
+	
+					fprintf(stderr,"getcmode %d: maxcmode %d, mcmode %d, subclkdif %d, intclkusec %d, subtmodeflags 0x%x\n",mcmode,maxmcmode,rmcmode,subclkdiv,intclkusec,subtmodeflags);
+					if (mcmode >= maxmcmode)
+						break;
+				}
+#endif
+				/* Configure a clock mode that gives us an optimal integration time ? */
+				for (mcmode = 1;; mcmode++) {
+					if ((ev = i1pro_setmcmode(p, mcmode)) != I1PRO_OK)
+						return ev;
+	
+					if ((ev = i1pro_getmcmode(p, &maxmcmode, &mcmode, &m->subclkdiv,
+					                             &intclkusec, &subtmodeflags) ) != I1PRO_OK)
+						return ev;
+	
+					if ((*inttime/(intclkusec * 1e-6)) > 65535.0) {
+						return I1PRO_INT_INTTOOBIG;
+					}
+	
+					if (*inttime >= (intclkusec * m->subclkdiv * 1e-6 * 0.99))
+						break;			/* Setting is optimal */
+	
+					/* We need to go around again */
+					if (mcmode >= maxmcmode) {
+						return I1PRO_INT_INTTOOSMALL;
+					}
+				}
+				m->c_mcmode = mcmode;
+				m->intclkp = intclkusec * 1e-6;
+				a1logd(p->log,3,"Switched to perfect mode, subtmode flag = 0x%x, intclk = %f Mhz\n",subtmodeflags & 0x01, 1.0/intclkusec);
+				if (subtmodeflags & 0x01)
+					m->subtmode = 1;	/* Last reading subtract mode */
+			}
+		}
+	}
+	a1logd(p->log,3,"Integration clock period = %f ussec\n",m->intclkp * 1e6);
+
+	/* Compute integration clocks */
+	dintclocks = floor(*inttime/m->intclkp + 0.5);
+	if (p->itype == instI1Pro2) {
+		if (dintclocks > 4294967296.0)		/* This is probably not the actual limit */
+			return I1PRO_INT_INTTOOBIG;
+	} else {
+		if (dintclocks > 65535.0)
+			return I1PRO_INT_INTTOOBIG;
+	}
+	intclocks = (int)dintclocks;
+	*inttime = (double)intclocks * m->intclkp;		/* Quantized integration time */
+
+	if (s->reflective && (mmodif & 0x10)) {
+		dlampclocks = floor(s->lamptime/(m->subclkdiv * m->intclkp) + 0.5);
+		if (dlampclocks > 256.0)		/* Clip - not sure why. Silly value anyway */
+			dlampclocks = 256.0;
+		lampclocks = (int)dlampclocks;
+		s->lamptime = dlampclocks * m->subclkdiv * m->intclkp;	/* Quantized lamp time */
+	} else {
+		dlampclocks = 0.0;
+		lampclocks = 0;
+	}
+
+	if (nummeas > 65535)
+		nummeas = 65535;		/* Or should we error ? */
+
+	/* Create measurement mode flag values for this operation for both */
+	/* legacy and Rev E mode. Other code will examine legacy mode flags */
+	measmodeflags = 0;
+	if (s->scan && !(mmodif & 0x20)) 			/* Never scan on a calibration */
+		measmodeflags |= I1PRO_MMF_SCAN;
+	if (!s->reflective || !(mmodif & 0x10))
+		measmodeflags |= I1PRO_MMF_NOLAMP;		/* No lamp if not reflective or dark measure */
+	if (gainmode == 0)
+		measmodeflags |= I1PRO_MMF_LOWGAIN;		/* Normal gain mode */
+
+	if (p->itype == instI1Pro2) {
+		measmodeflags2 = 0;
+		if (s->scan && !(mmodif & 0x20))			/* Never scan on a calibration */
+			measmodeflags2 |= I1PRO2_MMF_SCAN;
+
+		if (mmodif == i1p2_UV)
+			measmodeflags2 |= I1PRO2_MMF_UV_LED;	/* UV LED illumination measurement */
+		else if (mmodif == i1p2_wl_cal)
+			measmodeflags2 |= I1PRO2_MMF_WL_LED;	/* Wavelegth illumination cal */
+		else if (s->reflective && (mmodif & 0x10))
+			measmodeflags2 |= I1PRO2_MMF_LAMP;		/* lamp if reflective and mmodif possible */
+
+		if (gainmode != 0)
+			return I1PRO_INT_NO_HIGH_GAIN;
+	}
+
+	a1logd(p->log,2,"i1pro: Int time %f msec, delay %f msec, no readings %d, expect %f msec\n",
+		*inttime * 1000.0,
+		((measmodeflags & I1PRO_MMF_NOLAMP) ? 0.0 : s->lamptime) * 1000.0,
+		nummeas,
+		(nummeas * *inttime + ((measmodeflags & I1PRO_MMF_NOLAMP) ? 0.0 : s->lamptime)) * 1000.0);
+	
+	/* Do a setmeasparams */
+#ifdef NEVER
+	if (intclocks != m->c_intclocks				/* If any parameters have changed */
+	 || lampclocks != m->c_lampclocks
+	 || nummeas != m->c_nummeas
+	 || measmodeflags != m->c_measmodeflags
+	 || measmodeflags2 != m->c_measmodeflags2)
+#endif /* NEVER */
+	{
+
+		if (p->itype != instI1Pro2) {			/* Rev E sets the params in the measure command */
+			/* Set the hardware for measurement */
+			if ((ev = i1pro_setmeasparams(p, intclocks, lampclocks, nummeas, measmodeflags)) != I1PRO_OK)
+				return ev;
+		} else {
+			a1logd(p->log,2,"\ni1pro: SetMeasureParam2 %d, %d, %d, 0x%04x @ %d msec\n",
+	                   intclocks, lampclocks, nummeas, measmodeflags2,
+	                   msec_time() - m->msec);
+		}
+	
+		m->c_intclocks = intclocks;
+		m->c_lampclocks = lampclocks;
+		m->c_nummeas = nummeas;
+		m->c_measmodeflags = measmodeflags;
+		m->c_measmodeflags2 = measmodeflags2;
+
+		m->c_inttime = *inttime;		/* Special harware is configured */
+		m->c_lamptime = s->lamptime;
+	}
+
+	/* If the lamp needs to be off, make sure at least 1.5 seconds */
+	/* have elapsed since it was last on, to make sure it's dark. */
+	if ((measmodeflags & I1PRO_MMF_NOLAMP)
+	 && (timssinceoff = (msec_time() - m->llamponoff)) < LAMP_OFF_TIME) {
+		a1logd(p->log,3,"Sleep %d msec for lamp cooldown\n",LAMP_OFF_TIME - timssinceoff);
+		msec_sleep(LAMP_OFF_TIME - timssinceoff);	/* Make sure time adds up to 1.5 seconds */
+	}
+
+	/* Trigger a measurement */
+	if (p->itype != instI1Pro2) {
+		if ((ev = i1pro_triggermeasure(p, TRIG_DELAY)) != I1PRO_OK)
+			return ev;
+	} else {
+		if ((ev = i1pro2_triggermeasure(p, TRIG_DELAY)) != I1PRO_OK)
+			return ev;
+	}
+
+	return ev;
+}
+
+/* ============================================================ */
+/* Big endian wire format conversion routines */
+
+/* Take an int, and convert it into a byte buffer big endian */
+static void int2buf(unsigned char *buf, int inv) {
+	buf[0] = (inv >> 24) & 0xff;
+	buf[1] = (inv >> 16) & 0xff;
+	buf[2] = (inv >> 8) & 0xff;
+	buf[3] = (inv >> 0) & 0xff;
+}
+
+/* Take a short, and convert it into a byte buffer big endian */
+static void short2buf(unsigned char *buf, int inv) {
+	buf[0] = (inv >> 8) & 0xff;
+	buf[1] = (inv >> 0) & 0xff;
+}
+
+/* Take a word sized buffer, and convert it to an int */
+static int buf2int(unsigned char *buf) {
+	int val;
+	val = buf[0];	/* Hmm. should this be sign extended ?? */
+	val = ((val << 8) + (0xff & buf[1]));
+	val = ((val << 8) + (0xff & buf[2]));
+	val = ((val << 8) + (0xff & buf[3]));
+	return val;
+}
+
+/* Take a short sized buffer, and convert it to an int */
+static int buf2short(unsigned char *buf) {
+	int val;
+	val = *((signed char *)buf);		/* Sign extend */
+	val = ((val << 8) + (0xff & buf[1]));
+	return val;
+}
+
+/* Take a unsigned short sized buffer, and convert it to an int */
+static int buf2ushort(unsigned char *buf) {
+	int val;
+	val = (0xff & buf[0]);
+	val = ((val << 8) + (0xff & buf[1]));
+	return val;
+}
+
+/* ============================================================ */
+/* lower level reading processing and computation */
+
+/* Take a buffer full of sensor readings, and convert them to */
+/* absolute raw values. Linearise if Rev A..D */
+/* If RevE, fill in the [-1] value with the shielded cell values */
+/* Note the rev E darkthresh returned has NOT been converted to an absolute raw value */
+i1pro_code i1pro_sens_to_absraw(
+	i1pro *p,
+	double **absraw,		/* Array of [nummeas][-1 nraw] value to return */
+	unsigned char *buf,		/* Raw measurement data must be nsen * nummeas */
+	int nummeas,			/* Return number of readings measured */
+	double inttime, 		/* Integration time used */
+	int gainmode,			/* Gain mode, 0 = normal, 1 = high */
+	double *pdarkthresh     /* Return a raw dark threshold value (Rev E) */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	int i, j, k;
+	unsigned char *bp;
+	unsigned int maxpve = m->maxpve;	/* maximum +ve sensor value + 1 */ 
+	double avlastv = 0.0;
+	double darkthresh = 0.0;			/* Rev E calculated values */
+	double ndarkthresh = 0.0;
+	double gain;
+	int npoly;			/* Number of linearisation coefficients */
+	double *polys;		/* the coeficients */
+	double scale;		/* Absolute scale value */
+	int sskip = 0;		/* Bytes to skip at start */
+	int eskip = 0;		/* Bytes to skip at end */
+
+	if (gainmode) {
+		gain = m->highgain;
+		npoly = m->nlin1;
+		polys = m->lin1;
+	} else {
+		gain = 1.0;
+		npoly = m->nlin0;
+		polys = m->lin0;
+	}
+	scale = 1.0/(inttime * gain);
+
+	/* Now process the buffer values */
+	if (m->nsen > m->nraw) {	/* It's a Rev E, so we have extra values, */
+								/* and don't linearize here. */
+		sskip = 6 * 2;		/* 6 dark reading values */
+		eskip = 0 * 2;		/* none to skip at end */
+
+		if ((sskip + m->nraw * 2 + eskip) != (m->nsen * 2)) {
+			a1loge(p->log,1,"i1pro Rev E - sskip %d + nraw %d + eskip %d != nsen %d\n"
+			                                 ,sskip, m->nraw * 2, eskip, m->nsen * 2);
+			return I1PRO_INT_ASSERT;
+		}
+
+		for (bp = buf, i = 0; i < nummeas; i++, bp += eskip) {
+			unsigned int rval;
+			double fval;
+			
+			/* The first 6 readings (xraw from i1pro2_getmeaschar()) are shielded cells, */
+			/* and we use them as an estimate of the dark reading consistency, as well as for */
+			/* compensating the dark level calibration for any temperature changes. */
+
+			/* raw average of all measurement shielded cell values */
+			for (k = 0; k < 6; k++) {
+				darkthresh += (double)buf2ushort(bp + k * 2);
+				ndarkthresh++;
+			}
+
+			/* absraw of shielded cells per reading */
+			absraw[i][-1] = 0.0;
+			for (k = 0; k < 6; k++) {
+				rval = buf2ushort(bp + k * 2);
+				fval = (double)(int)rval;
+
+				/* And scale to be an absolute sensor reading */
+				absraw[i][-1] += fval * scale;
+			}
+			absraw[i][-1] /= 6.0;
+		
+			for (bp += sskip, j = 0; j < m->nraw; j++, bp += 2) {
+				rval = buf2ushort(bp);
+				a1logd(p->log,9,"% 3d:rval 0x%x, ",j, rval);
+				a1logd(p->log,9,"srval 0x%x, ",rval);
+				fval = (double)(int)rval;
+				a1logd(p->log,9,"fval %.0f, ",fval);
+
+				/* And scale to be an absolute sensor reading */
+				absraw[i][j] = fval * scale;
+				a1logd(p->log,9,"absval %.1f\n",fval * scale);
+			}
+		}
+		darkthresh /= ndarkthresh;
+		if (pdarkthresh != NULL)
+			*pdarkthresh = darkthresh;
+		a1logd(p->log,3,"i1pro_sens_to_absraw: Dark threshold = %f\n",darkthresh);
+
+	} else {
+		/* if subtmode is set, compute the average last reading raw value. */
+		/* Could this be some sort of temperature compensation offset ??? */
+		/* (Rev A produces a value that is quite different to a sensor value, */
+		/* ie. 1285 = 0x0505, while RevD and RevE in legacy mode have a value of 0 */
+		/* I've not seen anything actually use subtmode - maybe this is Rev B only ?) */
+		/* The 0 band seens to contain values similar to band 1, so it's not clear */
+		/* why the manufacturers driver appears to be discarding it ? */
+
+		/* (Not sure if it's reasonable to extend the sign and then do this */
+		/* computation, or whether it makes any difference, since I've never */
+		/* seen this mode triggered. */
+		if (m->subtmode) {
+			for (bp = buf + 254, i = 0; i < nummeas; i++, bp += (m->nsen * 2)) {
+				unsigned int lastv;
+				lastv = buf2ushort(bp);
+				if (lastv >= maxpve) {
+					lastv -= 0x00010000;	/* Convert to -ve */
+				}
+				avlastv += (double)lastv;
+			}
+			avlastv /= (double)nummeas;
+			a1logd(p->log,3,"subtmode got avlastv = %f\n",avlastv);
+		}
+
+		for (bp = buf, i = 0; i < nummeas; i++) {
+			absraw[i][-1] = 1.0;		/* Not used in RevA-D */
+
+			for (j = 0; j < 128; j++, bp += 2)  {
+				unsigned int rval;
+				double fval, lval;
+
+				rval = buf2ushort(bp);
+				a1logd(p->log,9,"% 3d:rval 0x%x, ",j, rval);
+				if (rval >= maxpve)
+					rval -= 0x00010000;	/* Convert to -ve */
+				a1logd(p->log,9,"srval 0x%x, ",rval);
+				fval = (double)(int)rval;
+				a1logd(p->log,9,"fval %.0f, ",fval);
+				fval -= avlastv;
+				a1logd(p->log,9,"fval-av %.0f, ",fval);
+
+#ifdef ENABLE_NONLINCOR	
+				/* Linearise */
+				for (lval = polys[npoly-1], k = npoly-2; k >= 0; k--)
+					lval = lval * fval + polys[k];
+#else
+				lval = fval;
+#endif
+				a1logd(p->log,9,"lval %.1f, ",lval);
+
+				/* And scale to be an absolute sensor reading */
+				absraw[i][j] = lval * scale;
+				a1logd(p->log,9,"absval %.1f\n",lval * scale);
+				// a1logd(p->log,3,"Meas %d band %d raw = %f\n",i,j,fval);
+			}
+
+			/* Duplicate last values in buffer to make up to 128 */
+			absraw[i][0] = absraw[i][1];
+			absraw[i][127] = absraw[i][126];
+		}
+	}
+
+	return I1PRO_OK;
+}
+
+/* Take a raw value, and convert it into an absolute raw value. */
+/* Note that linearisation is ignored, since it is assumed to be insignificant */
+/* to the black threshold and saturation values. */
+double i1pro_raw_to_absraw(
+	i1pro *p,
+	double raw,				/* Input value */
+	double inttime, 		/* Integration time used */
+	int gainmode			/* Gain mode, 0 = normal, 1 = high */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	int i, j, k;
+	double gain;
+	double scale;		/* Absolute scale value */
+	double fval;
+
+	if (gainmode) {
+		gain = m->highgain;
+	} else {
+		gain = 1.0;
+	}
+	scale = 1.0/(inttime * gain);
+
+	return raw * scale;
+}
+
+
+/* Invert a polinomial equation. */
+/* Since the linearisation is nearly a straight line, */
+/* a simple Newton inversion will suffice. */
+static double inv_poly(double *polys, int npoly, double inv) {
+	double outv = inv, lval, del = 100.0;
+	int i, k;
+
+	for (i = 0; i < 200 && fabs(del) > 1e-7; i++) {
+		for (lval = polys[npoly-1], k = npoly-2; k >= 0; k--) {
+			lval = lval * outv + polys[k];
+		}
+		del = (inv - lval);
+		outv += 0.99 * del;
+	}
+
+	return outv;
+}
+
+/* Take a single set of absolute linearised sensor values and */
+/* convert them back into Rev A..D raw reading values. */
+/* This is used for saving a calibration to the EEProm */
+i1pro_code i1pro_absraw_to_meas(
+	i1pro *p,
+	int *meas,				/* Return raw measurement data */
+	double *absraw,			/* Array of [-1 nraw] value to process */
+	double inttime, 		/* Integration time used */
+	int gainmode			/* Gain mode, 0 = normal, 1 = high */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	unsigned int maxpve = m->maxpve;	/* maximum +ve sensor value + 1 */ 
+	int i, j, k;
+	double avlastv = 0.0;
+	double gain;
+	int npoly;			/* Number of linearisation coefficients */
+	double *polys;		/* the coeficients */
+	double scale;		/* Absolute scale value */
+
+	if (m->subtmode) {
+		a1logd(p->log,1,"i1pro_absraw_to_meas subtmode set\n");
+		return I1PRO_INT_MALLOC;
+	}
+
+	if (gainmode) {
+		gain = m->highgain;
+		npoly = m->nlin1;
+		polys = m->lin1;
+	} else {
+		gain = 1.0;
+		npoly = m->nlin0;
+		polys = m->lin0;
+	}
+	scale = 1.0/(inttime * gain);
+
+	for (j = 0; j < 128; j++)  {
+		double fval, lval;
+		unsigned int rval;
+
+		/* Unscale from absolute sensor reading */
+		lval = absraw[j] / scale;
+
+#ifdef ENABLE_NONLINCOR	
+		/* Un-linearise */
+		fval = inv_poly(polys, npoly, lval);
+#else
+		fval = lval;
+#endif
+
+		if (fval < (double)((int)maxpve-65536))
+			fval = (double)((int)maxpve-65536);
+		else if (fval > (double)(maxpve-1))
+			fval = (double)(maxpve-1);
+
+		rval = (unsigned int)(int)floor(fval + 0.5);
+		meas[j] = rval;
+	}
+	return I1PRO_OK;
+}
+
+/* Average a set of measurements into one. */
+/* Return zero if readings are consistent and not saturated. */
+/* Return nz with bit 1 set if the readings are not consistent */
+/* Return nz with bit 2 set if the readings are saturated */
+/* Return the highest individual element. */
+/* Return the overall average. */
+int i1pro_average_multimeas(
+	i1pro *p,
+	double *avg,			/* return average [-1 nraw] */
+	double **multimeas,		/* Array of [nummeas][-1 nraw] value to average */
+	int nummeas,			/* number of readings to be averaged */
+	double *phighest,		/* If not NULL, return highest value from all bands and msrmts. */
+	double *poallavg,		/* If not NULL, return overall average of bands and measurements */
+	double satthresh,		/* Sauration threshold, 0 for none */
+	double darkthresh		/* Dark threshold (used for consistency check scaling) */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	int i, j;
+	double highest = -1e6;
+	double oallavg = 0.0;
+	double avgoverth = 0.0;		/* Average over threshold */
+	double maxavg = -1e38;		/* Track min and max averages of readings */
+	double minavg = 1e38;
+	double norm;
+	int rv = 0;
+	
+	a1logd(p->log,3,"i1pro_average_multimeas %d readings\n",nummeas);
+
+	for (j = -1; j < 128; j++) 
+		avg[j] = 0.0;
+
+	/* Now process the buffer values */
+	for (i = 0; i < nummeas; i++) {
+		double measavg = 0.0;
+		int k;
+
+		for (j = k = 0; j < m->nraw; j++) {
+			double val;
+
+			val = multimeas[i][j];
+
+			avg[j] += val;		/* Per value average */
+
+			/* Skip 0 and 127 cell values for RevA-D */
+			if (m->nsen == m->nraw && (j == 0 || j == 127))
+				continue;
+
+			if (val > highest)
+				highest = val;
+			if (val > satthresh)
+				avgoverth++;
+			measavg += val;
+			k++;
+		}
+		measavg /= (double)k;
+		oallavg += measavg;
+		if (measavg < minavg)
+			minavg = measavg;
+		if (measavg > maxavg)
+			maxavg = measavg;
+
+		/* and shielded values */
+		avg[-1] += multimeas[i][-1];
+	}
+
+	for (j = -1; j < 128; j++) 
+		avg[j] /= (double)nummeas;
+	oallavg /= (double)nummeas;
+	avgoverth /= (double)nummeas;
+
+	if (phighest != NULL)
+		*phighest = highest;
+
+	if (poallavg != NULL)
+		*poallavg = oallavg;
+
+	if (satthresh > 0.0 && avgoverth > 0.0)
+		rv |= 2;
+
+	norm = fabs(0.5 * (maxavg+minavg));
+	a1logd(p->log,4,"norm = %f, dark thresh = %f\n",norm,darkthresh);
+	if (norm < (2.0 * darkthresh))
+		norm = 2.0 * darkthresh;
+
+	a1logd(p->log,4,"overall avg = %f, minavg = %f, maxavg = %f, variance %f, shielded avg %f\n",
+	                   oallavg,minavg,maxavg,(maxavg - minavg)/norm, avg[-1]);
+	if ((maxavg - minavg)/norm > PATCH_CONS_THR) {
+		a1logd(p->log,2,"Reading is inconsistent: (maxavg %f - minavg %f)/norm %f = %f > thresh %f, darkthresh %f\n",maxavg,minavg,norm,(maxavg - minavg)/norm,PATCH_CONS_THR, darkthresh);
+		rv |= 1;
+	}
+	return rv;
+}
+
+/* Minimum number of scan samples in a patch */
+#define MIN_SAMPLES 3
+
+/* Range of bands to detect transitions */
+#define BL 5	/* Start */
+#define BH 105	/* End */
+#define BW 5	/* Width */
+
+/* Record of possible patch */
+typedef struct {
+	int ss;				/* Start sample index */
+	int no;				/* Number of samples */
+	int use;			/* nz if patch is to be used */
+} i1pro_patch;
+
+/* Recognise the required number of ref/trans patch locations, */
+/* and average the measurements within each patch. */
+/* *flags returns zero if readings are consistent and not saturated. */
+/* *flags returns nz with bit 1 set if the readings are not consistent */
+/* *flags returns nz with bit 2 set if the readings are saturated */
+/* *phighest returns the highest individual element. */
+/* (Doesn't extract [-1] shielded values, since they have already been used) */
+i1pro_code i1pro_extract_patches_multimeas(
+	i1pro *p,
+	int *flags,				/* return flags */
+	double **pavg,			/* return patch average [naptch][-1 nraw] */
+	int tnpatch,			/* Target number of patches to recognise */
+	double **multimeas,		/* Array of [nummeas][-1 nraw] value to extract from */
+	int nummeas,			/* number of readings made */
+	double *phighest,		/* If not NULL, return highest value from all bands and msrmts. */
+	double satthresh,		/* Sauration threshold, 0 for none */
+	double inttime			/* Integration time (used to adjust consistency threshold) */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	int i, j, k, pix;
+	double **sslope;			/* Signed difference between i and i+1 */
+	double *slope;				/* Accumulated absolute difference between i and i+1 */
+	double *fslope;				/* Filtered slope */
+	i1pro_patch *pat;			/* Possible patch information */
+	int npat, apat = 0;
+	double *maxval;				/* Maximum input value for each wavelength */
+	double fmaxslope = 0.0;
+	double maxslope = 0.0;
+	double minslope =  1e38;
+	double thresh = 0.4;		/* Slope threshold */
+	int try;					/* Thresholding try */
+	double avglegth;			/* Average length of patches */
+	int *sizepop;				/* Size popularity of potential patches */
+	double median;				/* median potential patch width */
+	double window;				/* +/- around median to accept */
+	double highest = -1e6;
+	double white_avg;			/* Average of (aproximate) white data */
+	int b_lo = BL;				/* Patch detection low band */
+	int b_hi = BH;				/* Patch detection low band */
+	int rv = 0;
+	double patch_cons_thr = PATCH_CONS_THR * m->scan_toll_ratio;
+#ifdef PATREC_DEBUG
+	double **plot;
+#endif
+
+	a1logd(p->log,2,"i1pro_extract_patches_multimeas looking for %d patches out of %d samples\n",tnpatch,nummeas);
+
+	/* Adjust bands if UV mode */
+	/* (This is insufficient for useful patch recognition) */
+	if (m->uv_en) {
+		b_lo = 91;
+		b_hi = 117;
+	}
+
+	maxval = dvectorz(-1, m->nraw-1);  
+
+	/* Loosen consistency threshold for short integation time, */
+	/* to allow for extra noise */
+	if (inttime < 0.012308)		/* Smaller than Rev A minimum int. time */
+		patch_cons_thr *= sqrt(0.012308/inttime);
+
+	/* Discover the maximum input value for normalisation */
+	for (j = 0; j < m->nraw; j ++) {
+		for (i = 0; i < nummeas; i++) {
+			if (multimeas[i][j] > maxval[j])
+				maxval[j] = multimeas[i][j];
+		}
+		if (maxval[j] < 1.0)
+			maxval[j] = 1.0;
+	}
+
+#ifdef PATREC_DEBUG
+	/* Plot out 6 lots of 8 values each */ 
+	plot = dmatrixz(0, 8, 0, nummeas-1);  
+//	for (j = 45; j <= (m->nraw-8); j += 100) 		/* Do just one band */
+#ifdef PATREC_ALLBANDS
+	for (j = 0; j <= (m->nraw-8); j += 8) 			/* Plot all the bands */
+#else
+	for (j = 5; j <= (m->nraw-8); j += 30) 			/* Do four bands */
+#endif
+	{
+		for (k = 0; k < 8; k ++) {
+			for (i = 0; i < nummeas; i++) { 
+				plot[k][i] = multimeas[i][j+k]/maxval[j+k];
+			}
+		}
+		for (i = 0; i < nummeas; i++)
+			plot[8][i] = (double)i;
+		printf("Bands %d - %d\n",j,j+7);
+		do_plot10(plot[8], plot[0], plot[1], plot[2], plot[3], plot[4], plot[5], plot[6], plot[7], NULL, NULL, nummeas, 0);
+	}
+#endif	/* PATREC_DEBUG */
+
+	sslope = dmatrixz(0, nummeas-1, -1, m->nraw-1);  
+	slope = dvectorz(0, nummeas-1);  
+	fslope = dvectorz(0, nummeas-1);  
+	sizepop = ivectorz(0, nummeas-1);
+
+#ifndef NEVER		/* Good with this on */
+	/* Average bands together */
+	for (i = 0; i < nummeas; i++) {
+		for (j = b_lo + BW; j < (b_hi - BW); j++) {
+			for (k = -b_lo; k <= BW; k++)		/* Box averaging filter over bands */
+				 sslope[i][j] += multimeas[i][j + k]/maxval[j];
+		}
+	}
+#else
+	/* Don't average bands */
+	for (i = 0; i < nummeas; i++) {
+		for (j = 0; j < m->nraw; j++) {
+			sslope[i][j] = multimeas[i][j]/maxval[j];
+		}
+	}
+#endif
+
+	/* Compute slope result over readings and bands */
+	/* Compute signed slope result over readings and bands */
+
+#ifdef NEVER		/* Works well for non-noisy readings */
+	/* Median of 5 differences from 6 points */
+	for (i = 2; i < (nummeas-3); i++) {
+		for (j = b_lo; j < b_hi; j++) {
+			double sl, asl[5];
+			int r, s;
+			asl[0] = fabs(sslope[i-2][j] - sslope[i-1][j]);
+			asl[1] = fabs(sslope[i-1][j] - sslope[i-0][j]);
+			asl[2] = fabs(sslope[i-0][j] - sslope[i+1][j]);
+			asl[3] = fabs(sslope[i+1][j] - sslope[i+2][j]);
+			asl[4] = fabs(sslope[i+2][j] - sslope[i+3][j]);
+
+			/* Sort them */
+			for (r = 0; r < (5-1); r++) {
+				for (s = r+1; s < 5; s++) {
+					if (asl[s] < asl[r]) {
+						double tt;
+						tt = asl[s];
+						asl[s] = asl[r];
+						asl[r] = tt;
+					}
+				}
+			}
+			/* Pick middle one */
+			sl = asl[2];
+			if (sl > slope[i])
+				slope[i] = sl;
+		}
+	}
+
+#else	/* Works better for noisy readings */
+
+	/* Compute sliding window average and deviation that contains */
+	/* our output point, and chose the average with the minimum deviation. */
+#define FW 3		/* Number of delta's to average */
+	for (i = FW-1; i < (nummeas-FW); i++) {		/* Samples */
+		double basl, bdev;		/* Best average slope, Best deviation */
+		double sl[2 * FW -1];
+		double asl[FW], dev[FW];		
+		int slopen = 0;
+		double slopeth = 0.0;
+		int m, pp;
+
+		for (pp = 0; pp < 2; pp++) { 			/* For each pass */
+
+			for (j = b_lo; j < b_hi; j++) {				/* Bands */
+
+				/* Compute differences for the range of our windows */
+				for (k = 0; k < (2 * FW -1); k++)
+					sl[k] = sslope[i+k-FW+1][j] - sslope[i+k+-FW+2][j];
+
+				/* For each window offset, compute average and deviation squared */
+				bdev = 1e38;
+				for (k = 0; k < FW; k++) { 
+
+					/* Compute average of this window offset */
+					asl[k] = 0.0;
+					for (m = 0; m < FW; m++)	/* For slope in window */
+						asl[k] += sl[k+m];
+					asl[k] /= (double)FW;
+
+					/* Compute deviation squared */
+					dev[k] = 0.0;
+					for (m = 0; m < FW; m++) {
+						double tt;
+						tt = sl[k+m] - asl[k];
+						dev[k] += tt * tt;
+					}
+					if (dev[k] < bdev)
+						bdev = dev[k];
+				}
+
+#ifndef NEVER
+				/* Weight the deviations with a triangular weighting */
+				/* to skew slightly towards the center */
+				for (k = 0; k < FW; k++) { 
+					double wt;
+
+					wt = fabs(2.0 * k - (FW -1.0))/(FW-1.0);
+					dev[k] += wt * bdev;
+				}
+#endif
+
+				/* For each window offset, choose the one to use. */
+				bdev = 1e38;
+				basl = 0.0;
+				for (k = 0; k < FW; k++) { 
+
+					/* Choose window average with smallest deviation squared */
+					if (dev[k] < bdev) {
+						bdev = dev[k];
+						basl = fabs(asl[k]);
+					}
+				}
+
+				if (pp == 0) {		/* First pass, compute average slope over bands */
+					slope[i] += basl;
+
+				} else {			/* Second pass, average slopes of bands over threshold */
+					if (basl > slopeth) {
+						slope[i] += basl;
+						slopen++;
+					}
+				}
+			}	/* Next band */
+
+			if (pp == 0) {
+				slopeth = 1.0 * slope[i]/j;		/* Compute threshold */
+				slope[i] = 0.0;
+			} else {
+				if (slopen > 0)
+					slope[i] /= slopen;			/* Compute average of those over threshold */
+			}
+		}		/* Next pass */
+	}
+#undef FW
+#endif
+
+#ifndef NEVER		/* Good with this on */
+	/* Normalise the slope values */
+	/* Locate the minumum and maximum values */
+	maxslope = 0.0;
+	minslope = 1e38;
+	for (i = 4; i < (nummeas-4); i++) {
+		double avs;
+
+		if (slope[i] > maxslope)
+			maxslope = slope[i];
+
+		/* Simple moving average for min comp. */
+		avs = 0.0;
+		for (j = -2; j <= 2; j++)
+			avs += slope[i+j];
+		avs /= 5.0;
+		if (avs < minslope)
+			minslope = avs;
+	}
+
+	/* Normalise the slope */
+	maxslope *= 0.5;
+	minslope *= 3.0;
+	for (i = 0; i < nummeas; i++) {
+		slope[i] = (slope[i] - minslope) / (maxslope - minslope);
+		if (slope[i] < 0.0)
+			slope[i] = 0.0;
+		else if (slope[i] > 1.0)
+			slope[i] = 1.0;
+	}
+
+	/* "Automatic Gain control" the raw slope information. */
+#define LFW 20		/* Half width of triangular filter */
+	for (i = 0; i < nummeas; i++) {
+		double sum, twt;
+		
+		sum = twt = 0.0;
+		for (j = -LFW; j <= LFW; j++) {
+			double wt;
+			if ((i+j) < 0 || (i+j) >= nummeas)
+				continue;
+
+			wt = ((LFW-abs(j))/(double)LFW);
+			
+			sum += wt * slope[i+j];
+			twt += wt;
+		}
+		fslope[i] = sum/twt;
+		if (fslope[i] > fmaxslope)
+			fmaxslope = fslope[i];
+	}
+#undef LFW
+
+#ifdef NEVER		/* Better with the off, for very noisy samples */
+	/* Apply AGC with limited gain */
+	for (i = 0; i < nummeas; i++) {
+		if (fslope[i] > fmaxslope/4.0)
+			slope[i] = slope[i]/fslope[i];
+		else
+			slope[i] = slope[i] * 4.0/fmaxslope;
+	}
+#endif
+#endif /* NEVER */
+
+	/* Locate the minumum and maximum values */
+	maxslope = 0.0;
+	minslope = 1e38;
+	for (i = 4; i < (nummeas-4); i++) {
+		double avs;
+
+		if (slope[i] > maxslope)
+			maxslope = slope[i];
+
+		/* Simple moving average for min comp. */
+		avs = 0.0;
+		for (j = -2; j <= 2; j++)
+			avs += slope[i+j];
+		avs /= 5.0;
+		if (avs < minslope)
+			minslope = avs;
+	}
+
+#ifndef NEVER		/* Good with this on */
+	/* Normalise the slope again */
+	maxslope *= 0.3;
+	minslope *= 3.0;
+	for (i = 0; i < nummeas; i++) {
+		slope[i] = (slope[i] - minslope) / (maxslope - minslope);
+		if (slope[i] < 0.0)
+			slope[i] = 0.0;
+		else if (slope[i] > 1.0)
+			slope[i] = 1.0;
+	}
+#endif
+
+#ifdef PATREC_DEBUG
+	printf("Slope filter output\n");
+	for (i = 0; i < nummeas; i++) { 
+		int jj;
+		for (jj = 0, j = b_lo; jj < 6 && j < b_hi; jj++, j += ((b_hi-b_lo)/6)) {
+			double sum = 0.0;
+			for (k = -b_lo; k <= BW; k++)		/* Box averaging filter over bands */
+				sum += multimeas[i][j + k];
+			plot[jj][i] = sum/((2.0 * b_lo + 1.0) * maxval[j+k]);
+		}
+	}
+	for (i = 0; i < nummeas; i++)
+		plot[6][i] = (double)i;
+	do_plot6(plot[6], slope, plot[0], plot[1], plot[2], plot[3], plot[4], nummeas);
+#endif	/* PATREC_DEBUG */
+
+	free_dvector(fslope, 0, nummeas-1);  
+	free_dmatrix(sslope, 0, nummeas-1, -1, m->nraw-1);  
+
+	/* Now threshold the measurements into possible patches */
+	apat = 2 * nummeas;
+	if ((pat = (i1pro_patch *)malloc(sizeof(i1pro_patch) * apat)) == NULL) {
+		a1logd(p->log, 1, "i1pro: malloc of patch structures failed!\n");
+		return I1PRO_INT_MALLOC;
+	}
+
+	avglegth = 0.0;
+	for (npat = i = 0; i < (nummeas-1); i++) {
+		if (slope[i] > thresh)
+			continue;
+
+		/* Start of a new patch */
+		if (npat >= apat) {
+			apat *= 2;
+			if ((pat = (i1pro_patch *)realloc(pat, sizeof(i1pro_patch) * apat)) == NULL) {
+				a1logd(p->log, 1, "i1pro: reallloc of patch structures failed!\n");
+				return I1PRO_INT_MALLOC;
+			}
+		}
+		pat[npat].ss = i;
+		pat[npat].no = 2;
+		pat[npat].use = 0;
+		for (i++; i < (nummeas-1); i++) {
+			if (slope[i] > thresh)
+				break;
+			pat[npat].no++;
+		}
+		avglegth += (double) pat[npat].no;
+		npat++;
+	}
+	a1logd(p->log,7,"Number of patches = %d\n",npat);
+
+	/* We don't count the first and last patches, as we assume they are white leader */
+	if (npat < (tnpatch + 2)) {
+		free_ivector(sizepop, 0, nummeas-1);
+		free_dvector(slope, 0, nummeas-1);  
+		free_dvector(maxval, -1, m->nraw-1);  
+		free(pat);
+		a1logd(p->log,2,"Patch recog failed - unable to detect enough possible patches\n");
+		return I1PRO_RD_NOTENOUGHPATCHES;
+	} else if (npat >= (2 * tnpatch) + 2) {
+		free_ivector(sizepop, 0, nummeas-1);
+		free_dvector(slope, 0, nummeas-1);  
+		free_dvector(maxval, -1, m->nraw-1);  
+		free(pat);
+		a1logd(p->log,2,"Patch recog failed - detecting too many possible patches\n");
+		return I1PRO_RD_TOOMANYPATCHES;
+	}
+	avglegth /= (double)npat;
+
+	for (i = 0; i < npat; i++) {
+		a1logd(p->log,7,"Raw patch %d, start %d, length %d\n",i, pat[i].ss, pat[i].no);
+	}
+
+	/* Accumulate popularity ccount of possible patches */
+	for (i = 1; i < (npat-1); i++)
+		sizepop[pat[i].no]++;
+
+	/* Locate the median potential patch width */
+	for (j = 0, i = 0; i < nummeas; i++) {
+		j += sizepop[i];
+		if (j >= ((npat-2)/2))
+			break;
+	}
+	median = (double)i;
+
+	a1logd(p->log,7,"Median patch width %f\n",median);
+
+	/* Now decide which patches to use. */
+	/* Try a widening window around the median. */
+	for (window = 0.2, try = 0; try < 15; window *= 1.4, try++) {
+		int bgcount = 0, bgstart = 0;
+		int gcount, gstart;
+		double wmin = median/(1.0 + window);
+		double wmax = median * (1.0 + window);
+
+		a1logd(p->log,7,"Window = %f - %f\n",wmin, wmax);
+		/* Track which is the largest contiguous group that */
+		/* is within our window */
+		gcount = gstart = 0;
+		for (i = 1; i < npat; i++) {
+			if (i < (npat-1) && pat[i].no <= wmax) {		/* Small enough */
+				if (pat[i].no >= wmin) {	/* And big enough */
+					if (gcount == 0) {		/* Start of new group */
+						gcount++;
+						gstart = i;
+						a1logd(p->log,7,"Start group at %d\n",gstart);
+					} else {
+						gcount++;			/* Continuing new group */
+						a1logd(p->log,7,"Continue group at %d, count %d\n",gstart,gcount);
+					}
+				}
+			} else {	/* Too big or end of patches, end this group */
+				a1logd(p->log,7,"Terminating group group at %d, count %d\n",gstart,gcount);
+				if (gcount > bgcount) {		/* New biggest group */
+					bgcount = gcount;
+					bgstart = gstart;
+					a1logd(p->log,7,"New biggest\n");
+				}
+				gcount = gstart = 0;		/* End this group */
+			}
+		}
+		a1logd(p->log,7,"Biggest group is at %d, count %d\n",bgstart,bgcount);
+
+		if (bgcount == tnpatch) {			/* We're done */
+			for (i = bgstart, j = 0; i < npat && j < tnpatch; i++) {
+				if (pat[i].no <= wmax && pat[i].no >= wmin) {
+					pat[i].use = 1;
+					j++;
+					if (pat[i].no < MIN_SAMPLES) {
+						a1logd(p->log,7,"Too few samples\n");
+						free_ivector(sizepop, 0, nummeas-1);
+						free_dvector(slope, 0, nummeas-1);  
+						free_dvector(maxval, -1, m->nraw-1);  
+						free(pat);
+						a1logd(p->log,2,"Patch recog failed - patches sampled too sparsely\n");
+						return I1PRO_RD_NOTENOUGHSAMPLES;
+					}
+				}
+			}
+			break;
+
+		} else if (bgcount > tnpatch) {
+			a1logd(p->log,7,"Too many patches\n");
+			free_ivector(sizepop, 0, nummeas-1);
+			free_dvector(slope, 0, nummeas-1);  
+			free_dvector(maxval, -1, m->nraw-1);  
+			free(pat);
+			a1logd(p->log,2,"Patch recog failed - detected too many consistent patches\n");
+			return I1PRO_RD_TOOMANYPATCHES;
+		}
+	}
+	if (try >= 15) {
+		a1logd(p->log,7,"Not enough patches\n");
+		free_ivector(sizepop, 0, nummeas-1);
+		free_dvector(slope, 0, nummeas-1);  
+		free_dvector(maxval, -1, m->nraw-1);  
+		free(pat);
+		a1logd(p->log,2,"Patch recog failed - unable to find enough consistent patches\n");
+		return I1PRO_RD_NOTENOUGHPATCHES;
+	}
+
+	a1logd(p->log,7,"Got %d patches out of potential %d:\n",tnpatch, npat);
+	a1logd(p->log,7,"Average patch legth %f\n",avglegth);
+	for (i = 1; i < (npat-1); i++) {
+		if (pat[i].use == 0)
+			continue;
+		a1logd(p->log,7,"Patch %d, start %d, length %d:\n",i, pat[i].ss, pat[i].no, pat[i].use);
+	}
+
+	/* Now trim the patches simply by shrinking their windows */
+	for (k = 1; k < (npat-1); k++) {
+		int nno, trim;
+
+		if (pat[k].use == 0)
+			continue;
+
+		
+		nno = (pat[k].no * 3)/4;
+		trim = (pat[k].no - nno)/2;
+
+		pat[k].ss += trim;
+		pat[k].no = nno;
+	}
+
+#ifdef PATREC_DEBUG
+	a1logd(p->log,7,"After trimming got:\n");
+	for (i = 1; i < (npat-1); i++) {
+		if (pat[i].use == 0)
+			continue;
+		printf("Patch %d, start %d, length %d:\n",i, pat[i].ss, pat[i].no, pat[i].use);
+	}
+
+	/* Create fake "slope" value that marks patches */
+	for (i = 0; i < nummeas; i++) 
+		slope[i] = 1.0;
+	for (k = 1; k < (npat-1); k++) {
+		if (pat[k].use == 0)
+			continue;
+		for (i = pat[k].ss; i < (pat[k].ss + pat[k].no); i++)
+			slope[i] = 0.0;
+	}
+
+	printf("Trimmed output:\n");
+	for (i = 0; i < nummeas; i++) { 
+		int jj;
+		for (jj = 0, j = b_lo; jj < 6 && j < b_hi; jj++, j += ((b_hi-b_lo)/6)) {
+			double sum = 0.0;
+			for (k = -b_lo; k <= BW; k++)		/* Box averaging filter over bands */
+				sum += multimeas[i][j + k];
+			plot[jj][i] = sum/((2.0 * b_lo + 1.0) * maxval[j+k]);
+		}
+	}
+	for (i = 0; i < nummeas; i++)
+		plot[6][i] = (double)i;
+	do_plot6(plot[6], slope, plot[0], plot[1], plot[2], plot[3], plot[4], nummeas);
+#endif	/* PATREC_DEBUG */
+
+#ifdef PATREC_DEBUG
+	free_dmatrix(plot, 0, 6, 0, nummeas-1);  
+#endif	/* PATREC_DEBUG */
+
+	/* Compute average of (aproximate) white */
+	white_avg = 0.0;
+	for (j = 1; j < (m->nraw-1); j++) 
+		white_avg += maxval[j];
+	white_avg /= (m->nraw - 2.0);
+
+	/* Now process the buffer values */
+	for (i = 0; i < tnpatch; i++) {
+		for (j = 0; j < m->nraw; j++) 
+			pavg[i][j] = 0.0;
+	}
+
+	for (pix = 0, k = 1; k < (npat-1); k++) {
+		double maxavg = -1e38;	/* Track min and max averages of readings for consistency */
+		double minavg = 1e38;
+		double avgoverth = 0.0;	/* Average over saturation threshold */
+		double cons;			/* Consistency */
+
+		if (pat[k].use == 0)
+			continue;
+
+		if (pat[k].no <= MIN_SAMPLES) {
+			a1logd(p->log,7,"Too few samples (%d, need %d)\n",pat[k].no,MIN_SAMPLES);
+			free_dvector(slope, 0, nummeas-1);  
+			free_ivector(sizepop, 0, nummeas-1);
+			free_dvector(maxval, -1, m->nraw-1);  
+			free(pat);
+			a1logd(p->log,2,"Patch recog failed - patches sampled too sparsely\n");
+			return I1PRO_RD_NOTENOUGHSAMPLES;
+		}
+
+		/* Measure samples that make up patch value */
+		for (i = pat[k].ss; i < (pat[k].ss + pat[k].no); i++) {
+			double measavg = 0.0;
+
+			for (j = 1; j < m->nraw-1; j++) {
+				double val;
+
+				val = multimeas[i][j];
+
+				if (val > highest)
+					highest = val;
+				if (val > satthresh)
+					avgoverth++;
+				measavg += val;
+				pavg[pix][j] += val;
+			}
+			measavg /= (m->nraw-2.0);
+			if (measavg < minavg)
+				minavg = measavg;
+			if (measavg > maxavg)
+				maxavg = measavg;
+
+			/* and the duplicated values at the end */
+			pavg[pix][0]   += multimeas[i][0];
+			pavg[pix][127] += multimeas[i][127];
+		}
+
+		for (j = 0; j < m->nraw; j++) 
+			pavg[pix][j] /= (double)pat[k].no;
+		avgoverth /= (double)pat[k].no;
+
+		if (satthresh > 0.0 && avgoverth >= 10.0)
+			rv |= 2;
+
+		cons = (maxavg - minavg)/white_avg;
+		a1logd(p->log,7,"Patch %d: consistency = %f%%, thresh = %f%%\n",pix,100.0 * cons, 100.0 * patch_cons_thr);
+		if (cons > patch_cons_thr) {
+			a1logd(p->log,2,"Patch recog failed - patch %d is inconsistent (%f%% > %f)\n",pix,cons, patch_cons_thr);
+			rv |= 1;
+		}
+		pix++;
+	}
+
+	if (phighest != NULL)
+		*phighest = highest;
+	if (flags != NULL)
+		*flags = rv;
+
+	free_dvector(slope, 0, nummeas-1);  
+	free_ivector(sizepop, 0, nummeas-1);
+	free_dvector(maxval, -1, m->nraw-1);  
+	free(pat);
+
+	if (rv & 2)
+		a1logd(p->log,2,"Patch recog failed - some patches are saturated\n");
+
+	a1logd(p->log,2,"i1pro_extract_patches_multimeas done, sat = %s, inconsist = %s\n",
+	                  rv & 2 ? "true" : "false", rv & 1 ? "true" : "false");
+
+	return I1PRO_OK;
+}
+#undef BL
+#undef BH
+#undef BW
+
+
+/* Recognise any flashes in the readings, and */
+/* and average their values together as well as summing their duration. */
+/* Return nz on an error */
+/* (Doesn't extract [-1] shielded values, since they have already been used) */
+i1pro_code i1pro_extract_patches_flash(
+	i1pro *p,
+	int *flags,				/* return flags */
+	double *duration,		/* return duration */
+	double *pavg,			/* return patch average [-1 nraw] */
+	double **multimeas,		/* Array of [nummeas][-1 nraw] value to extract from */
+	int nummeas,			/* number of readings made */
+	double inttime			/* Integration time (used to compute duration) */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	int i, j, k, pix;
+	double minval, maxval;		/* min and max input value at wavelength of maximum input */
+	double mean;				/* Mean of the max wavelength band */
+	int maxband;				/* Band of maximum value */
+	double thresh;				/* Level threshold */
+	int fsampl;					/* Index of the first sample over the threshold */
+	int nsampl;					/* Number of samples over the threshold */
+	double *aavg;				/* ambient average [-1 nraw] */
+	double finttime;			/* Flash integration time */
+	int rv = 0;
+#ifdef PATREC_DEBUG
+	double **plot;
+#endif
+
+	a1logd(p->log,2,"i1pro_extract_patches_flash looking for flashes in %d measurements\n",nummeas);
+
+	/* Discover the maximum input value for flash dection */
+	maxval = -1e6;
+	maxband = 0;
+	for (j = 0; j < m->nraw; j ++) {
+		for (i = 0; i < nummeas; i++) {
+			if (multimeas[i][j] > maxval) {
+				maxval = multimeas[i][j];
+				maxband = j;
+			}
+		}
+	}
+
+	if (maxval <= 0.0) {
+		a1logd(p->log,2,"No flashes found in measurement\n");
+		return I1PRO_RD_NOFLASHES;
+	}
+
+	minval = 1e6;
+	mean = 0.0;
+	for (i = 0; i < nummeas; i++) {
+		mean += multimeas[i][maxband];
+		if (multimeas[i][maxband] < minval)
+			minval = multimeas[i][maxband];
+	}
+	mean /= (double)nummeas;
+
+	/* Set the threshold at 5% from mean towards max */
+	thresh = (3.0 * mean + maxval)/4.0;
+	a1logd(p->log,7,"i1pro_extract_patches_flash band %d minval %f maxval %f, mean = %f, thresh = %f\n",maxband,minval,maxval,mean, thresh);
+
+#ifdef PATREC_DEBUG
+	/* Plot out 6 lots of 6 values each */ 
+	plot = dmatrixz(0, 6, 0, nummeas-1);  
+	for (j = maxband -3; j>= 0 && j < (m->nraw-6); j += 100)		/* Do one set around max */
+	{
+		for (k = 0; k < 6; k ++) {
+			for (i = 0; i < nummeas; i++) { 
+				plot[k][i] = multimeas[i][j+k]/maxval;
+			}
+		}
+		for (i = 0; i < nummeas; i++)
+			plot[6][i] = (double)i;
+		printf("Bands %d - %d\n",j,j+5);
+		do_plot6(plot[6], plot[0], plot[1], plot[2], plot[3], plot[4], plot[5], nummeas);
+	}
+	free_dmatrix(plot,0,6,0,nummeas-1);
+#endif	/* PATREC_DEBUG */
+
+#ifdef PATREC_DEBUG
+	/* Plot just the pulses */
+	{
+		int start, end;
+
+		plot = dmatrixz(0, 6, 0, nummeas-1);  
+
+		for(j = 0, start = -1, end = 0;;) {
+
+			for (start = -1, i = end; i < nummeas; i++) {
+				if (multimeas[i][maxband] >= thresh) {
+					if (start < 0)
+						start = i;
+				} else if (start >= 0) {
+					end = i;
+					break;
+				}
+			}
+			if (start < 0)
+				break;
+			start -= 3;
+			if (start < 0)
+				start = 0;
+			end += 4;
+			if (end > nummeas)
+				end = nummeas;
+	
+			for (i = start; i < end; i++, j++) { 
+				int q;
+
+				plot[6][j] = (double)j;
+#ifdef NEVER	/* Plot +/-3 around maxband */
+				for (q = 0, k = maxband -3; k < (maxband+3) && k >= 0 && k < m->nraw; k++, q++) {
+					plot[q][j] = multimeas[i][k]/maxval;
+				}
+#else
+				/* plot max of bands in 6 segments */
+				for (q = 0; q < 6; q++) {
+					int ss, ee;
+
+					plot[q][j] = -1e60;
+					ss = q * (m->nraw/6);
+					ee = (q+1) * (m->nraw/6);
+					for (k = ss; k < ee; k++) {
+						if (multimeas[i][k]/maxval > plot[q][j])
+							plot[q][j] = multimeas[i][k]/maxval;
+					} 
+				}
+#endif
+			}
+		}
+		do_plot6(plot[6], plot[0], plot[1], plot[2], plot[3], plot[4], plot[5], j);
+		free_dmatrix(plot,0,6,0,nummeas-1);
+	}
+#endif
+
+	/* Locate the first sample over the threshold, and the */
+	/* total number of samples in the pulses. */
+	fsampl = -1;
+	for (nsampl = i = 0; i < nummeas; i++) {
+		for (j = 0; j < m->nraw-1; j++) {
+			if (multimeas[i][j] >= thresh)
+				break;
+		}
+		if (j < m->nraw-1) {
+			if (fsampl < 0)
+				fsampl = i;
+			nsampl++;
+		}
+	}
+	a1logd(p->log,7,"Number of flash patches = %d\n",nsampl);
+	if (nsampl == 0)
+		return I1PRO_RD_NOFLASHES;
+
+	/* See if there are as many samples before the first flash */
+	if (nsampl < 6)
+		nsampl = 6;
+
+	/* Average nsample samples of ambient */
+	i = (fsampl-3-nsampl);
+	if (i < 0)
+		return I1PRO_RD_NOAMBB4FLASHES;
+	a1logd(p->log,7,"Ambient samples %d to %d \n",i,fsampl-3);
+	aavg = dvectorz(-1, m->nraw-1);  
+	for (nsampl = 0; i < (fsampl-3); i++) {
+		for (j = 0; j < m->nraw-1; j++)
+			aavg[j] += multimeas[i][j];
+		nsampl++;
+	}
+
+	/* Average all the values over the threshold, */
+	/* and also one either side of flash */
+	for (j = 0; j < m->nraw-1; j++)
+		pavg[j] = 0.0;
+
+	for (k = 0, i = 1; i < (nummeas-1); i++) {
+		int sample = 0;
+		for (j = 0; j < m->nraw-1; j++) {
+			if (multimeas[i-1][j] >= thresh) {
+				sample = 1;
+				break;
+			}
+			if (multimeas[i][j] >= thresh) {
+				sample = 1;
+				break;
+			}
+			if (multimeas[i+1][j] >= thresh) {
+				sample = 1;
+				break;
+			}
+		}
+		if (j < m->nraw-1) {
+			a1logd(p->log,7,"Integrating flash sample no %d \n",i);
+			for (j = 0; j < m->nraw-1; j++)
+				pavg[j] += multimeas[i][j];
+			k++;
+		}
+	}
+	for (j = 0; j < m->nraw-1; j++)
+		pavg[j] = pavg[j]/(double)k - aavg[j]/(double)nsampl;
+
+	a1logd(p->log,7,"Number of flash patches integrated = %d\n",k);
+
+	finttime = inttime * (double)k;
+	if (duration != NULL)
+		*duration = finttime;
+
+	/* Convert to cd/m^2 seconds */
+	for (j = 0; j < m->nraw-1; j++)
+		pavg[j] *= finttime;
+
+	if (flags != NULL)
+		*flags = rv;
+
+	free_dvector(aavg, -1, m->nraw-1);  
+
+	return I1PRO_OK;
+}
+
+
+/* Subtract the black level. */
+/* If Rev E, also adjust according to shielded cells, and linearise. */
+void i1pro_sub_absraw(
+	i1pro *p,
+	int nummeas,			/* Return number of readings measured */
+	double inttime,			/* Integration time used */
+	int gainmode,			/* Gain mode, 0 = normal, 1 = high */
+	double **absraw,		/* Source/Desination array [-1 nraw] */
+	double *sub				/* Black value to subtract [-1 nraw] */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	double gain;
+	int npoly;			/* Number of linearisation coefficients */
+	double *polys;		/* the coeficients */
+	double scale;		/* Absolute scale value */
+	double submax = -1e6;	/* Subtraction value maximum */
+	int i, j;
+	
+	if (gainmode) {
+		gain = m->highgain;
+		npoly = m->nlin1;
+		polys = m->lin1;
+	} else {
+		gain = 1.0;
+		npoly = m->nlin0;
+		polys = m->lin0;
+	}
+	scale = 1.0/(inttime * gain);	/* To scale RevE linearity */
+
+	/* Adjust black to allow for temperature change by using the */
+	/* shielded cell values as a reference. */
+	/* We use a heuristic to compute a zero based scale for adjusting the */
+	/* black. It's not clear why it works best this way, or how */
+	/* dependent on the particular instrument the magic numbers are, */
+	/* but it reduces the black level error from over 10% to about 0.3% */
+	if (p->itype == instI1Pro2) {
+//		double xx[NSEN_MAX], in[NSEN_MAX], res[NSEN_MAX];
+		double asub[NSEN_MAX];
+		double avgscell, zero;
+
+		/* Locate largest of black */
+		for (j = 0; j < m->nraw; j++) {
+			if (sub[j] > submax)
+				submax = sub[j];
+		}
+
+		/* Average the shielded cell value of all the readings */
+		avgscell = 0.0;
+		for (i = 0; i < nummeas; i++)
+			avgscell += absraw[i][-1];
+		avgscell /= (double)nummeas;
+
+		/* Compute scaling zero */
+		zero = 1.144 * 0.5 * (avgscell + sub[-1]);
+
+		/* make sure that the zero point is above any black value */
+		if (zero < (1.01 * avgscell))
+			zero = 1.01 * avgscell;
+		if (zero < (1.01 * sub[-1]))
+			zero = 1.01 * sub[-1];
+		if (zero < (1.01 * submax))
+			zero = 1.01 * submax;
+
+		a1logd(p->log,2,"Black shielded value = %f, Reading shielded value = %f\n",sub[-1], avgscell);
+		/* Compute the adjusted black */
+		for (j = 0; j < m->nraw; j++) {
+#ifdef NEVER
+			/* simple additive correction */
+# pragma message("######### i1pro2 Simple shielded cell temperature correction! ########")
+			asub[j] = sub[j] + avgscell - sub[-1];
+#else
+			/* heuristic scaled correction */
+			asub[j] = zero - (zero - sub[j]) * (zero - avgscell)/(zero - sub[-1]);
+#endif
+		}
+	
+		/* Subtract the black */
+		for (i = 0; i < nummeas; i++) {
+			for (j = 0; j < m->nraw; j++) {
+//				xx[j] = j, in[j] = absraw[i][j];
+
+				absraw[i][j] -= asub[j]; 		/* Subtract adjusted black */
+
+//				 res[j] = absraw[i][j] + (double)((int)(avgscell/20.0)) * 20.0;
+#ifdef ENABLE_NONLINCOR	
+				/* Linearise */
+				{
+					int k;
+					double fval, lval;
+
+					fval = absraw[i][j] / scale;		/* Scale back to sensor value range */
+
+					for (lval = polys[npoly-1], k = npoly-2; k >= 0; k--)
+						lval = lval * fval + polys[k];
+
+					absraw[i][j] = scale * lval;		/* Rescale back to absolute range */
+				}
+#endif
+			}
+#ifdef PLOT_BLACK_SUBTRACT	/* Plot black adjusted levels */
+			printf("black = meas, red = black, green = adjuste black, blue = result\n"); 
+			do_plot6(xx, in, sub, adjsub, res, NULL, NULL, m->nraw);
+#endif
+		}
+
+	/* Rev A-D don't have shielded reference cells */
+	} else {
+	
+		/* For each measurement */
+		for (i = 0; i < nummeas; i++) {
+			for (j = -1; j < m->nraw; j++) {
+				absraw[i][j] -= sub[j];
+			}
+		}
+	}
+}
+
+/* Convert an absraw array from raw wavelengths to output wavelenths */
+/* for a given [std res, high res] and [emis/tras, reflective] mode */
+void i1pro_absraw_to_abswav(
+	i1pro *p,
+	int highres,			/* 0 for std res, 1 for high res */ 
+	int refl,				/* 0 for emis/trans, 1 for reflective */ 
+	int nummeas,			/* Return number of readings measured */
+	double **abswav,		/* Desination array [nwav] */
+	double **absraw			/* Source array [-1 nraw] */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	int i, j, k, cx, sx;
+	double *tm;			/* Temporary array */
+	
+	tm = dvector(0, m->nwav[highres]-1);
+	
+	/* For each measurement */
+	for (i = 0; i < nummeas; i++) {
+
+		/* For each output wavelength */
+		for (cx = j = 0; j < m->nwav[highres]; j++) {
+			double oval = 0.0;
+	
+			/* For each matrix value */
+			sx = m->mtx[highres][refl].index[j];		/* Starting index */
+			for (k = 0; k < m->mtx[highres][refl].nocoef[j]; k++, cx++, sx++) {
+				oval += m->mtx[highres][refl].coef[cx] * absraw[i][sx];
+			}
+			abswav[i][j] = tm[j] = oval;
+		}
+
+		if (p->itype == instI1Pro2) {
+			/* Now apply stray light compensation */ 
+			/* For each output wavelength */
+			for (j = 0; j < m->nwav[highres]; j++) {
+				double oval = 0.0;
+		
+				/* For each matrix value */
+				for (k = 0; k < m->nwav[highres]; k++)
+					oval += m->straylight[highres][j][k] * tm[k];
+				abswav[i][j] = oval;
+			}
+#ifdef PLOT_DEBUG
+			printf("Before & after stray light correction:\n");
+			plot_wav_2(m, highres, tm, abswav[i]);
+#endif /* PLOT_DEBUG */
+		}
+	}
+	free_dvector(tm, 0, m->nwav[highres]-1);
+}
+
+/* Convert an abswav array of output wavelengths to scaled output readings. */
+void i1pro_scale_specrd(
+	i1pro *p,
+	double **outspecrd,		/* Destination */
+	int numpatches,			/* Number of readings/patches */
+	double **inspecrd		/* Source */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	int i, j;
+	
+	/* For each measurement */
+	for (i = 0; i < numpatches; i++) {
+
+		/* For each output wavelength */
+		for (j = 0; j < m->nwav[m->highres]; j++) {
+			outspecrd[i][j] = inspecrd[i][j] * s->cal_factor[m->highres][j];
+		}
+	}
+}
+
+
+/* =============================================== */
+/* Rev E wavelength calibration                    */
+
+/*
+	The Rev E has a wavelength reference LED amd
+	stores a reference raw spectrum of it in its
+	calibrated state, together with an polinomial
+	defining the raw bin no. to wavelength conversion.
+
+	By measuring the wavelength LED and finding
+	the best positional match against the reference
+	spectrum, a CCD bin offset can be computed
+	to compensate for any shift in the optical or
+	physical alignment of spectrum against CCD.
+
+	To use the adjustment, the raw to wave subsampling
+	filters need to be regenerated, and to ensure that
+	the instrument returns readings very close to the
+	manufacturers driver, the same underlying filter
+	creation mathematics needs to be used.
+
+	The manufacturers filter weights are the accumulated
+	third order Lagrange polynomial weights of the
+	integration of a 20 nm wide triange spectrum
+	centered at each output wavelength, discretely
+	integrated between the range of the middle two points
+	of the Lagrange interpolator. The triangle response
+	being integrated has an area of exactly 1.0.
+
+ */
+
+/* Invert a raw2wavlength polinomial equation. */
+/* Use simple Newton inversion will suffice. */
+static double inv_raw2wav(double *polys, int npoly, double inv) {
+	double outv = 560.0, lval, del = 100.0;
+	int i, k;
+
+	for (i = 0; i < 200 && fabs(del) > 1e-7; i++) {
+		for (lval = polys[npoly-1], k = npoly-2; k >= 0; k--) {
+			lval = lval * outv + polys[k];
+		}
+		del = (inv - lval);
+		outv += 0.4 * del;
+	}
+
+	return 128.0 - outv;
+}
+
+/* return the uncalibrated wavelength given a raw bin value */
+/* (Always uses reflective RevE wav2cal) */
+static double i1pro_raw2wav_uncal(i1pro *p, double raw) {
+	i1proimp *m = (i1proimp *)p->m;
+	double ov;
+	int k;
+
+	if (p->itype == instI1Pro2) {
+		raw = 128.0 - raw;		/* Quadratic expects +ve correlation */
+		
+		/* Compute polinomial */
+		for (ov = m->wlpoly1[4-1], k = 4-2; k >= 0; k--)
+			ov = ov * raw + m->wlpoly1[k];
+	} else {
+		co pp;
+
+		if (m->raw2wav == NULL) {
+			a1loge(p->log,1,"i1pro_raw2wav_uncal called when hi-res not inited\n");
+			return I1PRO_INT_ASSERT;
+		}
+
+		pp.p[0] = raw;
+		m->raw2wav->interp(m->raw2wav, &pp);
+		ov = pp.v[0];
+	}
+
+	return ov;
+} 
+
+/* return the calibrated wavelength given a raw bin value for the given mode */
+static double i1pro_raw2wav(i1pro *p, int refl, double raw) {
+	i1proimp *m = (i1proimp *)p->m;
+	double ov;
+	int k;
+
+	if (p->itype == instI1Pro2) {
+		i1pro_state *s = &m->ms[m->mmode];
+
+		/* Correct for CCD offset and scale back to reference */
+		raw = raw - s->wl_led_off + m->wl_led_ref_off;
+
+		raw = 128.0 - raw;		/* Quadratic expects +ve correlation */
+		
+		/* Compute polinomial */
+		if (refl) {
+			for (ov = m->wlpoly1[4-1], k = 4-2; k >= 0; k--)
+				ov = ov * raw + m->wlpoly1[k];
+		} else {
+			for (ov = m->wlpoly2[4-1], k = 4-2; k >= 0; k--)
+				ov = ov * raw + m->wlpoly2[k];
+		}
+	} else {
+		co pp;
+
+		/* If not RevE there is no WL calibration */
+		if (m->raw2wav == NULL) {
+			a1loge(p->log,1,"i1pro_raw2wav_uncal called when hi-res not inited\n");
+			return I1PRO_INT_ASSERT;
+		}
+
+		pp.p[0] = raw;
+		m->raw2wav->interp(m->raw2wav, &pp);
+		ov = pp.v[0];
+	}
+
+	return ov;
+}
+
+/* Powell minimisation contxt for WL calibration */
+typedef struct {
+	double ref_max;			/* reference maximum level */
+	double *wl_ref;		/* Wavlength reference samples */
+	int wl_ref_n;		/* Number of wavelength references */
+	double *wl_meas;	/* Wavelength measurement samples */
+	int wl_meas_n;		/* Number of wavelength measurement samples */
+	int plot;			/* Plot each try */
+} wlcal_cx;
+
+/* Powell minimisation callback function */
+/* Parameters being optimized are magnitude, offset and scale */ 
+static double wlcal_opt1(void *vcx, double tp[]) {
+#ifdef PLOT_DEBUG
+	int pix = 0;
+	double xx[1024];
+	double y1[1024];		/* interpolate ref */
+	double y2[1024];		/* Measurement */
+	double y3[1024];		/* Error */
+#endif
+	wlcal_cx *cx = (wlcal_cx *)vcx;
+	double vv, rv = 0.0;
+	int si, i;
+
+	si = (int)tp[1];
+
+	/* i = Measurement index */
+	for (i = si; i < cx->wl_meas_n; i++) {
+
+		double xv;			/* offset & scaled measurement index */
+		int ix;				/* Lagrange base offset */
+		double yv;
+
+		xv = ((double)i - tp[1]);	/* fitted measurement location in reference no scale */
+
+		ix = ((int)xv) - 1;			/* Reference index of Lagrange for this xv */
+		if (ix < 0)
+			continue;
+		if ((ix + 3) > cx->wl_ref_n)
+			break;
+
+		/* Compute interpolated value of reference using Lagrange: */
+		yv =  cx->wl_ref[ix+0] * (xv-(ix+1)) * (xv-(ix+2)) * (xv-(ix+3))
+		                                             /((0.0-1.0) * (0.0-2.0) * (0.0-3.0))
+		   +  cx->wl_ref[ix+1] * (xv-(ix+0)) * (xv-(ix+2)) * (xv-(ix+3))
+		                                             /((1.0-0.0) * (1.0-2.0) * (1.0-3.0))
+		   +  cx->wl_ref[ix+2] * (xv-(ix+0)) * (xv-(ix+1)) * (xv-(ix+3))
+		                                             /((2.0-0.0) * (2.0-1.0) * (2.0-3.0))
+		   +  cx->wl_ref[ix+3] * (xv-(ix+0)) * (xv-(ix+1)) * (xv-(ix+2))
+		                                             /((3.0-0.0) * (3.0-1.0) * (3.0-2.0));
+		vv = yv - tp[0] * cx->wl_meas[i];
+
+		/* Weight error linearly with magnitude, to emphasise peak error */
+		/* rather than what's happening down in the noise */
+		vv = vv * vv * (yv + 1.0)/(cx->ref_max+1.0);
+
+#ifdef PLOT_DEBUG
+		if (cx->plot) {
+			xx[pix] = (double)i;
+			y1[pix] = yv;
+			y2[pix] = tp[0] * cx->wl_meas[i];
+//			y3[pix] = 2000.0 * (0.02 + yv/cx->ref_max);		/* Weighting */
+			y3[pix] = 0.5 * vv;		/* Error squared */
+			pix++;
+		}
+#endif
+		rv += vv;
+	}
+#ifdef PLOT_DEBUG
+	if (cx->plot) {
+		printf("Params %f %f -> err %f\n", tp[0], tp[1], rv);
+		do_plot(xx, y1, y2, y3, pix);
+	}
+#endif
+//printf("~1 %f %f -> %f\n", tp[0], tp[1], rv);
+	return rv;
+}
+
+#ifdef SALONEINSTLIB
+/* Do a rudimetrary 2d optimization that uses exaustive */
+/* search with hierarchical step sizes */
+int wloptimize(double *cparm,
+	double *ss,
+	double tol,
+	double (*funk)(void *fdata, double tp[]),
+	void *fdata
+) {
+	double range[2][2];			/* [dim][min/max] */
+	double val[2];				/* Current test values */
+	double bfit = 1e38;			/* Current best fit values */
+	int dim;
+
+	for (dim = 0; dim < 2; dim++) {
+		range[dim][0] = cparm[dim] - ss[dim];
+		range[dim][1] = cparm[dim] + ss[dim];
+		val[dim] = cparm[dim];
+	}
+
+	/* Until we reach the tollerance */
+	for (;;) {
+		double mstep = 1e38;
+
+		for (dim = 0; dim < 2; dim++) {
+			double stepsz;
+			stepsz = (range[dim][1] - range[dim][0])/10.0;
+			if (stepsz < mstep)
+				mstep = stepsz;
+
+			/* Search in this dimension */
+			for (val[dim] = range[dim][0]; val[dim] <= range[dim][1]; val[dim] += stepsz) {
+				double fit;
+				fit = funk(fdata, val);
+				if (fit < bfit) {
+					cparm[dim] = val[dim];
+					bfit = fit;	
+				}
+			} 
+			val[dim] = cparm[dim];
+			range[dim][0] = val[dim] - stepsz;
+			range[dim][1] = val[dim] + stepsz;
+		}
+		if (mstep <= tol)
+			break;
+	}
+	return 0;
+}
+#endif /* SALONEINSTLIB */
+
+
+/* Given a raw measurement of the wavelength LED, */
+/* Compute the base offset that best fits it to the reference */
+i1pro_code i1pro2_match_wl_meas(i1pro *p, double *pled_off, double *wlraw) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_code ev = I1PRO_OK;
+	int i;
+	int rpoff, mpoff;		/* Peak offset */
+	int roff, moff;			/* Base index */
+	double lhalf, rhalf;
+	double fwhm;			/* Measured half width */
+	double rmax, mmax;
+	double magscale;
+	double led_off, off_nm;
+
+	/* Do simple match first - locate maximum */
+	rmax = -1e6; 
+	rpoff = -1;
+	for (i = 0; i < m->wl_led_count; i++) {	
+		if (m->wl_led_spec[i] > rmax) {
+			rmax = m->wl_led_spec[i];			/* Max of reference */
+			rpoff = i;
+		}
+	}
+ 
+	mmax = -1e6; 
+	mpoff = -1;
+	for (i = 0; i < m->nraw; i++) {
+		if (wlraw[i] > mmax) {
+			mmax = wlraw[i];					/* Max of measurement */
+			mpoff = i;
+		}
+	}
+ 
+	if (mpoff < 0 || mpoff >= m->nraw) {
+		a1logd(p->log,1,"Couldn't locate WL measurement peak\n");
+		return I1PRO_WL_SHAPE; 
+	}
+
+	/* Check magnitude is sufficient (not sure this is right, typically 5900 > 882) */
+	a1logd(p->log,2,"Measured WL level = %f, minimum needed = %f\n",mmax, m->wl_cal_min_level);
+	if (mmax < m->wl_cal_min_level) {
+		a1logd(p->log,1,"i1pro2_match_wl_meas peak magnitude too low\n");
+		return I1PRO_WL_TOOLOW;
+	}
+		
+	/* Locate the half peak values */
+	for (i = 1; i < mpoff; i++) {
+		if (wlraw[i] > (mmax/2.0)) {	/* Use linear interp */
+			lhalf = (wlraw[i] - mmax/2.0)/(wlraw[i] - wlraw[i-1]);
+			lhalf = lhalf * (i-1.0) + (1.0 - lhalf) * (double)i;
+			break;
+		}
+	}
+	if (i >= mpoff) {
+		a1logd(p->log,1,"Couldn't locate WL left half level\n");
+		return I1PRO_WL_SHAPE; 
+	}
+	for (; i < m->nraw; i++) {
+		if (wlraw[i] < (mmax/2.0)) {	/* Use linear interp */
+			rhalf = (mmax/2.0 - wlraw[i])/(wlraw[i-1] - wlraw[i]);
+			rhalf = rhalf * (i-1.0) + (1.0 - rhalf) * (double)i;
+			break;
+		}
+	}
+	if (i >= m->nraw) {
+		a1logd(p->log,1,"Couldn't locate WL righ half level\n");
+		return I1PRO_WL_SHAPE; 
+	}
+	a1logd(p->log,5,"WL half levels at %f (%f nm) and %f (%f nm)\n",lhalf, i1pro_raw2wav_uncal(p, lhalf), rhalf, i1pro_raw2wav_uncal(p, rhalf));
+	fwhm = i1pro_raw2wav_uncal(p, lhalf) - i1pro_raw2wav_uncal(p, rhalf);
+	a1logd(p->log,3, "WL spectrum fwhm = %f\n",fwhm);
+	if (fwhm < (m->wl_cal_fwhm - m->wl_cal_fwhm_tol) 
+	 || fwhm > (m->wl_cal_fwhm + m->wl_cal_fwhm_tol)) {
+		a1logd(p->log,1,"WL fwhm %f is out of range %f .. %f\n",fwhm,m->wl_cal_fwhm - m->wl_cal_fwhm_tol,m->wl_cal_fwhm + m->wl_cal_fwhm_tol);
+		return I1PRO_WL_SHAPE; 
+	}
+
+	roff = m->wl_led_ref_off;		/* reference raw offset */
+	moff = mpoff - rpoff;			/* rough measured raw offset */
+
+	a1logd(p->log,3, "Preliminary WL peak match at ref base offset %d into measurement\n", moff);
+	
+	magscale = rmax/mmax;		/* Initial scale to make them match */
+
+#ifdef PLOT_DEBUG
+	/* Plot the match */
+	{
+		double xx[1024];
+		double y1[1024];
+		double y2[1024];
+
+		for (i = 0; i < m->nraw; i++) {
+			xx[i] = (double)i;
+			y1[i] = 0.0;
+			if (i >= moff && (i - moff) < m->wl_led_count) {
+				y1[i] = m->wl_led_spec[i- moff];
+			}
+			y2[i] = wlraw[i] * magscale;
+		}
+		printf("Simple WL match, ref = black, meas = red:\n");
+		do_plot(xx, y1, y2, NULL, m->nraw);
+	}
+#endif
+
+	/* Now do a good match */
+	/*
+		Do Lagrange interpolation on the reference curve,
+		and use a minimizer to find the best fit (minimum weighted y error)
+		by optimizing the magnitude, offset and scale.
+	 */
+
+	{
+		wlcal_cx cx;
+		double cparm[2];		/* fit parameters */
+		double ss[2];			/* Search range */
+
+		cparm[0] = magscale;
+		ss[0] = 0.2;
+		cparm[1] = (double)moff;
+		ss[1] = 4.0;		/* == +- 12 nm */
+
+		cx.ref_max = rmax;
+		cx.wl_ref = m->wl_led_spec;
+		cx.wl_ref_n = m->wl_led_count;
+		cx.wl_meas = wlraw; 
+		cx.wl_meas_n = m->nraw;
+//		cx.plot = 1;		/* Plot each trial */
+
+		/* We could use the scale to adjust the whole CCD range, */
+		/* but the manufacturers driver doesn't seem to do this, */
+		/* and it may be making the calibration sensitive to any */
+		/* changes in the WL LED spectrum shape. Instead we minimize */
+		/* the error weighted for the peak of the shape. */
+
+#ifdef SALONEINSTLIB
+		if (wloptimize(cparm, ss, 1e-7, wlcal_opt1, &cx))
+			a1logw(p->log,"wlcal_opt1 failed\n");
+#else
+		if (powell(NULL, 2, cparm, ss, 1e-6, 1000, wlcal_opt1, &cx, NULL, NULL))
+			a1logw(p->log,"wlcal_opt1 failed\n");
+#endif
+		a1logd(p->log,3,"WL best fit parameters: %f %f\n", cparm[0], cparm[1]);
+
+		led_off = cparm[1];
+
+#ifdef PLOT_DEBUG
+		/* Plot the final result */
+		printf("Best WL match, ref = black, meas = red, err = green:\n");
+		cx.plot = 1;
+		wlcal_opt1(&cx, cparm);
+#endif
+
+		/* If we have calibrated on the ambient cap, correct */
+		/* for the emissive vs. reflective raw2wav scaling factor */
+		if (mmax < 2500.0) {
+			double wlraw2 = m->wl_led_ref_off + (double)rpoff;
+			double raw, wlnm, wlraw1, refnm;
+			int k;
+
+			/* Convert from raw to wavelength using poly2 (emission) */
+			raw = 128.0 - wlraw2;		/* Quadratic expects +ve correlation */
+			for (wlnm = m->wlpoly2[4-1], k = 4-2; k >= 0; k--)
+				wlnm = wlnm * raw + m->wlpoly2[k];
+
+			/* Convert from wavelength to raw using poly1 (reflectance) */
+			wlraw1 = inv_raw2wav(m->wlpoly1, 4, wlnm);
+//printf("emiss raw %f -> ref raw %f\n",wlraw2, wlraw1);
+
+			/* Adjust the raw correction to account for measuring it in emissive mode */
+			led_off = led_off + wlraw2 - wlraw1;
+
+			/* Hmm. This is rather suspect. The difference between the white reference */
+			/* calibrated wavelength offset and the ambient cap one is about -0.2788 raw. */
+			/* This is not explained by the poly1 vs. poly2 difference at the WL LED peak */
+			/* at 550 nm. (see above), which amounts to about +0.026, leaving 0.2528 */
+			/* unexplained. It appears the CCD wavelength has a dependence on the */
+			/* angle that the light enters the optics ?? */
+
+			led_off += 0.2528;	/* Hack to make ambient cap correction == white tile correction */
+
+			a1logd(p->log,3,"Adjusted raw correction by %f to account for measurement using ambient cap\n",wlraw2 - wlraw1 + 0.2528);
+		}
+
+		/* Check that the correction is not excessive */
+		off_nm = i1pro_raw2wav_uncal(p, led_off) - i1pro_raw2wav_uncal(p, m->wl_led_ref_off);
+		a1logd(p->log,2, "Final WL offset = %f, correction %f nm\n",led_off, off_nm);
+		if (fabs(off_nm)> m->wl_err_max) {
+			a1logd(p->log,1,"Final WL correction of %f nm is too big\n",off_nm);
+			return I1PRO_WL_ERR2BIG;
+		}
+
+		/* Do a verification plot */
+		/* Plot the measurement against calibrated wavelength, */
+		/* and reference measurement verses reference wavelength */
+	
+#ifdef PLOT_DEBUG
+		{
+			double xx[1024];
+			double y1[1024];		/* interpolate ref */
+			double y2[1024];		/* Measurement */
+			int ii;
+
+			/* i = index into measurement */
+			for (ii = 0, i = m->wl_led_ref_off; i < (m->wl_led_ref_off + m->wl_led_count); i++) {
+				double raw;
+				double mwl;			/* Measurment wavelength */
+				double rraw;		/* Reference raw value */
+				int ix;				/* Lagrange base offset */
+				int k;
+				double yv;
+
+				raw = (double)i;
+				raw = raw - led_off + m->wl_led_ref_off;
+				raw = 128.0 - raw;		/* Quadratic expects +ve correlation */
+				if (mmax < 2500.0) {
+					for (mwl = m->wlpoly2[4-1], k = 4-2; k >= 0; k--)
+						mwl = mwl * raw + m->wlpoly2[k];
+				} else {
+					for (mwl = m->wlpoly1[4-1], k = 4-2; k >= 0; k--)
+						mwl = mwl * raw + m->wlpoly1[k];
+				}
+				xx[ii] = mwl;
+				y1[ii] = cparm[0] * wlraw[i];
+				y2[ii] = 0.0;
+
+				/* Compute the reference index corresponding to this wavelength */
+				rraw = inv_raw2wav(m->wlpoly1, 4, mwl) - (double)m->wl_led_ref_off;
+
+				/* Use Lagrange to interpolate the reference level for this wavelength */
+				ix = ((int)rraw) - 1;	/* Reference index of Lagrange for this xv */
+				if (ix < 0)
+					continue;
+				if ((ix + 3) >= m->wl_led_count)
+					break;
+
+				/* Compute interpolated value of reference using Lagrange: */
+				yv =  m->wl_led_spec[ix+0] * (rraw-(ix+1)) * (rraw-(ix+2)) * (rraw-(ix+3))
+				                                             /((0.0-1.0) * (0.0-2.0) * (0.0-3.0))
+				   +  m->wl_led_spec[ix+1] * (rraw-(ix+0)) * (rraw-(ix+2)) * (rraw-(ix+3))
+				                                             /((1.0-0.0) * (1.0-2.0) * (1.0-3.0))
+				   +  m->wl_led_spec[ix+2] * (rraw-(ix+0)) * (rraw-(ix+1)) * (rraw-(ix+3))
+				                                             /((2.0-0.0) * (2.0-1.0) * (2.0-3.0))
+				   +  m->wl_led_spec[ix+3] * (rraw-(ix+0)) * (rraw-(ix+1)) * (rraw-(ix+2))
+				                                             /((3.0-0.0) * (3.0-1.0) * (3.0-2.0));
+				y2[ii] = yv;
+				ii++;
+			}
+			printf("Verification fit in nm:\n");
+			do_plot(xx, y1, y2, NULL, ii);
+		}
+#endif
+
+		if (pled_off != NULL)
+			*pled_off = led_off;
+	}
+
+	return ev; 
+}
+
+/* Compute standard res. downsampling filters for the given mode */
+/* given the current wl_led_off, and set them as current. */
+i1pro_code i1pro2_compute_wav_filters(i1pro *p, int refl) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	i1pro_code ev = I1PRO_OK;
+	double twidth;		/* Target filter width */
+	int six, eix;		/* raw starting index and one past end index */ 
+	int wlix;			/* current wavelenght index */
+	double *wlcop;		/* This wavelength base filter coefficient pointer */
+	double trh, trx;	/* Triangle height and triangle equation x weighting */
+	int i, j, k;
+
+	a1logd(p->log,2,"i1pro2_compute_wav_filters called with correction %f raw\n",s->wl_led_off - m->wl_led_ref_off);
+
+	twidth = (m->wl_long[0] - m->wl_short[0])/(m->nwav[0] - 1.0);	/* Filter width */
+
+	trh = 1.0/twidth;		/* Triangle height */
+	trx = trh/twidth;		/* Triangle equation x weighting */
+
+	/* Allocate separate space for the calibrated versions, so that the */
+	/* original eeprom values are preserved */
+	if (m->mtx_c[0][refl].index == NULL) {
+
+		if ((m->mtx_c[0][refl].index = (int *)calloc(m->nwav[0], sizeof(int))) == NULL) {
+			a1logd(p->log,1,"i1pro: malloc ndex1 failed!\n");
+			return I1PRO_INT_MALLOC;
+		}
+
+		if ((m->mtx_c[0][refl].nocoef = (int *)calloc(m->nwav[0], sizeof(int))) == NULL) {
+			a1logd(p->log,1,"i1pro: malloc nocoef failed!\n");
+			return I1PRO_INT_MALLOC;
+		}
+
+		if ((m->mtx_c[0][refl].coef = (double *)calloc(16 * m->nwav[0], sizeof(double)))
+		                                                                        == NULL) {
+			a1logd(p->log,1,"i1pro: malloc coef failed!\n");
+			return I1PRO_INT_MALLOC;
+		}
+	}
+
+	/* For each output wavelength */
+	wlcop = m->mtx_c[0][refl].coef;
+	for (wlix = 0; wlix < m->nwav[0]; wlix++) {
+		double owl = wlix/(m->nwav[0]-1.0) * (m->wl_long[0] - m->wl_short[0]) + m->wl_short[0];
+		int lip;	/* Lagrange interpolation position */
+
+//		printf("Generating filter for %.1f nm width %.1f nm\n",owl, twidth);
+
+		/* The filter is based on a triangle centered at owl and extending */
+		/* from owl - twidth to owl + twidth. We therefore need to locate the */
+		/* raw values that will overlap this range */
+
+		/* Do a dumb search from high to low nm */
+		for (six = 0; six < m->nraw; six++) {
+			if (i1pro_raw2wav(p, refl, (double)six) < (owl + twidth))
+				break;
+		}
+		if (six < 2 || six >= m->nraw) {
+			a1loge(p->log,1,"i1pro: compute_wav_filters() six %d out of raw range to cover output filter %.1f nm width %.1f nm\n",six, owl, twidth);
+			return I1PRO_INT_ASSERT;
+		}
+		eix = six;
+		six -= 2;		/* Outside */
+
+		for (; eix < m->nraw; eix++) {
+			if (i1pro_raw2wav(p, refl, (double)eix) <= (owl - twidth))
+				break;
+		}
+		if (eix > (m->nraw - 2) ) {
+			a1loge(p->log,1,"i1pro: compute_wav_filters() eix %d out of raw range to cover output filter %.1f nm width %.1f nm\n",eix, owl, twidth);
+			return I1PRO_INT_ASSERT;
+		}
+		eix += 2;
+
+//		for (j = six; j < eix; j++)
+//			printf("Using raw %d @ %.1f nm\n",j, i1pro_raw2wav(p, refl, (double)j));
+
+		/* Set start index for this wavelength */
+		m->mtx_c[0][refl].index[wlix] = six;
+
+		/* Set number of filter coefficients */
+		m->mtx_c[0][refl].nocoef[wlix] = eix - six;
+
+		if (m->mtx_c[0][refl].nocoef[wlix] > 16) {
+			a1loge(p->log,1,"i1pro: compute_wav_filters() too many filter %d\n",m->mtx_c[0][refl].nocoef[wlix]);
+			return I1PRO_INT_ASSERT;
+		}
+
+		/* Start with zero filter weightings */
+		for (i = 0; i < m->mtx_c[0][refl].nocoef[wlix]; i++)
+			wlcop[i] = 0.0;
+		
+		/* for each Lagrange interpolation position */
+		for (lip = six; (lip + 3) < eix; lip++) {
+			double rwav[4];		/* Relative wavelength of these Lagrange points */
+			double den[4];		/* Denominator values for points */
+			double num[4][4];	/* Numerator polinomial components x^3, x^2, x, 1 */
+			double ilow, ihigh;	/* Integration points */
+		
+			/* Relative wavelengths to owl of each basis point */
+			for (i = 0; i < 4; i++)
+				rwav[i] = i1pro_raw2wav(p, refl, (double)lip + i) - owl;
+//			printf("\n~1 rwav = %f %f %f %f\n", rwav[0], rwav[1], rwav[2], rwav[3]);
+
+			/* Compute each basis points Lagrange denominator values */
+			den[0] = (rwav[0]-rwav[1]) * (rwav[0]-rwav[2]) * (rwav[0]-rwav[3]);
+			den[1] = (rwav[1]-rwav[0]) * (rwav[1]-rwav[2]) * (rwav[1]-rwav[3]);
+			den[2] = (rwav[2]-rwav[0]) * (rwav[2]-rwav[1]) * (rwav[2]-rwav[3]);
+			den[3] = (rwav[3]-rwav[0]) * (rwav[3]-rwav[1]) * (rwav[3]-rwav[2]);
+//			printf("~1 denominators = %f %f %f %f\n", den[0], den[1], den[2], den[3]);
+	
+			/* Compute each basis points Langrange numerator components. */
+			/* We make the numerator have polinomial form, so that it is easy */
+			/* to compute the integral equation from it. */
+			num[0][0] = 1.0;
+			num[0][1] = -rwav[1] - rwav[2] - rwav[3];
+			num[0][2] = rwav[1] * rwav[2] + rwav[1] * rwav[3] + rwav[2] * rwav[3];
+			num[0][3] = -rwav[1] * rwav[2] * rwav[3];
+			num[1][0] = 1.0;
+			num[1][1] = -rwav[0] - rwav[2] - rwav[3];
+			num[1][2] = rwav[0] * rwav[2] + rwav[0] * rwav[3] + rwav[2] * rwav[3];
+			num[1][3] = -rwav[0] * rwav[2] * rwav[3];
+			num[2][0] = 1.0;
+			num[2][1] = -rwav[0] - rwav[1] - rwav[3];
+			num[2][2] = rwav[0] * rwav[1] + rwav[0] * rwav[3] + rwav[1] * rwav[3];
+			num[2][3] = -rwav[0] * rwav[1] * rwav[3];
+			num[3][0] = 1.0;
+			num[3][1] = -rwav[0] - rwav[1] - rwav[2];
+			num[3][2] = rwav[0] * rwav[1] + rwav[0] * rwav[2] + rwav[1] * rwav[2];
+			num[3][3] = -rwav[0] * rwav[1] * rwav[2];
+
+//			printf("~1 num %d = %f %f %f %f\n", 0, num[0][0], num[0][1], num[0][2], num[0][3]);
+//			printf("~1 num %d = %f %f %f %f\n", 1, num[1][0], num[1][1], num[1][2], num[1][3]);
+//			printf("~1 num %d = %f %f %f %f\n", 2, num[2][0], num[2][1], num[2][2], num[2][3]);
+//			printf("~1 num %d = %f %f %f %f\n", 3, num[3][0], num[3][1], num[3][2], num[3][3]);
+
+			/* Now compute the integral difference between the two middle points */
+			/* of the Lagrange over the triangle shape, and accumulate the resulting */
+			/* Lagrange weightings to the filter coefficients. */
+
+			/* For high and then low side of the triangle. */
+			for (k = 0; k < 2; k++) {
+
+				ihigh = rwav[1]; 
+				ilow = rwav[2]; 
+
+				if ((k == 0 && ilow <= twidth && ihigh >= 0.0)		/* Portion is +ve side */
+				 || (k == 1 && ilow <= 0.0 && ihigh >= -twidth)) {	/* Portion is -ve side */
+
+					if (k == 0) {
+						if (ilow < 0.0)
+							ilow = 0.0;
+						if (ihigh > twidth)
+							ihigh = twidth;
+//						printf("~1 doing +ve triangle between %f %f\n",ilow,ihigh);
+					} else {
+						if (ilow < -twidth)
+							ilow = -twidth;
+						if (ihigh > 0.0)
+							ihigh = 0.0;
+//						printf("~1 doing -ve triangle between %f %f\n",ilow,ihigh);
+					}
+
+					/* For each Lagrange point */
+					for (i = 0; i < 4; i++) {
+						double xnum[5];			/* Expanded numerator components */
+						double nvall, nvalh;	/* Numerator low and high values */
+
+						/* Because the y value is a function of x, we need to */
+						/* expand the Lagrange 3rd order polinomial into */
+						/* a 4th order polinomial using the triangle edge equation */
+						/* y = trh +- trx * x */
+						for (j = 0; j < 4; j++)
+							xnum[j] = (k == 0 ? -trx : trx) * num[i][j];
+						xnum[j] = 0.0;
+						for (j = 0; j < 4; j++)
+							xnum[j+1] += trh * num[i][j];
+
+						/* The 4th order equation becomes a 5th order one */
+						/* when we convert it to an integral, ie. x^4 becomes x^5/5 etc. */
+						for (j = 0; j < 4; j++)
+							xnum[j] /= (5.0 - (double)j);	/* Integral denom. */
+
+						/* Compute ihigh integral as 5th order polynomial */
+						nvalh = xnum[0];
+						nvalh = nvalh * ihigh + xnum[1];
+						nvalh = nvalh * ihigh + xnum[2];
+						nvalh = nvalh * ihigh + xnum[3];
+						nvalh = nvalh * ihigh + xnum[4];
+						nvalh = nvalh * ihigh;
+
+						/* Compute ilow integral as 5th order polynomial */
+						nvall = xnum[0];
+						nvall = nvall * ilow + xnum[1];
+						nvall = nvall * ilow + xnum[2];
+						nvall = nvall * ilow + xnum[3];
+						nvall = nvall * ilow + xnum[4];
+						nvall = nvall * ilow;
+
+						/* Compute ihigh - ilow and add to filter weightings */
+						wlcop[lip -six + i] += (nvalh - nvall)/den[i];
+//						printf("~1 k = %d, comp %d weight += %e now %e\n",k,lip-six+i,(nvalh - nvall)/den[i], wlcop[lip-six+i]);
+					}
+				}
+			}
+		}
+//		printf("~1 Weightings for for %.1f nm are:\n",owl);
+//		for (i = 0; i < m->mtx_c[0][refl].nocoef[wlix]; i++)
+//			printf("~1 comp %d weight %e\n",i,wlcop[i]);
+
+		wlcop += m->mtx_c[0][refl].nocoef[wlix];		/* Next group of weightings */
+	}
+#ifdef DEBUG 
+	/* Check against orginal filters */
+	{
+		int ix1, ix1c;
+		double aerr = 0.0;
+
+		a1logd(p->log,2,"Checking gemertated tables against EEProm table\n"); 
+		ix1 = ix1c = 0;
+		for (i = 0; i < m->nwav[0]; i++) {
+			double err;
+			int six, eix;
+
+			if (m->mtx_o.index[i] < m->mtx_o.index[i])
+				six = m->mtx_o.index[i];
+			else
+				six = m->mtx_o.index[i];
+
+			if ((m->mtx_o.index[i] + m->mtx_o.nocoef[i]) > (m->mtx_o.index[i] + m->mtx_o.nocoef[i]))
+				eix = m->mtx_o.index[i] + m->mtx_o.nocoef[i];
+			else
+				eix = m->mtx_o.index[i] + m->mtx_o.nocoef[i];
+//			printf("~1 filter %d from %d to %d\n",i,six,eix);
+
+			err = 0.0;
+			for (j = six; j < eix; j++) {
+		 		double w1, w1c;	
+
+				if (j < m->mtx_o.index[i] || j >= (m->mtx_o.index[i] + m->mtx_o.nocoef[i]))
+					w1 = 0.0;
+				else
+					w1 = m->mtx_o.coef[ix1 + j - m->mtx_o.index[i]];
+				if (j < m->mtx_c[0][refl].index[i]
+				 || j >= (m->mtx_c[0][refl].index[i] + m->mtx_c[0][refl].nocoef[i]))
+					w1c = 0.0;
+				else
+					w1c = m->mtx_c[0][refl].coef[ix1c + j - m->mtx_c[0][refl].index[i]];
+
+				err += fabs(w1 - w1c);
+//				printf("Weight %d, %e should be %e\n", j, w1c, w1);
+			}
+//			printf("Filter %d average weighting error = %f\n",i, err/j);
+			aerr += err/j;
+
+			ix1 += m->mtx_o.nocoef[i];
+			ix1c += m->mtx_c[0][refl].nocoef[i];
+		}
+		a1logd(p->log,2,"Overall average filter weighting change = %f\n",aerr/m->nwav[0]);
+	}
+#endif /* DEBUG */
+
+	/* Switch normal res. to use wavelength calibrated version */
+	m->mtx[0][refl] = m->mtx_c[0][refl];
+
+	return ev;
+}
+	
+
+/* =============================================== */
+#ifdef HIGH_RES
+
+#undef ANALIZE_EXISTING		/* Analize the manufacturers existing filter shape */
+
+/* High res congiguration */
+/* Pick one of these: */
+#define USE_LANCZOS2		/* [def] Use lanczos2 filter shape */
+#undef USE_DECONV			/* [und] Use deconvolution curve */
+#undef USE_GAUSSIAN			/* [und] Use gaussian filter shape*/
+#undef USE_BLACKMAN			/* [und] Use Blackman windowed sinc shape */
+#undef USE_CUBIC			/* [und] Use cubic spline filter */
+
+#undef COMPUTE_DISPERSION	/* Compute slit & optics dispersion from red laser data */
+
+#ifdef NEVER
+/* Plot the matrix coefficients */
+static void i1pro_debug_plot_mtx_coef(i1pro *p) {
+	i1proimp *m = (i1proimp *)p->m;
+	int i, j, k, cx, sx;
+	double *xx, *ss;
+	double **yy;
+
+	xx = dvectorz(-1, m->nraw-1);		/* X index */
+	yy = dmatrixz(0, 5, -1, m->nraw-1);	/* Curves distributed amongst 5 graphs */
+	
+	for (i = 0; i < m->nraw; i++)
+		xx[i] = i;
+
+	/* For each output wavelength */
+	for (cx = j = 0; j < m->nwav; j++) {
+		i = j % 5;
+
+//		printf("Out wave = %d\n",j);
+		/* For each matrix value */
+		sx = m->mtx_index[j];		/* Starting index */
+//		printf("start index = %d, nocoef %d\n",sx,m->mtx_nocoef[j]);
+		for (k = 0; k < m->mtx_nocoef[j]; k++, cx++, sx++) {
+//			printf("offset %d, coef ix %d val %f from ccd %d\n",k, cx, m->mtx_coef[cx], sx);
+			yy[5][sx] += 0.5 * m->mtx_coef[cx];
+			yy[i][sx] = m->mtx_coef[cx];
+		}
+	}
+
+	do_plot6(xx, yy[0], yy[1], yy[2], yy[3], yy[4], yy[5], m->nraw);
+	free_dvector(xx, -1, m->nraw-1);
+	free_dmatrix(yy, 0, 2, -1, m->nraw-1);
+}
+#endif
+
+#ifdef COMPUTE_DISPERSION
+
+/* Gausian filter implementation */
+/* parameters are amplidude [0], center wavelength [1], std. dev. [2] */
+static double gaussf(double tp[], double x) {
+	double y;
+
+	x = (x - tp[1])/(sqrt(2.0) * tp[2]);
+	y = tp[0] * exp(-(x * x));
+
+	return y;
+}
+
+/* Gausian integral implementatation */
+/* parameters are amplidude [0], center wavelength [1], std. dev. [2] */
+/* return an aproximation to the intergral between w1 and w2 */
+static double gaussint(double tp[], double w1, double w2) {
+	int j, nn;
+	double lw, ll, vv;
+
+	/* Intergate in 0.1 nm increments */
+	nn = (int)(fabs(w2 - w1)/0.1 + 0.5);
+
+	lw = w1;
+	ll = gaussf(tp, lw);
+	vv = 0.0;
+	for (j = 0; j < nn; j++) { 
+		double cw, cl;
+		cw = w1 + (j+1)/(nn +1.0) * (w2 - w1);
+		cl = gaussf(tp, cw);
+		vv += 0.5 * (cl + ll) * (lw - cw);
+		ll = cl;
+		lw = cw;
+	}
+	return fabs(vv);
+}
+
+/* Powell minimisation context */
+typedef struct {
+	double nsp;			/* Number of samples of dispersion data */
+	double *llv;		/* [nsamp] laser values */
+	double *lwl;		/* [nsamp+1] CCD boundary wavelegths */
+} hropt_cx;
+
+/* Powell minimisation callback function */
+/* to match dispersion data */
+static double hropt_opt1(void *vcx, double tp[]) {
+	hropt_cx *cx = (hropt_cx *)vcx;
+	double rv = 0.0;
+	int i, j;
+
+	/* For each CCD sample */
+	for (i = 0; i < cx->nsp; i++) {
+		double vv;
+
+		/* Actual CCD integrated value */
+		vv = cx->llv[i] * (cx->lwl[i] - cx->lwl[i+1]);
+		/* Computed intergral with current curve */
+		vv -= gaussint(tp, cx->lwl[i], cx->lwl[i+1]);
+		rv += vv * vv;
+	}
+//	printf("~1 params %f %f %f, rv = %f\n", tp[0],tp[1],tp[2],rv);
+	return rv;
+}
+
+#endif /* COMPUTE_DISPERSION */
+
+/* Filter shape point */
+typedef	struct {
+	double wl, we;
+} i1pro_fs;
+
+/* Filter cooeficient values */
+typedef struct {
+	int ix;				/* Raw index */
+	double we;			/* Weighting */
+} i1pro_fc;
+
+/* Wavelenth calibration crossover point information */
+typedef struct {
+	double wav;				/* Wavelegth of point */
+	double raw;				/* Raw index of point */		
+	double wei;				/* Weigting of the point */
+} i1pro_xp;
+
+/* Linearly interpolate the filter shape */
+static double lin_fshape(i1pro_fs *fsh, int n, double x) {
+	int i;
+	double y;
+
+	if (x <= fsh[0].wl)
+		return fsh[0].we;
+	else if (x >= fsh[n-1].wl)
+		return fsh[n-1].we;
+
+	for (i = 0; i < (n-2); i++)
+		if (x >= fsh[i].wl && x <= fsh[i+1].wl)
+			break;
+
+	x = (x - fsh[i].wl)/(fsh[i+1].wl - fsh[i].wl);
+	y = fsh[i].we + (fsh[i+1].we - fsh[i].we) * x;
+	
+	return y;
+}
+
+/* Generate a sample from a lanczos2 filter shape */
+/* wi is the width of the filter */
+static double lanczos2(double wi, double x) {
+	double y;
+
+#ifdef USE_DECONV
+	/* For 3.333, created by i1deconv.c */
+	static i1pro_fs fshape[49] = {
+		{ -7.200000, 0.0 },
+		{ -6.900000, 0.013546 },
+		{ -6.600000, 0.035563 },
+		{ -6.300000, 0.070500 },
+		{ -6.000000, 0.106543 },
+		{ -5.700000, 0.148088 },
+		{ -5.400000, 0.180888 },
+		{ -5.100000, 0.186637 },
+		{ -4.800000, 0.141795 },
+		{ -4.500000, 0.046101 },
+		{ -4.200000, -0.089335 },
+		{ -3.900000, -0.244652 },
+		{ -3.600000, -0.391910 },
+		{ -3.300000, -0.510480 },
+		{ -3.000000, -0.573177 },
+		{ -2.700000, -0.569256 },
+		{ -2.400000, -0.489404 },
+		{ -2.100000, -0.333957 },
+		{ -1.800000, -0.116832 },
+		{ -1.500000, 0.142177 },
+		{ -1.200000, 0.411639 },
+		{ -0.900000, 0.658382 },
+		{ -0.600000, 0.851521 },
+		{ -0.300000, 0.967139 },
+		{ 0.000000, 1.000000 },
+		{ 0.300000, 0.967139 },
+		{ 0.600000, 0.851521 },
+		{ 0.900000, 0.658382 },
+		{ 1.200000, 0.411639 },
+		{ 1.500000, 0.142177 },
+		{ 1.800000, -0.116832 },
+		{ 2.100000, -0.333957 },
+		{ 2.400000, -0.489404 },
+		{ 2.700000, -0.569256 },
+		{ 3.000000, -0.573177 },
+		{ 3.300000, -0.510480 },
+		{ 3.600000, -0.391910 },
+		{ 3.900000, -0.244652 },
+		{ 4.200000, -0.089335 },
+		{ 4.500000, 0.046101 },
+		{ 4.800000, 0.141795 },
+		{ 5.100000, 0.186637 },
+		{ 5.400000, 0.180888 },
+		{ 5.700000, 0.148088 },
+		{ 6.000000, 0.106543 },
+		{ 6.300000, 0.070500 },
+		{ 6.600000, 0.035563 },
+		{ 6.900000, 0.013546 },
+		{ 7.200000, 0.0 }
+	};
+
+	return lin_fshape(fshape, 49, x);
+#endif
+
+#ifdef USE_GAUSSIAN
+	/* gausian */
+	wi = wi/(2.0 * sqrt(2.0 * log(2.0)));	/* Convert width at half max to std. dev. */
+    x = x/(sqrt(2.0) * wi);
+//    y = 1.0/(wi * sqrt(2.0 * DBL_PI)) * exp(-(x * x));		/* Unity area */
+    y = exp(-(x * x));											/* Center at 1.0 */
+#endif
+
+#ifdef USE_LANCZOS2
+	/* lanczos2 */
+	x = fabs(1.0 * x/wi);
+	if (x >= 2.0)
+		return 0.0; 
+	if (x < 1e-5)
+		return 1.0;
+	y = sin(DBL_PI * x)/(DBL_PI * x) * sin(DBL_PI * x/2.0)/(DBL_PI * x/2.0);
+#endif
+
+#ifdef USE_BLACKMAN		/* Use Blackman windowed sinc shape */
+	double xx = x, w;
+	double a0, a1, a2, a3;
+	double bb, cc;
+
+	xx = fabs(1.0 * x/wi);
+	if (xx >= 2.0)
+		return 0.0; 
+	if (xx < 1e-5)
+		return 1.0;
+	y = sin(DBL_PI * xx)/(DBL_PI * xx);	/* sinc */
+
+	/* gausian window */
+//	wi *= 1.5;
+//	wi = wi/(2.0 * sqrt(2.0 * log(2.0)));	/* Convert width at half max to std. dev. */
+//	x = x/(sqrt(2.0) * wi);
+//	w = exp(-(x * x));
+
+	xx = (xx/4.0 + 0.5);		/* Convert to standard window cos() range */
+
+	/* Hamming window */
+//	a0 = 0.54; a1 = 0.46;
+//	w = a0 - a1 * cos(2.0 * DBL_PI * xx);
+
+	/* Blackman window */
+	a0 = 7938.0/18608.0; a1 = 9240.0/18608.0; a2 = 1430.0/18608.0;
+	w = a0 - a1 * cos(2.0 * DBL_PI * xx) + a2 * cos(4.0 * DBL_PI * xx);
+
+	/* Nuttall window */
+//	a0 = 0.355768; a1=0.487396; a2=0.144232; a3=0.012604;
+//	w = a0 - a1 * cos(2.0 * DBL_PI * xx) + a2 * cos(4.0 * DBL_PI * xx) - a3 * cos(6.0 * DBL_PI * xx);
+
+	/* Blackman Harris window */
+//	a0=0.35875; a1=0.48829; a2=0.14128; a3=0.01168;
+//	w = a0 - a1 * cos(2.0 * DBL_PI * xx) + a2 * cos(4.0 * DBL_PI * xx) - a3 * cos(6.0 * DBL_PI * xx);
+
+	/* Blackman Nuttall window */
+//	a0=0.3635819; a1=0.4891775; a2=0.1365995; a3=0.0106411;
+//	w = a0 - a1 * cos(2.0 * DBL_PI * xx) + a2 * cos(4.0 * DBL_PI * xx) - a3 * cos(6.0 * DBL_PI * xx);
+
+	y *= w;
+#endif
+#ifdef USE_CUBIC		/* Use cubic sline */
+	double xx = x;
+	double bb, cc;
+
+	xx = fabs(1.0 * x/wi);
+
+//	bb = cc = 1.0/3.0;		/* Mitchell */
+	bb = 0.5;
+	cc = 0.5;
+	xx *= 1.2;
+
+	if (xx < 1.0) {
+		y = ( 12.0 -  9.0 * bb - 6.0 * cc) * xx * xx * xx
+		  + (-18.0 + 12.0 * bb + 6.0 * cc) * xx * xx
+		  + (  6.0 -  2.0 * bb);
+		y /= (6.0 - 2.0 * bb);
+	} else if (xx < 2.0) {
+		y = ( -1.0 * bb -  6.0 * cc) * xx * xx * xx
+		  + (  6.0 * bb + 30.0 * cc) * xx * xx
+		  + (-12.0 * bb - 48.0 * cc) * xx 
+		  + (  8.0 * bb + 24.0 * cc);
+		y /= (6.0 - 2.0 * bb);
+	} else {
+		y = 0.0;
+	}
+#endif
+	return y;
+}
+
+#if defined(__APPLE__) && defined(__POWERPC__)
+
+/* Workaround for a ppc gcc 3.3 optimiser bug... */
+static int gcc_bug_fix(int i) {
+	static int nn;
+	nn += i;
+	return nn;
+}
+#endif	/* APPLE */
+
+/* Create or re-create high resolution mode references */
+i1pro_code i1pro_create_hr(i1pro *p) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_code ev = I1PRO_OK;
+	int refl;
+	int i, j, k, cx, sx;
+	
+	/* If we don't have any way of converting raw2wav (ie. RevE polinomial equations), */
+	/* use the orginal filters to figure this out. */
+	if (p->itype != instI1Pro2 && m->raw2wav == NULL) {
+		i1pro_fc coeff[100][16];	/* Existing filter cooefficients */
+		i1pro_xp xp[101];			/* Crossover points each side of filter */
+		i1pro_fs fshape[100 * 16];  /* Existing filter shape */
+		int ncp = 0;				/* Number of shape points */
+
+		/* Convert the native filter cooeficient representation to */
+		/* a 2D array we can randomly index. */
+		for (cx = j = 0; j < m->nwav[0]; j++) { /* For each output wavelength */
+			if (j >= 100) {	/* Assert */
+				a1loge(p->log,1,"i1pro: number of output wavelenths is > 100\n");
+				return I1PRO_INT_ASSERT;
+			}
+
+			/* For each matrix value */
+			sx = m->mtx_o.index[j];		/* Starting index */
+			for (k = 0; k < m->mtx_o.nocoef[j]; k++, cx++, sx++) {
+				if (k >= 16) {	/* Assert */
+					a1loge(p->log,1,"i1pro: number of filter coeefs is > 16\n");
+					return I1PRO_INT_ASSERT;
+				}
+
+				coeff[j][k].ix = sx;
+				coeff[j][k].we = m->mtx_o.coef[cx];
+//				printf("Output %d, filter %d weight = %e\n",j,k,coeff[j][k].we);
+			}
+		}
+
+#ifdef HIGH_RES_PLOT
+		/* Plot original re-sampling curves */
+		{
+			double *xx, *ss;
+			double **yy;
+
+			xx = dvectorz(-1, m->nraw-1);		/* X index */
+			yy = dmatrixz(0, 5, -1, m->nraw-1);	/* Curves distributed amongst 5 graphs */
+			
+			for (i = 0; i < m->nraw; i++)
+				xx[i] = i;
+
+			/* For each output wavelength */
+			for (j = 0; j < m->nwav[0]; j++) {
+				i = j % 5;
+
+				/* For each matrix value */
+				for (k = 0; k < m->mtx_o.nocoef[j]; k++) {
+					yy[5][coeff[j][k].ix] += 0.5 * coeff[j][k].we;
+					yy[i][coeff[j][k].ix] = coeff[j][k].we;
+				}
+			}
+
+			printf("Original wavelength sampling curves:\n");
+			do_plot6(xx, yy[0], yy[1], yy[2], yy[3], yy[4], yy[5], m->nraw);
+			free_dvector(xx, -1, m->nraw-1);
+			free_dmatrix(yy, 0, 2, -1, m->nraw-1);
+		}
+#endif /* HIGH_RES_PLOT */
+
+		/* Compute the crossover points between each filter */
+		for (i = 0; i < (m->nwav[0]-1); i++) {
+			double den, y1, y2, y3, y4, yn, xn;	/* Location of intersection */
+
+			/* between filter i and i+1, we want to find the two */
+			/* raw indexes where the weighting values cross over */
+			/* Do a brute force search to avoid making assumptions */
+			/* about the raw order */
+			for (j = 0; j < (m->mtx_o.nocoef[i]-1); j++) {
+				for (k = 0; k < (m->mtx_o.nocoef[i+1]-1); k++) {
+//					printf("~1 checking %d, %d: %d = %d, %d = %d\n",j,k, coeff[i][j].ix, coeff[i+1][k].ix, coeff[i][j+1].ix, coeff[i+1][k+1].ix);
+					if (coeff[i][j].ix == coeff[i+1][k].ix
+					 && coeff[i][j+1].ix == coeff[i+1][k+1].ix
+					 && coeff[i][j].we > 0.0 && coeff[i][j+1].we > 0.0
+					 && coeff[i][k].we > 0.0 && coeff[i][k+1].we > 0.0
+					 && ((   coeff[i][j].we >= coeff[i+1][k].we
+					 	 && coeff[i][j+1].we <= coeff[i+1][k+1].we)
+					  || (   coeff[i][j].we <= coeff[i+1][k].we
+					 	 && coeff[i][j+1].we >= coeff[i+1][k+1].we))) {
+//						printf("~1 got it at %d, %d: %d = %d, %d = %d\n",j,k, coeff[i][j].ix, coeff[i+1][k].ix, coeff[i][j+1].ix, coeff[i+1][k+1].ix);
+						goto gotit;
+					}
+				}
+			}
+		gotit:;
+			if (j >= m->mtx_o.nocoef[i]) {	/* Assert */
+				a1loge(p->log,1,"i1pro: failed to locate crossover between resampling filters\n");
+				return I1PRO_INT_ASSERT;
+			}
+//			printf("~1 %d: overlap at %d, %d: %f : %f, %f : %f\n",i, j,k, coeff[i][j].we, coeff[i+1][k].we, coeff[i][j+1].we, coeff[i+1][k+1].we);
+
+			/* Compute the intersection of the two line segments */
+			y1 = coeff[i][j].we;
+			y2 = coeff[i][j+1].we;
+			y3 = coeff[i+1][k].we;
+			y4 = coeff[i+1][k+1].we;
+			den = -y4 + y3 + y2 - y1;
+			yn = (y2 * y3 - y1 * y4)/den;
+			xn = (y3 - y1)/den;
+//			printf("~1 den = %f, yn = %f, xn = %f\n",den,yn,xn);
+			xp[i+1].wav = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], i + 0.5);
+			xp[i+1].raw = (1.0 - xn) * coeff[i][j].ix + xn * coeff[i][j+1].ix;
+			xp[i+1].wei = yn;
+//			printf("Intersection %d: wav %f, raw %f, wei %f\n",i+1,xp[i+1].wav,xp[i+1].raw,xp[i+1].wei);
+//			printf("\n");
+		}
+
+		/* Add the two points for the end filters */
+		{
+			double x5, x6, y5, y6;				/* Points on intesecting line */
+			double den, y1, y2, y3, y4, yn, xn;	/* Location of intersection */
+
+			x5 = xp[1].raw;
+			y5 = xp[1].wei;
+			x6 = xp[2].raw;
+			y6 = xp[2].wei;
+
+			/* Search for possible intersection point with first curve */
+			/* Create equation for line from next two intersection points */
+			for (j = 0; j < (m->mtx_o.nocoef[0]-1); j++) {
+				/* Extrapolate line to this segment */
+				y3 = y5 + (coeff[0][j].ix - x5)/(x6 - x5) * (y6 - y5);
+				y4 = y5 + (coeff[0][j+1].ix - x5)/(x6 - x5) * (y6 - y5);
+				/* This segment of curve */
+				y1 = coeff[0][j].we;
+				y2 = coeff[0][j+1].we;
+				if ( ((  y1 >= y3 && y2 <= y4)		/* Segments overlap */
+				   || (  y1 <= y3 && y2 >= y4))
+				  && ((    coeff[0][j].ix < x5 && coeff[0][j].ix < x6
+				        && coeff[0][j+1].ix < x5 && coeff[0][j+1].ix < x6)
+				   || (    coeff[0][j+1].ix > x5 && coeff[0][j+1].ix > x6
+					    && coeff[0][j].ix > x5 && coeff[0][j].ix > x6))) {
+					break;
+				}
+			}
+			if (j >= m->mtx_o.nocoef[0]) {	/* Assert */
+				a1loge(p->log,1,"i1pro: failed to end crossover\n");
+				return I1PRO_INT_ASSERT;
+			}
+	
+			den = -y4 + y3 + y2 - y1;
+			yn = (y2 * y3 - y1 * y4)/den;
+			xn = (y3 - y1)/den;
+//			printf("~1 den = %f, yn = %f, xn = %f\n",den,yn,xn);
+			xp[0].wav = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], -0.5);
+			xp[0].raw = (1.0 - xn) * coeff[0][j].ix + xn * coeff[0][j+1].ix;
+			xp[0].wei = yn;
+//			printf("End 0 intersection %d: wav %f, raw %f, wei %f\n",0,xp[0].wav,xp[0].raw,xp[0].wei);
+//			printf("\n");
+
+			x5 = xp[m->nwav[0]-2].raw;
+			y5 = xp[m->nwav[0]-2].wei;
+			x6 = xp[m->nwav[0]-1].raw;
+			y6 = xp[m->nwav[0]-1].wei;
+
+//			printf("~1 x5 %f, y5 %f, x6 %f, y6 %f\n",x5,y5,x6,y6);
+			/* Search for possible intersection point with first curve */
+			/* Create equation for line from next two intersection points */
+			for (j = 0; j < (m->mtx_o.nocoef[0]-1); j++) {
+				/* Extrapolate line to this segment */
+				y3 = y5 + (coeff[m->nwav[0]-1][j].ix - x5)/(x6 - x5) * (y6 - y5);
+				y4 = y5 + (coeff[m->nwav[0]-1][j+1].ix - x5)/(x6 - x5) * (y6 - y5);
+				/* This segment of curve */
+				y1 = coeff[m->nwav[0]-1][j].we;
+				y2 = coeff[m->nwav[0]-1][j+1].we;
+				if ( ((  y1 >= y3 && y2 <= y4)		/* Segments overlap */
+				   || (  y1 <= y3 && y2 >= y4))
+				  && ((    coeff[m->nwav[0]-1][j].ix < x5 && coeff[m->nwav[0]-1][j].ix < x6
+				        && coeff[m->nwav[0]-1][j+1].ix < x5 && coeff[m->nwav[0]-1][j+1].ix < x6)
+				   || (    coeff[m->nwav[0]-1][j+1].ix > x5 && coeff[m->nwav[0]-1][j+1].ix > x6
+					    && coeff[m->nwav[0]-1][j].ix > x5 && coeff[m->nwav[0]-1][j].ix > x6))) {
+					break;
+				}
+			}
+			if (j >= m->mtx_o.nocoef[m->nwav[0]-1]) {	/* Assert */
+				a1loge(p->log,1,"i1pro: failed to end crossover\n");
+				return I1PRO_INT_ASSERT;
+			}
+			den = -y4 + y3 + y2 - y1;
+			yn = (y2 * y3 - y1 * y4)/den;
+			xn = (y3 - y1)/den;
+//			printf("~1 den = %f, yn = %f, xn = %f\n",den,yn,xn);
+			xp[m->nwav[0]].wav = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], m->nwav[0]-0.5);
+			xp[m->nwav[0]].raw = (1.0 - xn) * coeff[m->nwav[0]-1][j].ix + xn * coeff[m->nwav[0]-1][j+1].ix;
+			xp[m->nwav[0]].wei = yn;
+//			printf("End 36 intersection %d: wav %f, raw %f, wei %f\n",m->nwav[0]+1,xp[m->nwav[0]].wav,xp[m->nwav[0]].raw,xp[m->nwav[0]].wei);
+//			printf("\n");
+		}
+
+#ifdef HIGH_RES_DEBUG
+		/* Check to see if the area of each filter curve is the same */
+		/* (yep, width times 2 * xover height is close to 1.0, and the */
+		/*  sum of the weightings is exactly 1.0) */
+		for (i = 0; i < m->nwav[0]; i++) {
+			double area1, area2;
+			area1 = fabs(xp[i].raw - xp[i+1].raw) * (xp[i].wei + xp[i+1].wei);
+
+			area2 = 0.0;
+			for (j = 0; j < (m->mtx_o.nocoef[i]); j++)
+			    area2 += coeff[i][j].we;
+
+		printf("Area of curve %d = %f, %f\n",i,area1, area2);
+		}
+#endif /* HIGH_RES_DEBUG */
+
+		/* From our crossover data, create a rspl that maps raw CCD index */
+		/* value into wavelegth. */
+		{
+			co sd[101];				/* Scattered data points */
+			datai glow, ghigh;
+			datao vlow, vhigh;
+			int gres[1];
+			double avgdev[1];
+
+			if ((m->raw2wav = new_rspl(RSPL_NOFLAGS, 1, 1)) == NULL) {
+				a1logd(p->log,1,"i1pro: creating rspl for high res conversion failed\n");
+				return I1PRO_INT_NEW_RSPL_FAILED;
+			}
+
+			vlow[0] = 1e6;
+			vhigh[0] = -1e6;
+			for (i = 0; i < (m->nwav[0]+1); i++) {
+				sd[i].p[0] = xp[i].raw;
+				sd[i].v[0] = xp[i].wav;
+				
+				if (sd[i].v[0] < vlow[0])
+					vlow[0] = sd[i].v[0];
+				if (sd[i].v[0] > vhigh[0])
+					vhigh[0] = sd[i].v[0];
+			}
+			glow[0] = 0.0;
+			ghigh[0] = 127.0;
+			gres[0] = 128;
+			avgdev[0] = 0.0;
+			
+			m->raw2wav->fit_rspl(m->raw2wav, 0, sd, m->nwav[0]+1, glow, ghigh, gres, vlow, vhigh, 0.5, avgdev, NULL);
+
+#ifdef HIGH_RES_PLOT
+		/* Plot raw to wav lookup */
+		{
+			double *xx, *yy, *y2;
+
+			xx = dvector(0, m->nwav[0]+1);		/* X index = raw bin */
+			yy = dvector(0, m->nwav[0]+1);		/* Y = nm */
+			y2 = dvector(0, m->nwav[0]+1);		/* Y = nm */
+			
+			for (i = 0; i < (m->nwav[0]+1); i++) {
+				co pp;
+				double iv, v1, v2;
+				xx[i] = xp[i].raw;
+				yy[i] = xp[i].wav;
+
+				pp.p[0] = xp[i].raw;
+				m->raw2wav->interp(m->raw2wav, &pp);
+				y2[i] = pp.v[0];
+			}
+
+			printf("CCD bin to wavelength mapping of original filters + rspl:\n");
+			do_plot6(xx, yy, y2, NULL, NULL, NULL, NULL, m->nwav+1);
+			free_dvector(xx, 0, m->nwav[0]+1);
+			free_dvector(yy, 0, m->nwav[0]+1);
+			free_dvector(y2, 0, m->nwav[0]+1);
+		}
+#endif /* HIGH_RES_PLOT */
+		}
+	}
+
+#ifdef ANALIZE_EXISTING
+	/* Convert each weighting curves values into normalized values and */
+	/* accumulate into a single curve. */
+	if (!m->hr_inited) {
+		for (i = 0; i < m->nwav[0]; i++) {
+			double cwl;		/* center wavelegth */
+			double weight = 0.0;
+
+			for (j = 0; j < (m->mtx_o.nocoef[i]); j++) {
+				double w1, w2, cellw;
+
+				/* Translate CCD cell boundaries index to wavelength */
+				w1 = i1pro_raw2wav_uncal(p, (double)coeff[i][j].ix - 0.5);
+
+				w2 = i1pro_raw2wav_uncal(p, (double)coeff[i][j].ix + 0.5);
+
+				cellw = fabs(w2 - w1);
+
+				cwl = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], i);
+
+				/* Translate CCD index to wavelength */
+				fshape[ncp].wl = i1pro_raw2wav_uncal(p, (double)coeff[i][j].ix) - cwl;
+				fshape[ncp].we = coeff[i][j].we / (0.09 * cellw);
+				ncp++;
+			}
+		}
+
+		/* Now sort by wavelength */
+#define HEAP_COMPARE(A,B) (A.wl < B.wl)
+		HEAPSORT(i1pro_fs, fshape, ncp)
+#undef HEAP_COMPARE
+
+		/* Strip out leading zero's */
+		for (i = 0; i < ncp; i++) {
+			if (fshape[i].we != 0.0)
+				break;
+		}
+		if (i > 1 && i < ncp) {
+			memmove(&fshape[0], &fshape[i-1], sizeof(i1pro_fs) * (ncp - i + 1));
+			ncp = ncp - i + 1;
+			for (i = 0; i < ncp; i++) {
+				if (fshape[i].we != 0.0)
+					break;
+			}
+		}
+
+#ifdef HIGH_RES_PLOT
+		/* Plot the shape of the accumulated curve */
+		{
+			double *x1 = dvectorz(0, ncp-1);
+			double *y1 = dvectorz(0, ncp-1);
+
+			for (i = 0; i < ncp; i++) {
+				double x;
+				x1[i] = fshape[i].wl;
+				y1[i] = fshape[i].we;
+			}
+			printf("Accumulated curve:\n");
+			do_plot(x1, y1, NULL, NULL, ncp);
+
+			free_dvector(x1, 0, ncp-1);
+			free_dvector(y1, 0, ncp-1);
+		}
+#endif /* HIGH_RES_PLOT */
+
+#ifdef HIGH_RES_DEBUG
+		/* Check that the orginal filter sums to a constant */
+		{
+			double x, sum;
+
+			for (x = 0.0; x < 10.0; x += 0.2) {
+				sum = 0;
+				sum += lin_fshape(fshape, ncp, x - 30.0);
+				sum += lin_fshape(fshape, ncp, x - 20.0);
+				sum += lin_fshape(fshape, ncp, x - 10.0);
+				sum += lin_fshape(fshape, ncp, x -  0.0);
+				sum += lin_fshape(fshape, ncp, x + 10.0);
+				sum += lin_fshape(fshape, ncp, x + 20.0);
+				printf("Offset %f, sum %f\n",x, sum);
+			}
+		}
+#endif /* HIGH_RES_DEBUG */
+	}
+#endif /* ANALIZE_EXISTING */
+
+#ifdef COMPUTE_DISPERSION
+	if (!m->hr_inited) {
+		/* Fit our red laser CCD data to a slit & optics Gaussian dispersion model */
+		{
+			double spf[3];				/* Spread function parameters */
+
+			/* Measured CCD values of red laser from CCD indexes 29 to 48 inclusive */
+			/* (It would be nice to have similar data from a monochromic source */
+			/*  at other wavelegths such as green and blue!) */
+			double llv[20] = {
+				53.23,
+				81.3,
+				116.15,
+				176.16,
+				305.87,
+				613.71,
+				8500.52,
+				64052.0,
+				103134.13,
+				89154.03,
+				21742.89,
+				1158.86,
+				591.44,
+				369.75,
+				241.01,
+				166.48,
+				126.79,
+				97.76,
+				63.88,
+				46.46
+			};
+			double lwl[21];		/* Wavelegth of boundary between CCD cells */ 
+			double ccd;
+			hropt_cx cx;
+			double ss[3];
+
+			/* Add CCD boundary wavelengths to dispersion data */
+			for (ccd = 29.0 - 0.5, i = 0; i < 21; i++, ccd += 1.0) {
+				/* Translate CCD cell boundaries index to wavelength */
+				lwl[i] = i1pro_raw2wav_uncal(p, ccd);
+			}
+
+			/* Fit a gausian to it */
+			cx.nsp = 20;
+			cx.llv = llv;
+			cx.lwl = lwl;
+
+			/* parameters are amplidude [0], center wavelength [1], std. dev. [2] */
+			spf[0] = 115248.0;
+			spf[1] = 653.78;
+			spf[2] = 3.480308;
+			ss[0] = 500.0;
+			ss[1] = 0.5;
+			ss[2] = 0.5;
+
+			if (powell(NULL, 3, spf, ss, 1e-5, 2000, hropt_opt1, &cx))
+				a1logw(p->log,"hropt_opt1 failed\n");
+
+#ifdef HIGH_RES_PLOT
+			/* Plot dispersion spectra */
+			{
+				double xx[200];
+				double y1[200];
+				double y2[200];
+				double w1, w2;
+
+				w1 = lwl[0] + 5.0;
+				w2 = lwl[20] - 5.0;
+				for (i = 0; i < 200; i++) {
+					double wl;
+					wl = w1 + (i/199.0) * (w2-w1);
+					xx[i] = wl;
+					for (j = 0; j < 20; j++) {
+						if (lwl[j] >= wl && wl >= lwl[j+1])
+							break; 
+					}
+					if (j < 20)
+						y1[i] = llv[j];
+					else
+						y1[i] = 0.0;
+					y2[i] = gaussf(spf, wl);
+				}
+				printf("Gauss Parameters %f %f %f\n",spf[0],spf[1],spf[2]);
+				printf("Red laser dispersion data:\n");
+				do_plot(xx, y1, y2, NULL, 200);
+			}
+#endif /* HIGH_RES_PLOT */
+
+			/* Normalize the gausian to have an area of 1 */
+			spf[0] *= 1.0/(spf[0] * spf[2] * sqrt(2.0 * DBL_PI));
+
+//			printf("~1 Normalized intergral = %f\n",gaussint(spf, spf[1] - 30.0, spf[1] + 30.0));
+//			printf("~1 Half width = %f\n",2.0 * sqrt(2.0 * log(2.0)) * spf[2]);
+		}
+	}
+#endif /* COMPUTE_DISPERSION */
+
+	/* Compute the upsampled calibration references */
+	if (!m->hr_inited) {
+		rspl *trspl;			/* Upsample rspl */
+		cow sd[40 * 40];		/* Scattered data points of existing references */
+		datai glow, ghigh;
+		datao vlow, vhigh;
+		int gres[2];
+		double avgdev[2];
+		int ii;
+		co pp;
+
+		if ((trspl = new_rspl(RSPL_NOFLAGS, 1, 1)) == NULL) {
+			a1logd(p->log,1,"i1pro: creating rspl for high res conversion failed\n");
+			return I1PRO_INT_NEW_RSPL_FAILED;
+		}
+		
+		for (ii = 0; ii < 3; ii++) {
+			double **ref2, *ref1;
+			double smooth = 1.0;
+
+			if (ii == 0) {
+				ref1 = m->white_ref[0];
+				ref2 = &m->white_ref[1];
+				smooth = 0.5;
+			} else if (ii == 1) {
+				ref1 = m->emis_coef[0];
+				ref2 = &m->emis_coef[1];
+				smooth = 500.0;			/* Hmm. Lagrange may work better ?? */
+			} else {
+				if (m->amb_coef[0] == NULL)
+					break;
+				ref1 = m->amb_coef[0];
+				ref2 = &m->amb_coef[1];
+				smooth = 0.2;
+			}
+
+			if (ref1 == NULL)
+				continue;		/* The instI1Monitor doesn't have a reflective cal */
+
+			vlow[0] = 1e6;
+			vhigh[0] = -1e6;
+			for (i = 0; i < m->nwav[0]; i++) {
+
+				sd[i].p[0] = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], i);
+				sd[i].v[0] = ref1[i];
+				sd[i].w = 1.0;
+
+				if (sd[i].v[0] < vlow[0])
+					vlow[0] = sd[i].v[0];
+				if (sd[i].v[0] > vhigh[0])
+				    vhigh[0] = sd[i].v[0];
+			}
+
+			if (ii == 1) {		/* fudge factors */
+
+#ifdef NEVER	/* Doesn't help */
+				/* Increase boost at short wavelegths */
+				if (m->wl_short[1] < 380.0) {
+					sd[i].p[0] = m->wl_short[1];
+					sd[i].v[0] = sd[0].v[0] * (1.0 + (380.0 - m->wl_short[1])/20.0);
+					sd[i++].w = 0.6;
+				}
+#endif
+
+#ifdef NEVER	/* Doesn't help */
+				/* Reduces boost at long wavelegths */
+				if (m->wl_long[1] > 730.0) {
+					sd[i].p[0] = m->wl_long[1];
+					sd[i].v[0] = sd[m->nwav[0]-1].v[0] * (1.0 + (m->wl_long[1] - 730.0)/100.0);
+					sd[i++].w = 0.3;
+				}
+#endif
+			}
+			
+			glow[0] = m->wl_short[1];
+			ghigh[0] = m->wl_long[1];
+			gres[0] = m->nwav[1];
+			avgdev[0] = 0.0;
+			
+			trspl->fit_rspl_w(trspl, 0, sd, i, glow, ghigh, gres, vlow, vhigh, smooth, avgdev, NULL);
+
+			if ((*ref2 = (double *)calloc(m->nwav[1], sizeof(double))) == NULL) {
+				trspl->del(trspl);
+				a1logw(p->log, "i1pro: malloc ref2 failed!\n");
+				return I1PRO_INT_MALLOC;
+			}
+
+			for (i = 0; i < m->nwav[1]; i++) {
+				pp.p[0] = m->wl_short[1]
+				        + (double)i * (m->wl_long[1] - m->wl_short[1])/(m->nwav[1]-1.0);
+				trspl->interp(trspl, &pp);
+				(*ref2)[i] = pp.v[0];
+			}
+#ifdef HIGH_RES_PLOT
+			/* Plot original and upsampled reference */
+			{
+				double *x1 = dvectorz(0, m->nwav[1]-1);
+				double *y1 = dvectorz(0, m->nwav[1]-1);
+				double *y2 = dvectorz(0, m->nwav[1]-1);
+	
+				for (i = 0; i < m->nwav[1]; i++) {
+					double wl = m->wl_short[1] + (double)i * (m->wl_long[1] - m->wl_short[1])/(m->nwav[1]-1.0);
+					x1[i] = wl;
+					y1[i] = (*ref2)[i];
+					if (wl < m->wl_short[0] || wl > m->wl_long[0]) {
+						y2[i] = 0.0;
+					} else {
+						double x, wl1, wl2;
+						for (j = 0; j < (m->nwav[0]-1); j++) {
+							wl1 = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], j);
+							wl2 = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], j+1);
+							if (wl >= wl1 && wl <= wl2)
+								break;
+						}
+						x = (wl - wl1)/(wl2 - wl1);
+						y2[i] = ref1[j] + (ref1[j+1] - ref1[j]) * x;
+					}
+				}
+				printf("Original and up-sampled ");
+				if (ii == 0) {
+					printf("Reflective cal. curve:\n");
+				} else if (ii == 1) {
+					ref1 = m->emis_coef[0];
+					ref2 = &m->emis_coef[1];
+					printf("Emission cal. curve:\n");
+				} else {
+					printf("Ambient cal. curve:\n");
+				}
+				do_plot(x1, y1, y2, NULL, m->nwav[1]);
+	
+				free_dvector(x1, 0, m->nwav[1]-1);
+				free_dvector(y1, 0, m->nwav[1]-1);
+				free_dvector(y2, 0, m->nwav[1]-1);
+			}
+#endif /* HIGH_RES_PLOT */
+		}
+		trspl->del(trspl);
+
+		/* Upsample stray light */
+		if (p->itype == instI1Pro2) {
+#ifdef SALONEINSTLIB
+			double **slp;			/* 2D Array of stray light values */
+
+			/* Then the 2D stray light using linear interpolation */
+			slp = dmatrix(0, m->nwav[0]-1, 0, m->nwav[0]-1);
+
+			/* Set scattered points */
+			for (i = 0; i < m->nwav[0]; i++) {		/* Output wavelength */
+				for (j = 0; j < m->nwav[0]; j++) {	/* Input wavelength */
+
+					slp[i][j] = m->straylight[0][i][j];
+
+					/* Use interpolate/extrapolate for middle points */
+					if (j == (i-1) || j == i || j == (i+1)) {
+						int j0, j1;
+						double w0, w1;
+						if (j == (i-1)) {
+							if (j <= 0)
+								j0 = j+3, j1 = j+4;
+							else if (j >= (m->nwav[0]-3))
+								j0 = j-2, j1 = j-1;
+							else
+								j0 = j-1, j1 = j+3;
+						} else if (j == i) {
+							if (j <= 1)
+								j0 = j+2, j1 = j+3;
+							else if (j >= (m->nwav[0]-2))
+								j0 = j-3, j1 = j-2;
+							else
+								j0 = j-2, j1 = j+2;
+						} else if (j == (i+1)) {
+							if (j <= 2)
+								j0 = j+1, j1 = j+2;
+							else if (j >= (m->nwav[0]-1))
+								j0 = j-4, j1 = j-3;
+							else
+								j0 = j-3, j1 = j+1;
+						}
+						w1 = (j - j0)/(j1 - j0);
+						w0 = 1.0 - w1;
+						slp[i][j] = w0 * m->straylight[0][i][j0]
+						          + w1 * m->straylight[0][i][j1];
+
+					}
+				}
+			}
+#else	/* !SALONEINSTLIB */
+			/* Then setup 2D stray light using rspl */
+			if ((trspl = new_rspl(RSPL_NOFLAGS, 2, 1)) == NULL) {
+				a1logd(p->log,1,"i1pro: creating rspl for high res conversion failed\n");
+				return I1PRO_INT_NEW_RSPL_FAILED;
+			}
+			
+			/* Set scattered points */
+			for (i = 0; i < m->nwav[0]; i++) {		/* Output wavelength */
+				for (j = 0; j < m->nwav[0]; j++) {	/* Input wavelength */
+					int ix = i * m->nwav[0] + j;
+
+					sd[ix].p[0] = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], i);
+					sd[ix].p[1] = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], j);
+					sd[ix].v[0] = m->straylight[0][i][j];
+					sd[ix].w = 1.0;
+					if (j == (i-1) || j == i || j == (i+1))
+						sd[ix].w = 0.0;
+				}
+			}
+
+			glow[0] = m->wl_short[1];
+			glow[1] = m->wl_short[1];
+			ghigh[0] = m->wl_long[1];
+			ghigh[1] = m->wl_long[1];
+			gres[0] = m->nwav[1];
+			gres[1] = m->nwav[1];
+			avgdev[0] = 0.0;
+			avgdev[1] = 0.0;
+			
+			trspl->fit_rspl_w(trspl, 0, sd, m->nwav[0] * m->nwav[0], glow, ghigh, gres, NULL, NULL, 0.5, avgdev, NULL);
+#endif	/* !SALONEINSTLIB */
+
+			m->straylight[1] = dmatrixz(0, m->nwav[1]-1, 0, m->nwav[1]-1);  
+
+			/* Create upsampled version */
+			for (i = 0; i < m->nwav[1]; i++) {		/* Output wavelength */
+				for (j = 0; j < m->nwav[1]; j++) {	/* Input wavelength */
+					double p0, p1;
+					p0 = XSPECT_WL(m->wl_short[1], m->wl_long[1], m->nwav[1], i);
+					p1 = XSPECT_WL(m->wl_short[1], m->wl_long[1], m->nwav[1], j);
+#ifdef SALONEINSTLIB
+					/* Do linear interp with clipping at ends */
+					{
+						int x0, x1, y0, y1;
+						double xx, yy, w0, w1, v0, v1;
+
+						xx = (m->nwav[0]-1.0) * (p0 - m->wl_short[0])/(m->wl_long[0] - m->wl_short[0]);
+						x0 = (int)floor(xx);
+						if (x0 <= 0)
+							x0 = 0;
+						else if (x0 >= (m->nwav[0]-2))
+							x0 = m->nwav[0]-2;
+						x1 = x0 + 1;
+						w1 = xx - (double)x0;
+						w0 = 1.0 - w1;
+
+						yy = (m->nwav[0]-1.0) * (p1 - m->wl_short[0])/(m->wl_long[0] - m->wl_short[0]);
+						y0 = (int)floor(yy);
+						if (y0 <= 0)
+							y0 = 0;
+						else if (y0 >= (m->nwav[0]-2))
+							y0 = m->nwav[0]-2;
+						y1 = y0 + 1;
+						v1 = yy - (double)y0;
+						v0 = 1.0 - v1;
+
+						pp.v[0] = w0 * v0 * slp[x0][y0] 
+						        + w0 * v1 * slp[x0][y1] 
+						        + w1 * v0 * slp[x1][y0] 
+						        + w1 * v1 * slp[x1][y1]; 
+					}
+#else /* !SALONEINSTLIB */
+					pp.p[0] = p0;
+					pp.p[1] = p1;
+					trspl->interp(trspl, &pp);
+#endif /* !SALONEINSTLIB */
+					m->straylight[1][i][j] = pp.v[0] * HIGHRES_WIDTH/10.0;
+					if (m->straylight[1][i][j] > 0.0)
+						m->straylight[1][i][j] = 0.0;
+				}
+			}
+
+			/* Fix primary wavelength weight and neighbors */
+			for (i = 0; i < m->nwav[1]; i++) {		/* Output wavelength */
+				double sum;
+
+				if (i > 0)
+					m->straylight[1][i][i-1] = 0.0;
+				m->straylight[1][i][i] = 0.0;
+				if (i < (m->nwav[1]-1))
+					m->straylight[1][i][i+1] = 0.0;
+
+				for (sum = 0.0, j = 0; j < m->nwav[1]; j++)
+					sum += m->straylight[1][i][j];
+
+				m->straylight[1][i][i] = 1.0 - sum;		/* Total sum should be 1.0 */
+			}
+
+#ifdef HIGH_RES_PLOT_STRAYL
+			/* Plot original and upsampled reference */
+			{
+				double *x1 = dvectorz(0, m->nwav[1]-1);
+				double *y1 = dvectorz(0, m->nwav[1]-1);
+				double *y2 = dvectorz(0, m->nwav[1]-1);
+	
+				for (i = 0; i < m->nwav[1]; i++) {		/* Output wavelength */
+					double wli = XSPECT_WL(m->wl_short[1], m->wl_long[1], m->nwav[1], i);
+					int i1 = XSPECT_IX(m->wl_short[0], m->wl_long[0], m->nwav[0], wli);
+
+					for (j = 0; j < m->nwav[1]; j++) {
+						double wl = XSPECT_WL(m->wl_short[1], m->wl_long[1], m->nwav[1], j);
+						x1[j] = wl;
+						y1[j] = m->straylight[1][i][j];
+						if (y1[j] == 0.0)
+							y1[j] = -8.0;
+						else
+							y1[j] = log10(fabs(y1[j]));
+						if (wli < m->wl_short[0] || wli > m->wl_long[0]
+						 || wl < m->wl_short[0] || wl > m->wl_long[0]) {
+							y2[j] = -8.0;
+						} else {
+							double x, wl1, wl2;
+							for (k = 0; k < (m->nwav[0]-1); k++) {
+								wl1 = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], k);
+								wl2 = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], k+1);
+								if (wl >= wl1 && wl <= wl2)
+									break;
+							}
+							x = (wl - wl1)/(wl2 - wl1);
+							y2[j] = m->straylight[0][i1][k] + (m->straylight[0][i1][k+1]
+							      - m->straylight[0][i1][k]) * x;
+							if (y2[j] == 0.0)
+								y2[j] = -8.0;
+							else
+								y2[j] = log10(fabs(y2[j]));
+						}
+					}
+					do_plot(x1, y1, y2, NULL, m->nwav[1]);
+				}
+	
+				free_dvector(x1, 0, m->nwav[1]-1);
+				free_dvector(y1, 0, m->nwav[1]-1);
+				free_dvector(y2, 0, m->nwav[1]-1);
+			}
+#endif /* HIGH_RES_PLOT */
+
+#ifdef SALONEINSTLIB
+			free_dmatrix(slp, 0, m->nwav[0]-1, 0, m->nwav[0]-1);
+#else /* !SALONEINSTLIB */
+			trspl->del(trspl);
+#endif /* !SALONEINSTLIB */
+		}
+	}
+
+	/* Create or re-create the high resolution filters */
+	for (refl = 0; refl < 2; refl++) {	/* for emis/trans and reflective */
+		double fshmax;					/* filter shape max wavelength from center */
+#define MXNOFC 64
+		i1pro_fc coeff2[500][MXNOFC];	/* New filter cooefficients */
+		double twidth;
+
+		/* Construct a set of filters that uses more CCD values */
+		twidth = HIGHRES_WIDTH;
+
+		if (m->nwav[1] > 500) {		/* Assert */
+			a1loge(p->log,1,"High res filter has too many bands\n");
+			return I1PRO_INT_ASSERT;
+		}
+
+		/* Use a simple means of determining width */
+		for (fshmax = 50.0; fshmax >= 0.0; fshmax -= 0.1) {
+			if (fabs(lanczos2(twidth, fshmax)) > 0.0001) {
+				fshmax += 0.1;
+				break;
+			}
+		}
+		if (fshmax <= 0.0) {
+			a1logw(p->log, "i1pro: fshmax search failed\n");
+			return I1PRO_INT_ASSERT;
+		}
+	
+//		printf("~1 fshmax = %f\n",fshmax);
+
+#ifdef HIGH_RES_DEBUG
+		/* Check that the filter sums to a constant */
+		{
+			double x, sum;
+	
+			for (x = 0.0; x < 5.0; x += 0.1) {
+				sum = 0;
+				sum += lin_fshape(fshape, ncp, x - 15.0);
+				sum += lin_fshape(fshape, ncp, x - 10.0);
+				sum += lin_fshape(fshape, ncp, x -  5.0);
+				sum += lin_fshape(fshape, ncp, x -  0.0);
+				sum += lin_fshape(fshape, ncp, x +  5.0);
+				sum += lin_fshape(fshape, ncp, x + 10.0);
+				printf("Offset %f, sum %f\n",x, sum);
+			}
+		}
+#endif /* HIGH_RES_DEBUG */
+
+		/* Create all the filters */
+		if (m->mtx_c[1][refl].nocoef != NULL)
+			free(m->mtx_c[1][refl].nocoef);
+		if ((m->mtx_c[1][refl].nocoef = (int *)calloc(m->nwav[1], sizeof(int))) == NULL) {
+			a1logw(p->log, "i1pro: malloc nocoef failed!\n");
+			return I1PRO_INT_MALLOC;
+		}
+
+		/* For all the useful CCD bands */
+		for (i = 1; i < 127; i++) {
+			double w1, wl, w2;
+
+			/* Translate CCD center and boundaries to calibrated wavelength */
+			wl = i1pro_raw2wav(p, refl, (double)i);
+			w1 = i1pro_raw2wav(p, refl, (double)i - 0.5);
+			w2 = i1pro_raw2wav(p, refl, (double)i + 0.5);
+
+//			printf("~1 CCD %d, w1 %f, wl %f, w2 %f\n",i,w1,wl,w2);
+
+			/* For each filter */
+			for (j = 0; j < m->nwav[1]; j++) {
+				double cwl, rwl;		/* center, relative wavelegth */
+				double we;
+
+				cwl = m->wl_short[1] + (double)j * (m->wl_long[1] - m->wl_short[1])/(m->nwav[1]-1.0);
+				rwl = wl - cwl;			/* relative wavelength to filter */
+
+				if (fabs(w1 - cwl) > fshmax && fabs(w2 - cwl) > fshmax)
+					continue;		/* Doesn't fall into this filter */
+
+				/* Integrate in 0.05 nm increments from filter shape */
+				/* using triangular integration. */
+				{
+					int nn;
+					double lw, ll;
+
+					nn = (int)(fabs(w2 - w1)/0.05 + 0.5);		/* Number to integrate over */
+			
+					lw = w1;				/* start at lower boundary of CCD cell */
+					ll = lanczos2(twidth, w1- cwl);
+					we = 0.0;
+					for (k = 0; k < nn; k++) { 
+						double cw, cl;
+
+#if defined(__APPLE__) && defined(__POWERPC__)
+						gcc_bug_fix(k);
+#endif
+						cw = w1 + (k+1.0)/(nn +1.0) * (w2 - w1);	/* wl to sample */
+						cl = lanczos2(twidth, cw- cwl);
+						we += 0.5 * (cl + ll) * (lw - cw);			/* Area under triangle */
+						ll = cl;
+						lw = cw;
+					}
+				}
+
+				if (m->mtx_c[1][refl].nocoef[j] >= MXNOFC) {
+					a1logw(p->log, "i1pro: run out of high res filter space\n");
+					return I1PRO_INT_ASSERT;
+				}
+
+				coeff2[j][m->mtx_c[1][refl].nocoef[j]].ix = i;
+				coeff2[j][m->mtx_c[1][refl].nocoef[j]++].we = we; 
+//				printf("~1 filter %d, cwl %f, rwl %f, ix %d, we %f, nocoefs %d\n",j,cwl,rwl,i,we,m->mtx_c[1][refl].nocoef[j]-1);
+			}
+		}
+
+#ifdef HIGH_RES_PLOT
+		/* Plot resampled curves */
+		{
+			double *xx, *ss;
+			double **yy;
+
+			xx = dvectorz(-1, m->nraw-1);		/* X index */
+			yy = dmatrixz(0, 5, -1, m->nraw-1);	/* Curves distributed amongst 5 graphs */
+			
+			for (i = 0; i < m->nraw; i++)
+				xx[i] = i;
+
+			/* For each output wavelength */
+			for (j = 0; j < m->nwav[1]; j++) {
+				i = j % 5;
+
+				/* For each matrix value */
+				for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++) {
+					yy[5][coeff2[j][k].ix] += 0.5 * coeff2[j][k].we;
+					yy[i][coeff2[j][k].ix] = coeff2[j][k].we;
+				}
+			}
+
+			printf("Hi-Res wavelength sampling curves:\n");
+			do_plot6(xx, yy[0], yy[1], yy[2], yy[3], yy[4], yy[5], m->nraw);
+			free_dvector(xx, -1, m->nraw-1);
+			free_dmatrix(yy, 0, 2, -1, m->nraw-1);
+		}
+#endif /* HIGH_RES_PLOT */
+
+		/* Normalise the filters area in CCD space, while maintaining the */
+		/* total contribution of each CCD at the target too. */
+		{
+			int ii;
+			double tot = 0.0;
+			double ccdweight[128], avgw;	/* Weighting determined by cell widths */
+			double ccdsum[128];
+
+			/* Normalize the overall filter weightings */
+			for (j = 0; j < m->nwav[1]; j++)
+				for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+					tot += coeff2[j][k].we;
+			tot /= (double)m->nwav[1];
+			for (j = 0; j < m->nwav[1]; j++)
+				for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+					coeff2[j][k].we /= tot;
+
+			/* Determine the relative weights for each CCD */
+			avgw = 0.0;
+			for (i = 1; i < 127; i++) {
+
+				ccdweight[i] = i1pro_raw2wav(p, refl, (double)i - 0.5)
+				             - i1pro_raw2wav(p, refl, (double)i + 0.5);
+				ccdweight[i] = fabs(ccdweight[i]);
+				avgw += ccdweight[i];
+			}
+			avgw /= 126.0;
+			// ~~this isn't right because not all CCD's get used!!
+
+#ifdef NEVER
+			/* Itterate */
+			for (ii = 0; ; ii++) {
+
+				/* Normalize the individual filter weightings */
+				for (j = 0; j < m->nwav[1]; j++) {
+					double err;
+					tot = 0.0;
+					for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+						tot += coeff2[j][k].we;
+					err = 1.0 - tot;
+	
+					for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+						coeff2[j][k].we += err/m->mtx_c[1][refl].nocoef[j];
+//					for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+//						coeff2[j][k].we *= 1.0/tot;
+				}
+
+				/* Check CCD sums */
+				for (i = 1; i < 127; i++) 
+					ccdsum[i] = 0.0;
+
+				for (j = 0; j < m->nwav[1]; j++) {
+					for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+						ccdsum[coeff2[j][k].ix] += coeff2[j][k].we;
+				}
+
+				if (ii >= 6)
+					break;
+
+				/* Readjust CCD sum */
+				for (i = 1; i < 127; i++) { 
+					ccdsum[i] = ccdtsum[i]/ccdsum[i];		/* Amount to adjust */
+				}
+
+				for (j = 0; j < m->nwav[1]; j++) {
+					for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+						coeff2[j][k].we *= ccdsum[coeff2[j][k].ix];
+				}
+			}
+#endif	/* NEVER */
+		}
+
+#ifdef HIGH_RES_PLOT
+		/* Plot resampled curves */
+		{
+			double *xx, *ss;
+			double **yy;
+
+			xx = dvectorz(-1, m->nraw-1);		/* X index */
+			yy = dmatrixz(0, 5, -1, m->nraw-1);	/* Curves distributed amongst 5 graphs */
+			
+			for (i = 0; i < m->nraw; i++)
+				xx[i] = i;
+
+			/* For each output wavelength */
+			for (j = 0; j < m->nwav[1]; j++) {
+				i = j % 5;
+
+				/* For each matrix value */
+				for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++) {
+					yy[5][coeff2[j][k].ix] += 0.5 * coeff2[j][k].we;
+					yy[i][coeff2[j][k].ix] = coeff2[j][k].we;
+				}
+			}
+
+			printf("Normalized Hi-Res wavelength sampling curves:\n");
+			do_plot6(xx, yy[0], yy[1], yy[2], yy[3], yy[4], yy[5], m->nraw);
+			free_dvector(xx, -1, m->nraw-1);
+			free_dmatrix(yy, 0, 2, -1, m->nraw-1);
+		}
+#endif /* HIGH_RES_PLOT */
+
+		/* Convert hires filters into runtime format */
+		{
+			int xcount;
+
+			/* Allocate or reallocate high res filter tables */
+			if (m->mtx_c[1][refl].index != NULL)
+				free(m->mtx_c[1][refl].index);
+			if (m->mtx_c[1][refl].coef != NULL)
+				free(m->mtx_c[1][refl].coef);
+
+			if ((m->mtx_c[1][refl].index = (int *)calloc(m->nwav[1], sizeof(int))) == NULL) {
+				a1logw(p->log, "i1pro: malloc index failed!\n");
+				return I1PRO_INT_MALLOC;
+			}
+	
+			xcount = 0;
+			for (j = 0; j < m->nwav[1]; j++) {
+				m->mtx_c[1][refl].index[j] = coeff2[j][0].ix;
+				xcount += m->mtx_c[1][refl].nocoef[j];
+			}
+	
+			if ((m->mtx_c[1][refl].coef = (double *)calloc(xcount, sizeof(double))) == NULL) {
+				a1logw(p->log, "i1pro: malloc coef failed!\n");
+				return I1PRO_INT_MALLOC;
+			}
+
+			for (i = j = 0; j < m->nwav[1]; j++)
+				for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++, i++)
+					m->mtx_c[1][refl].coef[i] = coeff2[j][k].we;
+
+			/* Set high res tables to new allocations */
+			m->mtx[1][refl] = m->mtx_c[1][refl];
+		}
+	}
+
+	/* Generate high res. per mode calibration factors. */
+	if (!m->hr_inited) {
+
+		m->hr_inited = 1;		/* Set so that i1pro_compute_white_cal() etc. does right thing */
+
+		for (i = 0; i < i1p_no_modes; i++) {
+			i1pro_state *s = &m->ms[i];
+
+			if (s->cal_factor[1] == NULL)
+				s->cal_factor[1] = dvectorz(0, m->nwav[1]-1);
+
+			switch(i) {
+				case i1p_refl_spot:
+				case i1p_refl_scan:
+					if (s->cal_valid) {
+						/* (Using cal_factor[] as temp. for i1pro_absraw_to_abswav()) */
+#ifdef NEVER
+						printf("~1 regenerating calibration for reflection\n");
+						printf("~1 raw white data:\n");
+						plot_raw(s->white_data);
+#endif	/* NEVER */
+						i1pro_absraw_to_abswav(p, 0, s->reflective, 1, &s->cal_factor[0], &s->white_data);
+#ifdef NEVER
+						printf("~1 Std res intmd. cal_factor:\n");
+						plot_wav(m, 0, s->cal_factor[0]);
+#endif	/* NEVER */
+						i1pro_absraw_to_abswav(p, 1, s->reflective, 1, &s->cal_factor[1], &s->white_data);
+#ifdef NEVER
+						printf("~1 High intmd. cal_factor:\n");
+						plot_wav(m, 1, s->cal_factor[1]);
+						printf("~1 Std res white ref:\n");
+						plot_wav(m, 0, m->white_ref[0]);
+						printf("~1 High res white ref:\n");
+						plot_wav(m, 1, m->white_ref[1]);
+#endif	/* NEVER */
+						i1pro_compute_white_cal(p, s->cal_factor[0], m->white_ref[0], s->cal_factor[0],
+						                           s->cal_factor[1], m->white_ref[1], s->cal_factor[1]);
+#ifdef NEVER
+						printf("~1 Std res final cal_factor:\n");
+						plot_wav(m, 0, s->cal_factor[0]);
+						printf("~1 High final cal_factor:\n");
+						plot_wav(m, 1, s->cal_factor[1]);
+#endif	/* NEVER */
+					}
+					break;
+
+				case i1p_emiss_spot_na:
+				case i1p_emiss_spot:
+				case i1p_emiss_scan:
+					for (j = 0; j < m->nwav[1]; j++)
+						s->cal_factor[1][j] = EMIS_SCALE_FACTOR * m->emis_coef[1][j];
+					break;
+
+				case i1p_amb_spot:
+				case i1p_amb_flash:
+#ifdef FAKE_AMBIENT
+					for (j = 0; j < m->nwav[1]; j++)
+						s->cal_factor[1][j] = EMIS_SCALE_FACTOR * m->emis_coef[1][j];
+					s->cal_valid = 1;
+#else
+
+					if (m->amb_coef[0] != NULL) {
+						for (j = 0; j < m->nwav[1]; j++)
+							s->cal_factor[1][j] = AMB_SCALE_FACTOR * m->emis_coef[1][j] * m->amb_coef[1][j];
+						s->cal_valid = 1;
+					}
+#endif
+					break;
+				case i1p_trans_spot:
+				case i1p_trans_scan:
+					if (s->cal_valid) {
+						/* (Using cal_factor[] as temp. for i1pro_absraw_to_abswav()) */
+						i1pro_absraw_to_abswav(p, 0, s->reflective, 1, &s->cal_factor[0], &s->white_data);
+						i1pro_absraw_to_abswav(p, 1, s->reflective, 1, &s->cal_factor[1], &s->white_data);
+						i1pro_compute_white_cal(p, s->cal_factor[0], NULL, s->cal_factor[0],
+			                                       s->cal_factor[1], NULL, s->cal_factor[1]);
+					}
+					break;
+			}
+		}
+	}
+
+	/* Hires has been initialised */
+	m->hr_inited = 1;
+
+	return ev;
+}
+
+#endif /* HIGH_RES */
+
+
+/* return nz if high res is supported */
+int i1pro_imp_highres(i1pro *p) {
+#ifdef HIGH_RES
+	return 1;
+#else
+	return 0;
+#endif /* HIGH_RES */
+}
+
+/* Set to high resolution mode */
+i1pro_code i1pro_set_highres(i1pro *p) {
+	int i;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_code ev = I1PRO_OK;
+
+#ifdef HIGH_RES
+	if (m->hr_inited == 0) {
+		if ((ev = i1pro_create_hr(p)) != I1PRO_OK)
+			return ev;
+	}
+	m->highres = 1;
+#else
+	ev = I1PRO_UNSUPPORTED;
+#endif /* HIGH_RES */
+
+	return ev;
+}
+
+/* Set to standard resolution mode */
+i1pro_code i1pro_set_stdres(i1pro *p) {
+	int i;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_code ev = I1PRO_OK;
+
+#ifdef HIGH_RES
+	m->highres = 0;
+#else
+	ev = I1PRO_UNSUPPORTED;
+#endif /* HIGH_RES */
+
+	return ev;
+}
+
+/* =============================================== */
+
+/* Modify the scan consistency tolerance */
+i1pro_code i1pro_set_scan_toll(i1pro *p, double toll_ratio) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_code ev = I1PRO_OK;
+
+	m->scan_toll_ratio = toll_ratio;
+
+	return I1PRO_OK;
+}
+
+
+/* Optics adjustment weights */
+static double opt_adj_weights[21] = {
+	1.4944496665144658e-282, 2.0036175483913455e-070, 1.2554893022685038e+232,
+	2.3898157055642966e+190, 1.5697625128432372e-076, 6.6912978722191457e+281,
+	1.2369092402930559e+277, 1.4430907501246712e-153, 3.0017439193018232e+238,
+	1.2978311824382444e+161, 5.5068703318775818e-311, 7.7791723264455314e-260,
+	6.4560484084110176e+170, 8.9481529920968425e+165, 1.3565405878488529e-153,
+	2.0835868791190880e-076, 5.4310198502711138e+241, 4.8689849775675438e+275,
+	9.2709981544886391e+122, 3.7958270103353899e-153, 7.1366083837501666e-154
+};
+
+/* Convert from spectral to XYZ, and transfer to the ipatch array */
+i1pro_code i1pro_conv2XYZ(
+	i1pro *p,
+	ipatch *vals,		/* Values to return */
+	int nvals,			/* Number of values */
+	double **specrd,	/* Spectral readings */
+	instClamping clamp	/* Clamp XYZ/Lab to be +ve */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	xsp2cie *conv;	/* Spectral to XYZ conversion object */
+	int i, j, k;
+	int six = 0;		/* Starting index */
+	int nwl = m->nwav[m->highres];	/* Number of wavelegths */
+	double wl_short = m->wl_short[m->highres];	/* Starting wavelegth */
+	double sms;			/* Weighting */
+
+	if (s->emiss)
+		conv = new_xsp2cie(icxIT_none, NULL, icxOT_CIE_1931_2, NULL, icSigXYZData, (icxClamping)clamp);
+	else
+		conv = new_xsp2cie(icxIT_D50, NULL, icxOT_CIE_1931_2, NULL, icSigXYZData, (icxClamping)clamp);
+	if (conv == NULL)
+		return I1PRO_INT_CIECONVFAIL;
+
+	/* Don't report any wavelengths below the minimum for this mode */
+	if ((s->min_wl-1e-3) > wl_short) {
+		double wl = 0.0;
+		for (j = 0; j < m->nwav[m->highres]; j++) {
+			wl = XSPECT_WL(m->wl_short[m->highres], m->wl_long[m->highres], m->nwav[m->highres], j);
+			if (wl >= (s->min_wl-1e-3))
+				break;
+		}
+		six = j;
+		wl_short = wl;
+		nwl -= six;
+	}
+
+	a1logd(p->log,5,"i1pro_conv2XYZ got wl_short %f, wl_long %f, nwav %d, min_wl %f\n",
+	                m->wl_short[m->highres], m->wl_long[m->highres], m->nwav[m->highres], s->min_wl);
+	a1logd(p->log,5,"      after skip got wl_short %f, nwl = %d\n", wl_short, nwl);
+
+	for (sms = 0.0, i = 1; i < 21; i++)
+		sms += opt_adj_weights[i];
+	sms *= opt_adj_weights[0];
+
+	for (i = 0; i < nvals; i++) {
+
+		vals[i].loc[0] = '\000';
+		vals[i].mtype = inst_mrt_none;
+		vals[i].XYZ_v = 0;
+		vals[i].sp.spec_n = 0;
+		vals[i].duration = 0.0;
+	
+		vals[i].sp.spec_n = nwl;
+		vals[i].sp.spec_wl_short = wl_short;
+		vals[i].sp.spec_wl_long = m->wl_long[m->highres];
+
+		if (s->emiss) {
+			/* Leave spectral values as mW/m^2 */
+			for (j = six, k = 0; j < m->nwav[m->highres]; j++, k++) {
+				vals[i].sp.spec[k] = specrd[i][j] * sms;
+			}
+			vals[i].sp.norm = 1.0;
+
+			/* Set the XYZ */
+			conv->convert(conv, vals[i].XYZ, &vals[i].sp);
+			vals[i].XYZ_v = 1;
+
+			if (s->ambient) {
+				if (s->flash)
+					vals[i].mtype = inst_mrt_ambient_flash;
+				else
+					vals[i].mtype = inst_mrt_ambient;
+			} else {
+				if (s->flash)
+					vals[i].mtype = inst_mrt_emission_flash;
+				else
+					vals[i].mtype = inst_mrt_emission;
+			}
+
+		} else {
+			/* Scale spectral values to percentage reflectance */
+			for (j = six, k = 0; j < m->nwav[m->highres]; j++, k++) {
+				vals[i].sp.spec[k] = 100.0 * specrd[i][j] * sms;
+			}
+			vals[i].sp.norm = 100.0;
+
+			/* Set the XYZ */
+			conv->convert(conv, vals[i].XYZ, &vals[i].sp);
+			vals[i].XYZ_v = 1;
+			vals[i].XYZ[0] *= 100.0;
+			vals[i].XYZ[1] *= 100.0;
+			vals[i].XYZ[2] *= 100.0;
+
+			if (s->trans)
+				vals[i].mtype = inst_mrt_transmissive;
+			else
+				vals[i].mtype = inst_mrt_reflective;
+		}
+
+		/* Don't return spectral if not asked for */
+		if (!m->spec_en) {
+			vals[i].sp.spec_n = 0;
+		}
+	}
+
+	conv->del(conv);
+	return I1PRO_OK;
+}
+
+/* Check a reflective white reference measurement to see if */
+/* it seems reasonable. Return I1PRO_OK if it is, error if not. */
+i1pro_code i1pro_check_white_reference1(
+	i1pro *p,
+	double *abswav			/* [nwav[0]] Measurement to check */
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	double *emiswav, normfac;
+	double avg01, avg2227;
+	int j;
+
+	emiswav = dvector(-1, m->nraw-1);
+
+	/* Convert from absolute wavelength converted sensor reading, */
+	/* to calibrated emission wavelength spectrum. */
+
+	/* For each output wavelength */
+	for (j = 0; j < m->nwav[0]; j++) {
+		emiswav[j] = m->emis_coef[0][j] * abswav[j];
+	}
+#ifdef PLOT_DEBUG
+	printf("White ref read converted to emissive spectrum:\n");
+	plot_wav(m, 0, emiswav);
+#endif
+
+	/* Normalise the measurement to the reflectance of the 17 wavelength */
+	/* of the white reference (550nm), as well as dividing out the */
+	/* reference white. This should leave us with the iluminant spectrum, */
+	normfac = m->white_ref[0][17]/emiswav[17];
+	
+	for (j = 0; j < m->nwav[0]; j++) {
+		emiswav[j] *= normfac/m->white_ref[0][j];
+	}
+
+#ifdef PLOT_DEBUG
+	printf("normalised to reference white read:\n");
+	plot_wav(m, 0, emiswav);
+#endif
+
+	/* Compute two sample averages of the illuminant spectrum. */
+	avg01 = 0.5 * (emiswav[0] + emiswav[1]);
+
+	for (avg2227 = 0, j = 22; j < 28; j++) {
+		avg2227 += emiswav[j];
+	}
+	avg2227 /= (double)(28 - 22);
+
+	free_dvector(emiswav, -1, m->nraw-1);
+
+	/* And check them against tolerance for the illuminant. */
+	if (m->physfilt == 0x82) {		/* UV filter */
+		if (0.0 < avg01 && avg01 < 0.05
+		 && 1.2 < avg2227 && avg2227 < 1.76) {
+			return I1PRO_OK;
+		}
+
+	} else {						/* No filter */
+		if (0.11 < avg01 && avg01 < 0.22
+		 && 1.35 < avg2227 && avg2227 < 1.6) {
+			return I1PRO_OK;
+		}
+	}
+	a1logd(p->log,2,"Checking white reference failed, 0.11 < avg01 %f < 0.22, 1.35 < avg2227 %f < 1.6\n",avg01,avg2227);
+	return I1PRO_RD_WHITEREFERROR;
+}
+
+/* Compute a mode calibration factor given the reading of the white reference. */
+/* Return 1 if any of the transmission wavelengths are low. */
+int i1pro_compute_white_cal(
+	i1pro *p,
+	double *cal_factor0,	/* [nwav[0]] Calibration factor to compute */
+	double *white_ref0,		/* [nwav[0]] White reference to aim for, NULL for 1.0 */
+	double *white_read0,	/* [nwav[0]] The white that was read */
+	double *cal_factor1,	/* [nwav[1]] Calibration factor to compute */
+	double *white_ref1,		/* [nwav[1]] White reference to aim for, NULL for 1.0 */
+	double *white_read1		/* [nwav[1]] The white that was read */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	int j, warn = 0;;
+	
+	if (white_ref0 == NULL) {		/* transmission white reference */
+		double avgwh = 0.0;
+
+		/* Compute average white reference reading */
+		for (j = 0; j < m->nwav[0]; j++)
+			avgwh += white_read0[j];
+		avgwh /= (double)m->nwav[0];
+
+		/* For each wavelength */
+		for (j = 0; j < m->nwav[0]; j++) {
+			/* If reference is < 0.4% of average */
+			if (white_read0[j]/avgwh < 0.004) {
+				cal_factor0[j] = 1.0/(0.004 * avgwh);
+				warn = 1;
+			} else {
+				cal_factor0[j] = 1.0/white_read0[j];	
+			}
+		}
+
+	} else {					/* Reflection white reference */
+
+		/* For each wavelength */
+		for (j = 0; j < m->nwav[0]; j++) {
+			if (white_read0[j] < 1000.0)
+				cal_factor0[j] = white_ref0[j]/1000.0;	
+			else
+				cal_factor0[j] = white_ref0[j]/white_read0[j];	
+		}
+	}
+
+#ifdef HIGH_RES
+	if (m->hr_inited == 0)
+		return warn;
+
+	if (white_ref1 == NULL) {		/* transmission white reference */
+		double avgwh = 0.0;
+
+		/* Compute average white reference reading */
+		for (j = 0; j < m->nwav[1]; j++)
+			avgwh += white_read1[j];
+		avgwh /= (double)m->nwav[1];
+
+		/* For each wavelength */
+		for (j = 0; j < m->nwav[1]; j++) {
+			/* If reference is < 0.4% of average */
+			if (white_read1[j]/avgwh < 0.004) {
+				cal_factor1[j] = 1.0/(0.004 * avgwh);
+				warn = 1;
+			} else {
+				cal_factor1[j] = 1.0/white_read1[j];	
+			}
+		}
+
+	} else {					/* Reflection white reference */
+
+		/* For each wavelength */
+		for (j = 0; j < m->nwav[1]; j++) {
+			if (white_read1[j] < 1000.0)
+				cal_factor1[j] = white_ref1[j]/1000.0;	
+			else
+				cal_factor1[j] = white_ref1[j]/white_read1[j];	
+		}
+	}
+#endif /* HIGH_RES */
+	return warn;
+}
+
+/* For adaptive mode, compute a new integration time and gain mode */
+/* in order to optimise the sensor values. Note that the Rev E doesn't have */
+/* a high gain mode. */
+i1pro_code i1pro_optimise_sensor(
+	i1pro *p,
+	double *pnew_int_time,
+	int    *pnew_gain_mode,
+	double cur_int_time,
+	int    cur_gain_mode,
+	int    permithg,		/* nz to permit switching to high gain mode */
+	int    permitclip,		/* nz to permit clipping out of range int_time, else error */
+	double targoscale,		/* Optimising target scale ( <= 1.0) */
+	double scale			/* scale needed of current int time to reach optimum */
+) {
+	i1pro_code ev = I1PRO_OK;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	double new_int_time;
+	int    new_gain_mode;
+
+	a1logd(p->log,3,"i1pro_optimise_sensor called, inttime %f, gain mode %d, targ scale %f, scale %f\n",cur_int_time,cur_gain_mode, targoscale, scale);
+
+	/* Compute new normal gain integration time */
+	if (cur_gain_mode)		/* If high gain */
+		new_int_time = cur_int_time * scale * m->highgain;
+	else
+		new_int_time = cur_int_time * scale;
+	new_gain_mode = 0;
+
+	a1logd(p->log,3,"target inttime %f, gain mode %d\n",new_int_time,new_gain_mode);
+
+	/* Adjust to low light situation by increasing the integration time. */
+	if (new_int_time > s->targmaxitime) {	/* Exceeding target integration time */
+		if (s->targmaxitime/new_int_time > s->targoscale2) {	/* But within range */
+			/* Compromise sensor target value to maintain targmaxitime */
+			new_int_time = s->targmaxitime;
+			a1logd(p->log,3,"Using targmaxitime with compromise sensor target\n");
+		} else {
+			/* Target reduced sensor value to give improved measurement time and continuity */
+			new_int_time *= s->targoscale2;
+			a1logd(p->log,3,"Using compromse sensor target\n");
+		}
+#ifdef USE_HIGH_GAIN_MODE
+		/* !! Should change this so that it doesn't affect int. time, */
+		/* but that we simply switch to high gain mode when the */
+		/* expected level is < target_level/gain */
+		/* Hmm. It may not be a good idea to use high gain mode if it compromises */
+		/* the longer integration time which reduces noise. */
+		if (p->itype != instI1Pro2 && new_int_time > m->max_int_time && permithg) {
+			new_int_time /= m->highgain;
+			new_gain_mode = 1;
+			a1logd(p->log,3,"Switching to high gain mode\n");
+		}
+#endif
+	}
+	a1logd(p->log,3,"after low light adjust, inttime %f, gain mode %d\n",new_int_time,new_gain_mode);
+
+	/* Deal with still low light */
+	if (new_int_time > m->max_int_time) {
+		if (permitclip)
+			new_int_time = m->max_int_time;
+		else
+			return I1PRO_RD_LIGHTTOOLOW;
+	}
+	a1logd(p->log,3,"after low light clip, inttime %f, gain mode %d\n",new_int_time,new_gain_mode);
+
+	/* Adjust to high light situation */
+	if (new_int_time < m->min_int_time && targoscale < 1.0) {
+		new_int_time /= targoscale;			/* Aim for non-scaled sensor optimum */
+		if (new_int_time > m->min_int_time)	/* But scale as much as possible */
+			new_int_time = m->min_int_time;
+	}
+	a1logd(p->log,3,"after high light adjust, inttime %f, gain mode %d\n",new_int_time,new_gain_mode);
+
+	/* Deal with still high light */
+	if (new_int_time < m->min_int_time) {
+		if (permitclip)
+			new_int_time = m->min_int_time;
+		else
+			return I1PRO_RD_LIGHTTOOHIGH;
+	}
+	a1logd(p->log,3,"after high light clip, returning inttime %f, gain mode %d\n",new_int_time,new_gain_mode);
+
+	if (pnew_int_time != NULL)
+		*pnew_int_time = new_int_time;
+
+	if (pnew_gain_mode != NULL)
+		*pnew_gain_mode = new_gain_mode;
+
+	return I1PRO_OK;
+}
+
+/* Compute the number of measurements needed, given the target */
+/* measurement time and integration time. Will return 0 if target time is 0 */
+int i1pro_comp_nummeas(
+	i1pro *p,
+	double meas_time,
+	double int_time
+) {
+	int nmeas;
+	if (meas_time <= 0.0)
+		return 0;
+	nmeas = (int)floor(meas_time/int_time + 0.5);
+	if (nmeas < 1)
+		nmeas = 1;
+	return nmeas;
+}
+
+/* Convert the dark interpolation data to a useful state */
+/* (also allow for interpolating the shielded cell values) */
+void
+i1pro_prepare_idark(
+	i1pro *p
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	int i, j;
+
+	/* For normal and high gain */
+	for (i = 0; i < 4; i+= 2) {
+		for (j = -1; j < m->nraw; j++) {
+			double d01, d1;
+			d01 = s->idark_data[i+0][j] * s->idark_int_time[i+0];
+			d1 = s->idark_data[i+1][j]  * s->idark_int_time[i+1];
+	
+			/* Compute increment */
+			s->idark_data[i+1][j] = (d1 - d01)/(s->idark_int_time[i+1] - s->idark_int_time[i+0]);
+	
+			/* Compute base */
+			s->idark_data[i+0][j] = d01 - s->idark_data[i+1][j] * s->idark_int_time[i+0];
+		}
+		if (p->itype == instI1Pro2) 	/* Rev E doesn't have high gain mode */
+			break;
+	}
+}
+
+/* Create the dark reference for the given integration time and gain */
+/* by interpolating from the 4 readings taken earlier. */
+i1pro_code
+i1pro_interp_dark(
+	i1pro *p,
+	double *result,		/* Put result of interpolation here */
+	double inttime,
+	int gainmode
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_state *s = &m->ms[m->mmode];
+	int i, j;
+
+	if (!s->idark_valid)
+		return I1PRO_INT_NOTCALIBRATED;
+		
+	i = 0;
+#ifdef USE_HIGH_GAIN_MODE
+	if (gainmode)
+		i = 2;
+#endif
+
+	for (j = -1; j < m->nraw; j++) {
+		double tt;
+		tt = s->idark_data[i+0][j] + inttime * s->idark_data[i+1][j];
+		tt /= inttime;
+		result[j] = tt;
+	}
+	return I1PRO_OK;
+}
+
+/* Set the noinitcalib mode */
+void i1pro_set_noinitcalib(i1pro *p, int v, int losecs) {
+	i1proimp *m = (i1proimp *)p->m;
+
+	/* Ignore disabling init calib if more than losecs since instrument was open */
+	if (v && losecs != 0 && m->lo_secs >= losecs) {
+		a1logd(p->log,3,"initcalib disable ignored because %d >= %d secs\n",m->lo_secs,losecs);
+		return;
+	}
+	m->noinitcalib = v;
+}
+
+/* Set the trigger config */
+void i1pro_set_trig(i1pro *p, inst_opt_type trig) {
+	i1proimp *m = (i1proimp *)p->m;
+	m->trig = trig;
+}
+
+/* Return the trigger config */
+inst_opt_type i1pro_get_trig(i1pro *p) {
+	i1proimp *m = (i1proimp *)p->m;
+	return m->trig;
+}
+
+/* Switch thread handler */
+int i1pro_switch_thread(void *pp) {
+	int nfailed = 0;
+	i1pro *p = (i1pro *)pp;
+	i1proimp *m = (i1proimp *)p->m;
+	i1pro_code rv = I1PRO_OK; 
+	a1logd(p->log,3,"Switch thread started\n");
+	for (nfailed = 0;nfailed < 5;) {
+		rv = i1pro_waitfor_switch_th(p, SW_THREAD_TIMEOUT);
+		a1logd(p->log,8,"Switch handler triggered with rv %d, th_term %d\n",rv,m->th_term);
+		if (m->th_term) {
+			m->th_termed = 1;
+			break;
+		}
+		if (rv == I1PRO_INT_BUTTONTIMEOUT) {
+			nfailed = 0;
+			continue;
+		}
+		if (rv != I1PRO_OK) {
+			nfailed++;
+			a1logd(p->log,3,"Switch thread failed with 0x%x\n",rv);
+			continue;
+		}
+		m->switch_count++;
+		if (!m->hide_switch && p->eventcallback != NULL) {
+			p->eventcallback(p->event_cntx, inst_event_switch);
+		}
+	}
+	a1logd(p->log,3,"Switch thread returning\n");
+	return rv;
+}
+
+/* ============================================================ */
+/* Low level i1pro commands */
+
+/* USB Instrument commands */
+
+/* Reset the instrument */
+i1pro_code
+i1pro_reset(
+	i1pro *p,
+	int mask	/* reset mask ?. Known values ar 0x1f, 0x07, 0x01 */
+				/* 0x1f = normal resent */
+				/* 0x01 = establish high power mode */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	unsigned char pbuf[2];	/* 1 or 2 bytes to write */
+	int len = 1;			/* Message length */
+	int se, rv = I1PRO_OK;
+	int stime = 0;
+
+	a1logd(p->log,2,"i1pro_reset: reset with mask 0x%02x @ %d msec\n",
+	                          mask,(stime = msec_time()) - m->msec);
+
+	pbuf[0] = mask;
+
+	if (p->itype == instI1Pro2) {
+		pbuf[1] = 0;		/* Not known what i1pro2 second byte is for */
+		len = 2;
+	}
+
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xCA, 0, 0, pbuf, len, 2.0);
+
+	rv = icoms2i1pro_err(se);
+
+	a1logd(p->log,2,"i1pro_reset: complete, ICOM err 0x%x (%d msec)\n",se,msec_time()-stime);
+
+	/* Allow time for hardware to stabalize */
+	msec_sleep(100);
+
+	/* Make sure that we re-initialize the measurement mode */
+	m->c_intclocks = 0;
+	m->c_lampclocks = 0;
+	m->c_nummeas = 0;
+	m->c_measmodeflags = 0;
+
+	return rv;
+}
+
+/* Read from the EEProm */
+i1pro_code
+i1pro_readEEProm(
+	i1pro *p,
+	unsigned char *buf,		/* Where to read it to */
+	int addr,				/* Address in EEprom to read from */
+	int size				/* Number of bytes to read (max 65535) */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	int rwbytes;			/* Data bytes read or written */
+	unsigned char pbuf[8];	/* Write EEprom parameters */
+	int len = 8;			/* Message length */
+	int se, rv = I1PRO_OK;
+	int stime;
+
+	if (size >= 0x10000)
+		return I1PRO_INT_EETOOBIG;
+
+	a1logd(p->log,2,"i1pro_readEEProm: address 0x%x size 0x%x @ %d msec\n",
+	                           addr, size, (stime = msec_time()) - m->msec);
+
+	int2buf(&pbuf[0], addr);
+	short2buf(&pbuf[4], size);
+	pbuf[6] = pbuf[7] = 0;		/* Ignored */
+
+	if (p->itype == instI1Pro2)
+		len = 6;
+
+  	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xC4, 0, 0, pbuf, len, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro_readEEProm: read failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	/* Now read the bytes */
+	se = p->icom->usb_read(p->icom, NULL, 0x82, buf, size, &rwbytes, 5.0);
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro_readEEProm: read failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	if (rwbytes != size) {
+		a1logd(p->log,1,"i1pro_readEEProm: 0x%x bytes, short read error\n",rwbytes);
+		return I1PRO_HW_EE_SHORTREAD;
+	}
+
+	if (p->log->debug >= 7) {
+		int i;
+		char oline[100], *bp = oline;
+		for (i = 0; i < size; i++) {
+			if ((i % 16) == 0)
+				bp += sprintf(bp,"    %04x:",i);
+			bp += sprintf(bp," %02x",buf[i]);
+			if ((i+1) >= size || ((i+1) % 16) == 0) {
+				bp += sprintf(bp,"\n");
+				a1logd(p->log,7,oline);
+				bp = oline;
+			}
+		}
+	}
+
+	a1logd(p->log,2,"i1pro_readEEProm: 0x%x bytes, ICOM err 0x%x (%d msec)\n",
+	                                          rwbytes, se, msec_time()-stime);
+
+	return rv;
+}
+
+/* Write to the EEProm */
+i1pro_code
+i1pro_writeEEProm(
+	i1pro *p,
+	unsigned char *buf,		/* Where to write from */
+	int addr,				/* Address in EEprom to write to */
+	int size				/* Number of bytes to write (max 65535) */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	int rwbytes;			/* Data bytes read or written */
+	unsigned char pbuf[8];	/* Write EEprom parameters */
+	int len = 8;			/* Message length */
+	int se = 0, rv = I1PRO_OK;
+	int i;
+	int stime;
+
+	/* Don't write over fixed values, as the instrument could become unusable.. */ 
+	if (addr < 0 || addr > 0x1000 || (addr + size) >= 0x1000)
+		return I1PRO_INT_EETOOBIG;
+
+	a1logd(p->log,2,"i1pro_writeEEProm: address 0x%x size 0x%x @ %d msec\n",
+	                             addr,size, (stime = msec_time()) - m->msec);
+
+	if (p->log->debug >= 6) {
+		int i;
+		char oline[100], *bp = oline;
+		for (i = 0; i < size; i++) {
+			if ((i % 16) == 0)
+				bp += sprintf(bp,"    %04x:",i);
+			bp += sprintf(bp," %02x",buf[i]);
+			if ((i+1) >= size || ((i+1) % 16) == 0) {
+				bp += sprintf(bp,"\n");
+				a1logd(p->log,6,oline);
+				bp = oline;
+			}
+		}
+	}
+
+#ifdef ENABLE_WRITE
+	int2buf(&pbuf[0], addr);
+	short2buf(&pbuf[4], size);
+	short2buf(&pbuf[6], 0x100);		/* Might be accidental, left over from getmisc.. */
+
+	if (p->itype == instI1Pro2)
+		len = 6;
+
+  	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xC3, 0, 0, pbuf, len, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,2,"i1pro_writeEEProm: write failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	/* Now write the bytes */
+	se = p->icom->usb_write(p->icom, NULL, 0x03, buf, size, &rwbytes, 5.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro_writeEEProm: failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	if (rwbytes != size) {
+		a1logd(p->log,1,"i1pro_writeEEProm: 0x%x bytes, short write error\n",rwbytes);
+		return I1PRO_HW_EE_SHORTWRITE;
+	}
+
+	/* Now we write two separate bytes of 0 - confirm write ?? */
+	for (i = 0; i < 2; i++) {
+		pbuf[0] = 0;
+
+		/* Now write the bytes */
+		se = p->icom->usb_write(p->icom, NULL, 0x03, pbuf, 1, &rwbytes, 5.0);
+
+		if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+			a1logd(p->log,1,"i1pro_writeEEProm: write failed with ICOM err 0x%x\n",se);
+			return rv;
+		}
+
+		if (rwbytes != 1) {
+			a1logd(p->log,1,"i1pro_writeEEProm: 0x%x bytes, short write error\n",rwbytes);
+			return I1PRO_HW_EE_SHORTWRITE;
+		}
+	}
+	a1logd(p->log,2,"i1pro_writeEEProm: 0x%x bytes, ICOM err 0x%x (%d msec)\n",
+	                   size, se, msec_time()-stime);
+
+	/* The instrument needs some recovery time after a write */
+	msec_sleep(50);
+
+#else /* ENABLE_WRITE */
+
+	a1logd(p->log,2,"i1pro_writeEEProm: (NOT) 0x%x bytes, ICOM err 0x%x\n",size, se);
+
+#endif /* ENABLE_WRITE */
+
+	return rv;
+}
+
+/* Get the miscellaneous status */
+/* return pointers may be NULL if not needed. */
+i1pro_code
+i1pro_getmisc(
+	i1pro *p,
+	int *fwrev,		/* Return the hardware version number */
+	int *unkn1,		/* Unknown status, set after doing a measurement */
+	int *maxpve,	/* Maximum positive value in sensor readings */
+	int *unkn3,		/* Unknown status, usually 1 */
+	int *powmode	/* 0 = high power mode, 8 = low power mode */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	unsigned char pbuf[8];	/* status bytes read */
+	int _fwrev;
+	int _unkn1;
+	int _maxpve;
+	int _unkn3;
+	int _powmode;
+	int se, rv = I1PRO_OK;
+	int stime = 0;
+
+	a1logd(p->log,2,"i1pro_getmisc: @ %d msec\n",(stime = msec_time()) - m->msec);
+
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xC9, 0, 0, pbuf, 8, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro_getmisc: failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	_fwrev   = buf2ushort(&pbuf[0]);
+	_unkn1   = buf2ushort(&pbuf[2]);	/* Value set after each read. Average ?? */
+	_maxpve  = buf2ushort(&pbuf[4]);
+	_unkn3   = pbuf[6];		/* Flag values are tested, but don't seem to be used ? */
+	_powmode = pbuf[7];
+
+	a1logd(p->log,2,"i1pro_getmisc: returning %d, 0x%04x, 0x%04x, 0x%02x, 0x%02x ICOM err 0x%x (%d msec)\n",
+	                   _fwrev, _unkn1, _maxpve, _unkn3, _powmode, se, msec_time()-stime);
+
+	if (fwrev != NULL) *fwrev = _fwrev;
+	if (unkn1 != NULL) *unkn1 = _unkn1;
+	if (maxpve != NULL) *maxpve = _maxpve;
+	if (unkn3 != NULL) *unkn3 = _unkn3;
+	if (powmode != NULL) *powmode = _powmode;
+
+	return rv;
+}
+
+/* Get the current measurement parameters */
+/* Return pointers may be NULL if not needed. */
+i1pro_code
+i1pro_getmeasparams(
+	i1pro *p,
+	int *intclocks,		/* Number of integration clocks */
+	int *lampclocks,	/* Number of lamp turn on sub-clocks */
+	int *nummeas,		/* Number of measurements */
+	int *measmodeflags	/* Measurement mode flags */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	unsigned char pbuf[8];	/* status bytes read */
+	int _intclocks;
+	int _lampclocks;
+	int _nummeas;
+	int _measmodeflags;
+	int se, rv = I1PRO_OK;
+	int stime = 0;
+
+	a1logd(p->log,2,"i1pro_getmeasparams: @ %d msec\n", (stime = msec_time()) - m->msec);
+
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xC2, 0, 0, pbuf, 8, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro_getmeasparams: failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	_intclocks     = buf2ushort(&pbuf[0]);
+	_lampclocks    = buf2ushort(&pbuf[2]);
+	_nummeas       = buf2ushort(&pbuf[4]);
+	_measmodeflags = pbuf[6];
+
+	a1logd(p->log,2,"i1pro_getmeasparams: returning %d, %d, %d, 0x%02x ICOM err 0x%x (%d msec)\n",
+	                   _intclocks, _lampclocks, _nummeas, _measmodeflags, se, msec_time()-stime);
+
+	if (intclocks != NULL) *intclocks = _intclocks;
+	if (lampclocks != NULL) *lampclocks = _lampclocks;
+	if (nummeas != NULL) *nummeas = _nummeas;
+	if (measmodeflags != NULL) *measmodeflags = _measmodeflags;
+
+	return rv;
+}
+
+/* Set the current measurement parameters */
+/* Return pointers may be NULL if not needed. */
+/* Quirks:
+
+	Rev. A upgrade:
+	Rev. B:
+		Appears to have a bug where the measurement time
+		is the sum of the previous measurement plus the current measurement.
+		It doesn't seem to alter the integration time though.
+		There is no obvious way of fixing this (ie. reseting the instrument
+		doesn't work).
+
+	Rev. D:
+		It appears that setting intclocks to 0, toggles to/from
+		a half clock speed mode. (?)
+*/
+
+i1pro_code
+i1pro_setmeasparams(
+	i1pro *p,
+	int intclocks,		/* Number of integration clocks */
+	int lampclocks,		/* Number of lamp turn on sub-clocks */
+	int nummeas,		/* Number of measurements */
+	int measmodeflags	/* Measurement mode flags */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	unsigned char pbuf[8];	/* command bytes written */
+	int se, rv = I1PRO_OK;
+	int stime = 0;
+
+	a1logd(p->log,2,"i1pro_setmeasparams: %d, %d, %d, 0x%02x @ %d msec\n",
+	                   intclocks, lampclocks, nummeas, measmodeflags,
+	                   (stime = msec_time()) - m->msec);
+
+	short2buf(&pbuf[0], intclocks);
+	short2buf(&pbuf[2], lampclocks);
+	short2buf(&pbuf[4], nummeas);
+	pbuf[6] = measmodeflags;
+	pbuf[7] = 0;
+
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xC1, 0, 0, pbuf, 8, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro_setmeasparams: failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	a1logd(p->log,2,"i1pro_setmeasparams: returning ICOM err 0x%x (%d msec)\n",
+	                                                     se,msec_time()-stime);
+	return rv;
+}
+
+/* Delayed trigger implementation, called from thread */
+static int
+i1pro_delayed_trigger(void *pp) {
+	i1pro *p = (i1pro *)pp;
+	i1proimp *m = (i1proimp *)p->m;
+	int se, rv = I1PRO_OK;
+	int stime = 0;
+
+	if ((m->c_measmodeflags & I1PRO_MMF_NOLAMP) == 0) {		/* Lamp will be on for measurement */
+		m->llampoffon = msec_time();						/* Record when it turned on */
+//		printf("~1 got lamp off -> on at %d (%f)\n",m->llampoffon, (m->llampoffon - m->llamponoff)/1000.0);
+
+	}
+
+	a1logd(p->log,2,"i1pro_delayed_trigger: start sleep @ %d msec\n", msec_time() - m->msec);
+
+	/* Delay the trigger */
+	msec_sleep(m->trig_delay);
+
+	m->tr_t1 = msec_time();		/* Diagnostic */
+
+	a1logd(p->log,2,"i1pro_delayed_trigger: trigger @ %d msec\n",(stime = msec_time()) - m->msec);
+
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xC0, 0, 0, NULL, 0, 2.0);
+
+	m->tr_t2 = msec_time();		/* Diagnostic */
+
+	m->trig_se = se;
+	m->trig_rv = icoms2i1pro_err(se);
+
+	a1logd(p->log,2,"i1pro_delayed_trigger: returning ICOM err 0x%x (%d msec)\n",
+	                                                       se,msec_time()-stime);
+
+	return 0;
+}
+
+/* Trigger a measurement after the nominated delay */
+/* The actual return code will be in m->trig_rv after the delay. */
+/* This allows us to start the measurement read before the trigger, */
+/* ensuring that process scheduling latency can't cause the read to fail. */
+i1pro_code
+i1pro_triggermeasure(i1pro *p, int delay) {
+	i1proimp *m = (i1proimp *)p->m;
+	int rv = I1PRO_OK;
+
+	a1logd(p->log,2,"i1pro_triggermeasure: trigger after %dmsec delay @ %d msec\n",
+	                                                 delay, msec_time() - m->msec);
+
+	/* NOTE := would be better here to create thread once, and then trigger it */
+	/* using a condition variable. */
+	if (m->trig_thread != NULL)
+		m->trig_thread->del(m->trig_thread);
+
+    m->tr_t1 = m->tr_t2 = m->tr_t3 = m->tr_t4 = m->tr_t5 = m->tr_t6 = m->tr_t7 = 0;
+	m->trig_delay = delay;
+
+	if ((m->trig_thread = new_athread(i1pro_delayed_trigger, (void *)p)) == NULL) {
+		a1logd(p->log,1,"i1pro_triggermeasure: creating delayed trigger thread failed\n");
+		return I1PRO_INT_THREADFAILED;
+	}
+
+#ifdef WAIT_FOR_DELAY_TRIGGER	/* hack to diagnose threading problems */
+	while (m->tr_t2 == 0) {
+		Sleep(1);
+	}
+#endif
+	a1logd(p->log,2,"i1pro_triggermeasure: scheduled triggering OK\n");
+
+	return rv;
+}
+
+/* Read a measurements results. */
+/* A buffer full of bytes is returned. */
+/* (This will fail on a Rev. A if there is more than about a 40 msec delay */
+/* between triggering the measurement and starting this read. */
+/* It appears though that the read can be pending before triggering though. */
+/* Scan reads will also terminate if there is too great a delay beteween each read.) */
+i1pro_code
+i1pro_readmeasurement(
+	i1pro *p,
+	int inummeas,			/* Initial number of measurements to expect */
+	int scanflag,			/* NZ if in scan mode to continue reading */
+	unsigned char *buf,		/* Where to read it to */
+	int bsize,				/* Bytes available in buffer */
+	int *nummeas,			/* Return number of readings measured */
+	i1p_mmodif mmodif		/* Measurement modifier enum */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	unsigned char *ibuf = buf;	/* Incoming buffer */
+	int nmeas;					/* Number of measurements for this read */
+	double top, extra;			/* Time out period */
+	int rwbytes;				/* Data bytes read or written */
+	int se, rv = I1PRO_OK;
+	int treadings = 0;
+	int stime = 0;
+//	int gotshort = 0;			/* nz when got a previous short reading */
+
+	if ((bsize % (m->nsen * 2)) != 0) {
+		return I1PRO_INT_ODDREADBUF;
+	}
+
+	a1logd(p->log,2,"i1pro_readmeasurement: inummeas %d, scanflag %d, address %p bsize 0x%x "
+	          "@ %d msec\n",inummeas, scanflag, buf, bsize, (stime = msec_time()) - m->msec);
+
+	extra = 2.0;		/* Extra timeout margin */
+
+	/* Deal with Rev A+ & Rev B quirk: */
+	if ((m->fwrev >= 200 && m->fwrev < 300)
+	 || (m->fwrev >= 300 && m->fwrev < 400))
+		extra += m->l_inttime;
+	m->l_inttime = m->c_inttime;
+
+#ifdef SINGLE_READ
+	if (scanflag == 0)
+		nmeas = inummeas;
+	else
+		nmeas = bsize / (m->nsen * 2);		/* Use a single large read */
+#else
+	nmeas = inummeas;				/* Smaller initial number of measurements */
+#endif
+
+	top = extra + m->c_inttime * nmeas;
+	if ((m->c_measmodeflags & I1PRO_MMF_NOLAMP) == 0)	/* Lamp is on */
+		top += m->c_lamptime;
+
+	/* NOTE :- for a scan on Rev. A, if we don't read fast enough the Eye-One will */
+	/* assume it should stop sending, even though the user has the switch pressed. */
+	/* For the rev A, this is quite a small margin (aprox. 1 msec ?) */
+	/* The Rev D has a lot more buffering, and is quite robust. */
+	/* By using the delayed trigger and a single read, this problem is usually */
+	/* eliminated. */
+	/* An unexpected short read seems to lock the instrument up. Not currently */
+	/* sure what sequence would recover it for a retry of the read. */
+	for (;;) {
+		int size;		/* number of bytes to read */
+
+		size = m->nsen * 2 * nmeas;
+
+		if (size > bsize) {		/* oops, no room for read */
+			a1logd(p->log,1,"i1pro_readmeasurement: buffer was too short for scan\n");
+			return I1PRO_INT_MEASBUFFTOOSMALL;
+		}
+
+		m->tr_t6 = msec_time();	/* Diagnostic, start of subsequent reads */
+		if (m->tr_t3 == 0) m->tr_t3 = m->tr_t6;		/* Diagnostic, start of first read */
+
+		se = p->icom->usb_read(p->icom, NULL, 0x82, buf, size, &rwbytes, top);
+
+		m->tr_t5 = m->tr_t7;
+		m->tr_t7 = msec_time();	/* Diagnostic, end of subsequent reads */
+		if (m->tr_t4 == 0) {
+			m->tr_t5 = m->tr_t2;
+			m->tr_t4 = m->tr_t7;	/* Diagnostic, end of first read */
+		}
+
+#ifdef NEVER		/* Use short + timeout to terminate scan */
+		if (gotshort != 0 && se == ICOM_TO) {	/* We got a timeout after a short read. */ 
+			a1logd(p->log,2,"i1pro_readmeasurement: timed out in %f secs after getting short read\n",top);
+			a1logd(p->log,2,"i1pro_readmeasurement: trig & rd times %d %d %d %d)\n",
+			    m->tr_t2-m->tr_t1, m->tr_t3-m->tr_t2, m->tr_t4-m->tr_t3, m->tr_t6-m->tr_t5);
+			break;		/* We're done */
+		} else
+#endif
+		  if (se == ICOM_SHORT) {		/* Expect this to terminate scan reading */
+			a1logd(p->log,2,"i1pro_readmeasurement: short read, read %d bytes, asked for %d\n",
+			                                                                     rwbytes,size);
+			a1logd(p->log,2,"i1pro_readmeasurement: trig & rd times %d %d %d %d)\n",
+			   m->tr_t2-m->tr_t1, m->tr_t3-m->tr_t2, m->tr_t4-m->tr_t3, m->tr_t6-m->tr_t5);
+		} else if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+			if (m->trig_rv != I1PRO_OK) {
+				a1logd(p->log,1,"i1pro_readmeasurement: trigger failed, ICOM err 0x%x\n",
+				                                                             m->trig_se);
+				return m->trig_rv;
+			}
+			if (se & ICOM_TO)
+				a1logd(p->log,1,"i1pro_readmeasurement: timed out with top = %f\n",top);
+			a1logd(p->log,1,"i1pro_readmeasurement: failed, bytes read 0x%x, ICOM err 0x%x\n",
+			                                                                     rwbytes, se);
+			return rv;
+		}
+ 
+		/* If we didn't read a multiple of m->nsen * 2, we've got problems */
+		if ((rwbytes % (m->nsen * 2)) != 0) {
+			a1logd(p->log,1,"i1pro_readmeasurement: read 0x%x bytes, odd read error\n",rwbytes);
+			return I1PRO_HW_ME_ODDREAD;
+		}
+
+		/* Track where we're up to */
+		bsize -= rwbytes;
+		buf   += rwbytes;
+		treadings += rwbytes/(m->nsen * 2);
+
+		if (scanflag == 0) {	/* Not scanning */
+
+			/* Expect to read exactly what we asked for */
+			if (rwbytes != size) {
+				a1logd(p->log,1,"i1pro_readmeasurement: unexpected short read, got %d expected %d\n"
+				                                                                     ,rwbytes,size);
+				return I1PRO_HW_ME_SHORTREAD;
+			}
+			break;	/* And we're done */
+		}
+
+#ifdef NEVER		/* Use short + timeout to terminate scan */
+		/* We expect to get a short read at the end of a scan, */
+		/* or we might have the USB transfer truncated by somethinge else. */
+		/* Note the short read, and keep reading until we get a time out */
+		if (rwbytes != size) {
+			gotshort = 1;
+		} else {
+			gotshort = 0;
+		}
+#else				/* Use short to terminate scan */
+		/* We're scanning and expect to get a short read at the end of the scan. */
+		if (rwbytes != size) {
+			break;
+		}
+#endif
+
+		if (bsize == 0) {		/* oops, no room for more scanning read */
+			unsigned char tbuf[NSEN_MAX * 2];
+
+			/* We need to clean up, so soak up all the data and throw it away */
+			while ((se = p->icom->usb_read(p->icom, NULL, 0x82, tbuf, m->nsen * 2, &rwbytes, top)) == ICOM_OK)
+				;
+			a1logd(p->log,1,"i1pro_readmeasurement: buffer was too short for scan\n");
+			return I1PRO_INT_MEASBUFFTOOSMALL;
+		}
+
+		/* Read a bunch more readings until the read is short or times out */
+		nmeas = bsize / (m->nsen * 2);
+		if (nmeas > 64)
+			nmeas = 64;
+		top = extra + m->c_inttime * nmeas;
+	}
+
+	if ((m->c_measmodeflags & I1PRO_MMF_NOLAMP) == 0) {		/* Lamp was on for measurement */
+		m->slamponoff = m->llamponoff;						/* remember second last */
+		m->llamponoff = msec_time();						/* Record when it turned off */
+//		printf("~1 got lamp on -> off at %d (%f)\n",m->llamponoff, (m->llamponoff - m->llampoffon)/1000.0);
+		m->lampage += (m->llamponoff - m->llampoffon)/1000.0;	/* Time lamp was on */
+	}
+	/* Update log values */
+	if (mmodif != i1p_dark_cal)
+		m->meascount++;
+
+	/* Must have timed out in initial readings */
+	if (treadings < inummeas) {
+		a1logd(p->log,1,"i1pro_readmeasurement: read failed, bytes read 0x%x, ICOM err 0x%x\n",
+		                                                                          rwbytes, se);
+		return I1PRO_RD_SHORTMEAS;
+	} 
+
+	if (p->log->debug >= 6) {
+		int i, size = treadings * m->nsen * 2;
+		char oline[100], *bp = oline;
+		for (i = 0; i < size; i++) {
+			if ((i % 16) == 0)
+				bp += sprintf(bp,"    %04x:",i);
+			bp += sprintf(bp," %02x",ibuf[i]);
+			if ((i+1) >= size || ((i+1) % 16) == 0) {
+				bp += sprintf(bp,"\n");
+				a1logd(p->log,6,oline);
+				bp = oline;
+			}
+		}
+	}
+
+	a1logd(p->log,2,"i1pro_readmeasurement: read %d readings, ICOM err 0x%x (%d msec)\n",
+	                                                   treadings, se, msec_time()-stime);
+	a1logd(p->log,2,"i1pro_readmeasurement: (trig & rd times %d %d %d %d)\n",
+	    m->tr_t2-m->tr_t1, m->tr_t3-m->tr_t2, m->tr_t4-m->tr_t3, m->tr_t6-m->tr_t5);
+
+	if (nummeas != NULL) *nummeas = treadings;
+
+	return rv;
+}
+
+/* Set the measurement clock mode */
+/* Firmware Version >= 301 only */
+i1pro_code
+i1pro_setmcmode(
+	i1pro *p,
+	int mcmode	/* Measurement clock mode, 1..mxmcmode */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	unsigned char pbuf[1];	/* 1 bytes to write */
+	int se, rv = I1PRO_OK;
+	int stime = 0;
+
+	a1logd(p->log,2,"i1pro_setmcmode: mode %d @ %d msec\n",
+	                   mcmode, (stime = msec_time()) - m->msec);
+
+	pbuf[0] = mcmode;
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xCF, 0, 0, pbuf, 1, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro_setmcmode: failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	a1logd(p->log,2,"i1pro_setmcmode: done, ICOM err 0x%x (%d msec)\n",
+	                                             se, msec_time()-stime);
+	return rv;
+}
+
+/* Get the current measurement clock mode */
+/* Return pointers may be NULL if not needed. */
+/* Firmware Version >= 301 only */
+i1pro_code
+i1pro_getmcmode(
+	i1pro *p,
+	int *maxmcmode,		/* mcmode must be <= maxmcmode */
+	int *mcmode,		/* readback current mcmode */
+	int *subclkdiv,		/* Sub clock divider ratio */
+	int *intclkusec,	/* Integration clock in usec */
+	int *subtmode		/* Subtract mode on read using average of value 127 */
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	unsigned char pbuf[8];	/* status bytes read */
+	int _maxmcmode;		/* mcmode must be < maxmcmode */
+	int _mcmode;		/* readback current mcmode */
+	int _unknown;		/* Unknown */
+	int _subclkdiv;		/* Sub clock divider ratio */
+	int _intclkusec;	/* Integration clock in usec */
+	int _subtmode;		/* Subtract mode on read using average of value 127 */
+	int se, rv = I1PRO_OK;
+	int stime = 0;
+
+	a1logd(p->log,2,"i1pro_getmcmode: called @ %d msec\n",
+	                   (stime = msec_time()) - m->msec);
+
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xD1, 0, 0, pbuf, 6, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro_getmcmode: failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	_maxmcmode  = pbuf[0];
+	_mcmode     = pbuf[1];
+	_unknown    = pbuf[2];
+	_subclkdiv  = pbuf[3];
+	_intclkusec = pbuf[4];
+	_subtmode   = pbuf[5];
+
+	a1logd(p->log,2,"i1pro_getmcmode: returns %d, %d, (%d), %d, %d 0x%x ICOM err 0x%x (%d msec)\n",
+	      _maxmcmode, _mcmode, _unknown, _subclkdiv, _intclkusec, _subtmode, se, msec_time()-stime);
+
+	if (maxmcmode != NULL) *maxmcmode = _maxmcmode;
+	if (mcmode != NULL) *mcmode = _mcmode;
+	if (subclkdiv != NULL) *subclkdiv = _subclkdiv;
+	if (intclkusec != NULL) *intclkusec = _intclkusec;
+	if (subtmode != NULL) *subtmode = _subtmode;
+
+	return rv;
+}
+
+
+/* Wait for a reply triggered by an instrument switch press */
+i1pro_code i1pro_waitfor_switch(i1pro *p, double top) {
+	i1proimp *m = (i1proimp *)p->m;
+	int rwbytes;			/* Data bytes read */
+	unsigned char buf[8];	/* Result  */
+	int se, rv = I1PRO_OK;
+	int stime = 0;
+
+	a1logd(p->log,2,"i1pro_waitfor_switch: read 1 byte from switch hit port @ %d msec\n",
+	                                                     (stime = msec_time()) - m->msec);
+
+	/* Now read 1 byte */
+	se = p->icom->usb_read(p->icom, NULL, 0x84, buf, 1, &rwbytes, top);
+
+	if (se & ICOM_TO) {
+		a1logd(p->log,2,"i1pro_waitfor_switch: read 0x%x bytes, timed out (%d msec)\n",
+		                   rwbytes,msec_time()-stime);
+		return I1PRO_INT_BUTTONTIMEOUT;
+	}
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro_waitfor_switch: failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	if (rwbytes != 1) {
+		a1logd(p->log,1,"i1pro_waitfor_switch: read 0x%x bytes, short read error (%d msec)\n",
+		                                                          rwbytes,msec_time()-stime);
+		return I1PRO_HW_SW_SHORTREAD;
+	}
+
+	a1logd(p->log,2,"i1pro_waitfor_switch: read 0x%x bytes value 0x%x ICOM err 0x%x (%d msec)\n",
+		                                                 rwbytes, buf[0], se, msec_time()-stime);
+
+	return rv; 
+}
+
+/* Wait for a reply triggered by a key press (thread version) */
+/* Returns I1PRO_OK if the switch has been pressed, */
+/* or I1PRO_INT_BUTTONTIMEOUT if */
+/* no switch was pressed befor the time expired, */
+/* or some other error. */
+i1pro_code i1pro_waitfor_switch_th(i1pro *p, double top) {
+	i1proimp *m = (i1proimp *)p->m;
+	int rwbytes;			/* Data bytes read */
+	unsigned char buf[8];	/* Result  */
+	int se, rv = I1PRO_OK;
+	int stime = 0;
+
+	a1logd(p->log,2,"i1pro_waitfor_switch_th: read 1 byte from switch hit port @ %d msec\n",
+	                                                      (stime = msec_time()) - m->msec);
+
+	/* Now read 1 byte */
+	se = p->icom->usb_read(p->icom, &m->cancelt, 0x84, buf, 1, &rwbytes, top);
+
+	if (se & ICOM_TO) {
+		a1logd(p->log,2,"i1pro_waitfor_switch_th: read 0x%x bytes, timed out (%d msec)\n",
+		                                                      rwbytes,msec_time()-stime);
+		return I1PRO_INT_BUTTONTIMEOUT;
+	}
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,2,"i1pro_waitfor_switch_th: failed with ICOM err 0x%x (%d msec)\n",
+		                                                           se,msec_time()-stime);
+		return rv;
+	}
+
+	if (rwbytes != 1) {
+		a1logd(p->log,2,"i1pro_waitfor_switch_th: read 0x%x bytes, short read error (%d msec)\n",
+		                                                              rwbytes,msec_time()-stime);
+		return I1PRO_HW_SW_SHORTREAD;
+	}
+
+	a1logd(p->log,2,"i1pro_waitfor_switch_th: read 0x%x bytes value 0x%x ICOM err 0x%x (%d msec)\n",
+		                                                   rwbytes, buf[0], se,msec_time()-stime);
+
+	return rv; 
+}
+
+/* Terminate switch handling */
+/* This seems to always return an error ? */
+i1pro_code
+i1pro_terminate_switch(
+	i1pro *p
+) {
+	i1proimp *m = (i1proimp *)p->m;
+	unsigned char pbuf[8];	/* 8 bytes to write */
+	int se, rv = I1PRO_OK;
+
+	a1logd(p->log,2,"i1pro_terminate_switch: called\n");
+
+	/* These values may not be significant */
+	pbuf[0] = pbuf[1] = pbuf[2] = pbuf[3] = 0xff;
+	pbuf[4] = 0xfc;
+	pbuf[5] = 0xee;
+	pbuf[6] = 0x12;
+	pbuf[7] = 0x00;
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xD0, 3, 0, pbuf, 8, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,2,"i1pro_terminate_switch: Warning: Terminate Switch Handling failed with ICOM err 0x%x\n",se);
+	} else {
+		a1logd(p->log,2,"i1pro_terminate_switch: done, ICOM err 0x%x\n",se);
+	}
+
+	/* In case the above didn't work, cancel the I/O */
+	msec_sleep(50);
+	if (m->th_termed == 0) {
+		a1logd(p->log,3,"i1pro terminate switch thread failed, canceling I/O\n");
+		p->icom->usb_cancel_io(p->icom, &m->cancelt);
+	}
+	
+	return rv;
+}
+
+/* ============================================================ */
+/* Low level i1pro2 (Rev E) commands */
+
+/* Get the EEProm size */
+i1pro_code
+i1pro2_geteesize(
+    i1pro *p,
+    int *eesize
+) {
+	int se, rv = I1PRO_OK;
+	unsigned char buf[4];	/* Result  */
+	int _eesize = 0;
+
+	a1logd(p->log,2,"i1pro2_geteesize: called\n");
+
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xD9, 0, 0, buf, 4, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro2_geteesize: failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	_eesize = buf2int(buf);
+
+	a1logd(p->log,2,"i1pro2_geteesize: returning %d ICOM err 0x%x\n", _eesize, se);
+
+	if (eesize != NULL)
+		*eesize = _eesize;
+
+	return rv;
+}
+
+/* Get the Chip ID */
+/* This does actually work with the Rev D. */
+/* (It returns all zero's unless you've read the EEProm first !) */
+i1pro_code
+i1pro2_getchipid(
+	i1pro *p,
+	unsigned char chipid[8]
+) {
+	int se, rv = I1PRO_OK;
+
+	a1logd(p->log,2,"i1pro2_getchipid: called\n");
+
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xD2, 0, 0, chipid, 8, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro2_getchipid: failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	a1logd(p->log,2,"i1pro2_getchipid: returning %02X-%02X%02X%02X%02X%02X%02X%02X ICOM err 0x%x\n",
+                           chipid[0], chipid[1], chipid[2], chipid[3],
+                           chipid[4], chipid[5], chipid[6], chipid[7], se);
+	return rv;
+}
+
+/* Get Rev E measure characteristics. */
+i1pro_code
+i1pro2_getmeaschar(
+    i1pro *p,
+    int *clkusec,		/* Return integration clock length in usec ?      (ie. 36)  */
+    int *xraw,			/* Return number of extra non-reading (dark) raw bands ? (ie. 6)   */
+    int *nraw,			/* Return number of reading raw bands ?           (ie. 128) */
+    int *subdiv			/* Sub divider and minium integration clocks  ?   (ie. 136) */
+) {
+	int se, rv = I1PRO_OK;
+	unsigned char buf[16];	/* Result  */
+    int _clkusec;
+    int _xraw;
+    int _nraw;
+    int _subdiv;
+
+	a1logd(p->log,2,"i1pro2_getmeaschar: called\n");
+
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xD5, 0, 0, buf, 16, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro2_getmeaschar: failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	_clkusec = buf2int(buf + 0);
+	_xraw = buf2int(buf + 4);
+	_nraw = buf2int(buf + 8);
+	_subdiv = buf2int(buf + 12);
+
+	a1logd(p->log,2,"i1pro2_getmeaschar: returning clkusec %d, xraw %d, nraw %d, subdiv %d ICOM err 0x%x\n", _clkusec, _xraw, _nraw, _subdiv, se);
+
+	if (clkusec != NULL)
+		*clkusec = _clkusec;
+	if (xraw != NULL)
+		*xraw = _xraw;
+	if (nraw != NULL)
+		*nraw = _nraw;
+	if (subdiv != NULL)
+		*subdiv = _subdiv;
+
+	return rv;
+}
+
+/* Delayed trigger implementation, called from thread */
+/* We assume that the Rev E measurement parameters have been set in */
+/* the i1proimp structure c_* values */
+static int
+i1pro2_delayed_trigger(void *pp) {
+	i1pro *p = (i1pro *)pp;
+	i1proimp *m = (i1proimp *)p->m;
+	unsigned char pbuf[14];	/* 14 bytes to write */
+	int se, rv = I1PRO_OK;
+	int stime = 0;
+
+	int2buf(pbuf + 0, m->c_intclocks); 
+	int2buf(pbuf + 4, m->c_lampclocks); 
+	int2buf(pbuf + 8, m->c_nummeas); 
+	short2buf(pbuf + 12, m->c_measmodeflags2); 
+
+	if ((m->c_measmodeflags & I1PRO_MMF_NOLAMP) == 0) {		/* Lamp will be on for measurement */
+		m->llampoffon = msec_time();						/* Record when it turned on */
+	}
+
+	a1logd(p->log,2,"i1pro2_delayed_trigger: Rev E start sleep @ %d msec\n",
+	                                                 msec_time() - m->msec);
+
+	/* Delay the trigger */
+	msec_sleep(m->trig_delay);
+
+	m->tr_t1 = msec_time();		/* Diagnostic */
+
+	a1logd(p->log,2,"i1pro2_delayed_trigger: trigger Rev E @ %d msec\n",
+	                                     (stime = msec_time()) - m->msec);
+
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xD4, 0, 0, pbuf, 14, 2.0);
+
+	m->tr_t2 = msec_time();		/* Diagnostic */
+
+	m->trig_se = se;
+	m->trig_rv = icoms2i1pro_err(se);
+
+	a1logd(p->log,2,"i1pro2_delayed_trigger: done ICOM err 0x%x (%d msec)\n",
+	                                                  se,msec_time()-stime);
+	return 0;
+}
+
+/* Trigger a measurement after the nominated delay */
+/* The actual return code will be in m->trig_rv after the delay. */
+/* This allows us to start the measurement read before the trigger, */
+/* ensuring that process scheduling latency can't cause the read to fail. */
+i1pro_code
+i1pro2_triggermeasure(i1pro *p, int delay) {
+	i1proimp *m = (i1proimp *)p->m;
+	int rv = I1PRO_OK;
+
+	a1logd(p->log,2,"i1pro2_triggermeasure: triggering Rev Emeasurement after %dmsec "
+	                               "delay @ %d msec\n", delay, msec_time() - m->msec);
+
+	/* NOTE := would be better here to create thread once, and then trigger it */
+	/* using a condition variable. */
+	if (m->trig_thread != NULL)
+		m->trig_thread->del(m->trig_thread);
+
+    m->tr_t1 = m->tr_t2 = m->tr_t3 = m->tr_t4 = m->tr_t5 = m->tr_t6 = m->tr_t7 = 0;
+	m->trig_delay = delay;
+
+	if ((m->trig_thread = new_athread(i1pro2_delayed_trigger, (void *)p)) == NULL) {
+		a1logd(p->log,1,"i1pro2_triggermeasure: creating delayed trigger Rev E thread failed\n");
+		return I1PRO_INT_THREADFAILED;
+	}
+
+#ifdef WAIT_FOR_DELAY_TRIGGER	/* hack to diagnose threading problems */
+	while (m->tr_t2 == 0) {
+		Sleep(1);
+	}
+#endif
+	a1logd(p->log,2,"i1pro2_triggermeasure: scheduled triggering Rev E OK\n");
+
+	return rv;
+}
+
+/* Get the UV before and after measurement voltage drop */
+i1pro_code
+i1pro2_getUVvolts(
+    i1pro *p,
+    int *before,
+    int *after
+) {
+	int se, rv = I1PRO_OK;
+	unsigned char buf[4];	/* Result  */
+	int _before = 0;
+	int _after = 0;
+
+	a1logd(p->log,2,"i1pro2_getUVvolts: called\n");
+
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xD8, 0, 0, buf, 4, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro2_getUVvolts: failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	_before = buf2ushort(buf);
+	_after = buf2ushort(buf+2);
+
+	a1logd(p->log,2,"i1pro2_getUVvolts: returning %d, %d ICOM err 0x%x\n", _before, _after, se);
+
+	if (before != NULL)
+		*before = _before;
+
+	if (after != NULL)
+		*after = _after;
+
+	return rv;
+}
+
+/* Terminate Ruler tracking (???) */
+/* The parameter seems to be always 0 ? */
+static int
+i1pro2_stop_ruler(void *pp, int parm) {
+	i1pro *p = (i1pro *)pp;
+	i1proimp *m = (i1proimp *)p->m;
+	unsigned char pbuf[2];	/* 2 bytes to write */
+	int se, rv = I1PRO_OK;
+
+	short2buf(pbuf, parm); 
+
+	a1logd(p->log,2,"i1pro2_stop_ruler: called with 0x%x\n", parm);
+
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xD7, 0, 0, pbuf, 2, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro2_stop_ruler: failed with ICOM err 0x%x\n",rv);
+		return rv;
+	}
+
+	a1logd(p->log,2,"i1pro2_stop_ruler: returning ICOM err 0x%x\n",rv);
+
+	return rv;
+}
+
+	/* Send a raw indicator LED sequence. */
+/*
+	The byte sequence has the following format:
+	(all values are big endian)
+
+	XXXX	Number of following blocks, BE.
+
+	Blocks are:
+
+	YYYY	Number of bytes in the block
+	RRRR	Number of repeats of the block, FFFFFFFF = infinite
+
+	A sequence of codes:
+
+	LL TTTT
+			L = Led mask:
+				01 = Red Right
+				02 = Green Right
+				04 = Blue Right
+				08 = Red Left
+				10 = Green Left
+				20 = Blue Left
+			TTT = clock count for this mask (ie. aprox. 73 usec clock period)
+	PWM typically alternates between on & off state with a period total of
+	0x50 clocks = 170 Hz. 255 clocks would be 54 Hz.
+
+ */
+
+static int
+i1pro2_indLEDseq(void *pp, unsigned char *buf, int size) {
+	i1pro *p = (i1pro *)pp;
+	i1proimp *m = (i1proimp *)p->m;
+	int rwbytes;			/* Data bytes written */
+	unsigned char pbuf[4];	/* Number of bytes being send */
+	int se, rv = I1PRO_OK;
+
+	int2buf(pbuf, size); 
+
+	a1logd(p->log,2,"i1pro2_indLEDseq: length %d bytes\n", size);
+
+	se = p->icom->usb_control(p->icom,
+		               IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+	                   0xD6, 0, 0, pbuf, 4, 2.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro2_indLEDseq: failed with ICOM err 0x%x\n",rv);
+		return rv;
+	}
+
+	a1logd(p->log,2,"i1pro2_geteesize: command got ICOM err 0x%x\n", se);
+
+	/* Now write the bytes */
+	se = p->icom->usb_write(p->icom, NULL, 0x03, buf, size, &rwbytes, 5.0);
+
+	if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+		a1logd(p->log,1,"i1pro2_indLEDseq: data write failed with ICOM err 0x%x\n",se);
+		return rv;
+	}
+
+	if (rwbytes != size) {
+		a1logd(p->log,1,"i1pro2_indLEDseq: wrote 0x%x bytes, short write error\n",rwbytes);
+		return I1PRO_HW_LED_SHORTWRITE;
+	}
+
+	a1logd(p->log,2,"i1pro2_indLEDseq: wrote 0x%x bytes LED sequence, ICOM err 0x%x\n", size, rv);
+
+	return rv;
+}
+
+/* Turn indicator LEDs off */
+static int
+i1pro2_indLEDoff(void *pp) {
+	i1pro *p = (i1pro *)pp;
+	int rv = I1PRO_OK;
+	unsigned char seq[] = {
+		0x00, 0x00, 0x00, 0x01,
+
+		0x00, 0x00, 0x00, 0x07,
+		0x00, 0x00, 0x00, 0x01,
+		0x00, 0x00, 0x10
+	};
+
+	a1logd(p->log,2,"i1pro2_indLEDoff: called\n");
+	rv = i1pro2_indLEDseq(p, seq, sizeof(seq));
+	a1logd(p->log,2,"i1pro2_indLEDoff: returning ICOM err 0x%x\n",rv);
+
+	return rv;
+}
+
+#ifdef NEVER
+
+	// ~~99 play with LED settings
+	if (p->itype == instI1Pro2) {
+
+		// LED is capable of white and red
+
+		/* Turns it off */
+		unsigned char b1[] = {
+			0x00, 0x00, 0x00, 0x01,
+
+			0x00, 0x00, 0x00, 0x07,
+			0x00, 0x00, 0x00, 0x01,
+			0x00, 0x00, 0x01
+		};
+
+		/* Makes it white */
+		unsigned char b2[] = {
+			0x00, 0x00, 0x00, 0x02,
+
+			0x00, 0x00, 0x00, 0x0a,
+			0x00, 0x00, 0x00, 0x01,
+			0x00, 0x36, 0x00,
+			0x00, 0x00, 0x01,
+
+			0x00, 0x00, 0x00, 0x0a,
+			0xff, 0xff, 0xff, 0xff,
+			0x3f, 0x36, 0x40,
+			0x00, 0x00, 0x01
+		};
+
+		/* Makes it pulsing white */
+		unsigned char b3[] = {
+			0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x36, 0x40, 0x00,
+			0x00, 0x01, 0x00, 0x00, 0x08, 0xec, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x03, 0x00, 0x00, 0x50, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x50, 0x3f, 0x00, 0x03, 0x00,
+			0x00, 0x4d, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x45, 0x3f, 0x00,
+			0x03, 0x00, 0x00, 0x42, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x42, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x4f,
+			0x3f, 0x00, 0x04, 0x00, 0x00, 0x4d, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x04, 0x00,
+			0x00, 0x46, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x41, 0x3f, 0x00,
+			0x05, 0x00, 0x00, 0x4d, 0x3f, 0x00, 0x05, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x05, 0x00, 0x00, 0x46,
+			0x3f, 0x00, 0x05, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x06, 0x00, 0x00, 0x4d, 0x3f, 0x00, 0x06, 0x00,
+			0x00, 0x4a, 0x3f, 0x00, 0x06, 0x00, 0x00, 0x47, 0x3f, 0x00, 0x06, 0x00, 0x00, 0x44, 0x3f, 0x00,
+			0x06, 0x00, 0x00, 0x41, 0x3f, 0x00, 0x07, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x07, 0x00, 0x00, 0x46,
+			0x3f, 0x00, 0x07, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x08, 0x00, 0x00, 0x4a, 0x3f, 0x00, 0x07, 0x00,
+			0x00, 0x3e, 0x3f, 0x00, 0x08, 0x00, 0x00, 0x44, 0x3f, 0x00, 0x09, 0x00, 0x00, 0x4a, 0x3f, 0x00,
+			0x09, 0x00, 0x00, 0x47, 0x3f, 0x00, 0x09, 0x00, 0x00, 0x44, 0x3f, 0x00, 0x0a, 0x00, 0x00, 0x49,
+			0x3f, 0x00, 0x09, 0x00, 0x00, 0x3f, 0x3f, 0x00, 0x09, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x0b, 0x00,
+			0x00, 0x48, 0x3f, 0x00, 0x0b, 0x00, 0x00, 0x45, 0x3f, 0x00, 0x0a, 0x00, 0x00, 0x3c, 0x3f, 0x00,
+			0x0c, 0x00, 0x00, 0x46, 0x3f, 0x00, 0x0c, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x0d, 0x00, 0x00, 0x46,
+			0x3f, 0x00, 0x0c, 0x00, 0x00, 0x3e, 0x3f, 0x00, 0x0c, 0x00, 0x00, 0x3c, 0x3f, 0x00, 0x0d, 0x00,
+			0x00, 0x3f, 0x3f, 0x00, 0x0d, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x0e, 0x00, 0x00, 0x3f, 0x3f, 0x00,
+			0x0e, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x0e, 0x00, 0x00, 0x3b, 0x3f, 0x00, 0x0f, 0x00, 0x00, 0x3d,
+			0x3f, 0x00, 0x0e, 0x00, 0x00, 0x37, 0x3f, 0x00, 0x0f, 0x00, 0x00, 0x39, 0x3f, 0x00, 0x10, 0x00,
+			0x00, 0x3b, 0x3f, 0x00, 0x12, 0x00, 0x00, 0x40, 0x3f, 0x00, 0x10, 0x00, 0x00, 0x37, 0x3f, 0x00,
+			0x13, 0x00, 0x00, 0x3f, 0x3f, 0x00, 0x13, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x11, 0x00, 0x00, 0x34,
+			0x3f, 0x00, 0x12, 0x00, 0x00, 0x36, 0x3f, 0x00, 0x12, 0x00, 0x00, 0x34, 0x3f, 0x00, 0x14, 0x00,
+			0x00, 0x38, 0x3f, 0x00, 0x14, 0x00, 0x00, 0x36, 0x3f, 0x00, 0x17, 0x00, 0x00, 0x3c, 0x3f, 0x00,
+			0x17, 0x00, 0x00, 0x3a, 0x3f, 0x00, 0x18, 0x00, 0x00, 0x3a, 0x3f, 0x00, 0x15, 0x00, 0x00, 0x31,
+			0x3f, 0x00, 0x17, 0x00, 0x00, 0x34, 0x3f, 0x00, 0x16, 0x00, 0x00, 0x30, 0x3f, 0x00, 0x1a, 0x00,
+			0x00, 0x37, 0x3f, 0x00, 0x1b, 0x00, 0x00, 0x37, 0x3f, 0x00, 0x18, 0x00, 0x00, 0x2f, 0x3f, 0x00,
+			0x1c, 0x00, 0x00, 0x35, 0x3f, 0x00, 0x1c, 0x00, 0x00, 0x33, 0x3f, 0x00, 0x1c, 0x00, 0x00, 0x31,
+			0x3f, 0x00, 0x1d, 0x00, 0x00, 0x31, 0x3f, 0x00, 0x1b, 0x00, 0x00, 0x2c, 0x3f, 0x00, 0x1c, 0x00,
+			0x00, 0x2c, 0x3f, 0x00, 0x1d, 0x00, 0x00, 0x2c, 0x3f, 0x00, 0x1e, 0x00, 0x00, 0x2c, 0x3f, 0x00,
+			0x1d, 0x00, 0x00, 0x29, 0x3f, 0x00, 0x1e, 0x00, 0x00, 0x29, 0x3f, 0x00, 0x23, 0x00, 0x00, 0x2e,
+			0x3f, 0x00, 0x22, 0x00, 0x00, 0x2b, 0x3f, 0x00, 0x25, 0x00, 0x00, 0x2d, 0x3f, 0x00, 0x24, 0x00,
+			0x00, 0x2a, 0x3f, 0x00, 0x22, 0x00, 0x00, 0x26, 0x3f, 0x00, 0x27, 0x00, 0x00, 0x2a, 0x3f, 0x00,
+			0x22, 0x00, 0x00, 0x23, 0x3f, 0x00, 0x23, 0x00, 0x00, 0x23, 0x3f, 0x00, 0x2a, 0x00, 0x00, 0x28,
+			0x3f, 0x00, 0x24, 0x00, 0x00, 0x21, 0x3f, 0x00, 0x29, 0x00, 0x00, 0x24, 0x3f, 0x00, 0x2c, 0x00,
+			0x00, 0x25, 0x3f, 0x00, 0x28, 0x00, 0x00, 0x20, 0x3f, 0x00, 0x2b, 0x00, 0x00, 0x21, 0x3f, 0x00,
+			0x2d, 0x00, 0x00, 0x21, 0x3f, 0x00, 0x2b, 0x00, 0x00, 0x1e, 0x3f, 0x00, 0x2a, 0x00, 0x00, 0x1c,
+			0x3f, 0x00, 0x2f, 0x00, 0x00, 0x1e, 0x3f, 0x00, 0x2b, 0x00, 0x00, 0x1a, 0x3f, 0x00, 0x2d, 0x00,
+			0x00, 0x1a, 0x3f, 0x00, 0x31, 0x00, 0x00, 0x1b, 0x3f, 0x00, 0x2e, 0x00, 0x00, 0x18, 0x3f, 0x00,
+			0x37, 0x00, 0x00, 0x1b, 0x3f, 0x00, 0x38, 0x00, 0x00, 0x1a, 0x3f, 0x00, 0x37, 0x00, 0x00, 0x18,
+			0x3f, 0x00, 0x31, 0x00, 0x00, 0x14, 0x3f, 0x00, 0x39, 0x00, 0x00, 0x16, 0x3f, 0x00, 0x3d, 0x00,
+			0x00, 0x16, 0x3f, 0x00, 0x36, 0x00, 0x00, 0x12, 0x3f, 0x00, 0x3a, 0x00, 0x00, 0x12, 0x3f, 0x00,
+			0x3b, 0x00, 0x00, 0x11, 0x3f, 0x00, 0x40, 0x00, 0x00, 0x11, 0x3f, 0x00, 0x3a, 0x00, 0x00, 0x0e,
+			0x3f, 0x00, 0x3b, 0x00, 0x00, 0x0d, 0x3f, 0x00, 0x3c, 0x00, 0x00, 0x0c, 0x3f, 0x00, 0x3d, 0x00,
+			0x00, 0x0b, 0x3f, 0x00, 0x3e, 0x00, 0x00, 0x0a, 0x3f, 0x00, 0x3f, 0x00, 0x00, 0x09, 0x3f, 0x00,
+			0x40, 0x00, 0x00, 0x08, 0x3f, 0x00, 0x42, 0x00, 0x00, 0x07, 0x3f, 0x00, 0x44, 0x00, 0x00, 0x06,
+			0x3f, 0x00, 0x47, 0x00, 0x00, 0x05, 0x3f, 0x00, 0x4b, 0x00, 0x00, 0x04, 0x3f, 0x00, 0x50, 0x00,
+			0x00, 0x03, 0x3f, 0x00, 0x44, 0x00, 0x00, 0x01, 0x3f, 0x00, 0x45, 0x3f, 0x00, 0x45, 0x3f, 0x00,
+			0x45, 0x3f, 0x00, 0x45, 0x3f, 0x00, 0x44, 0x00, 0x00, 0x01, 0x3f, 0x00, 0x50, 0x00, 0x00, 0x03,
+			0x3f, 0x00, 0x4b, 0x00, 0x00, 0x04, 0x3f, 0x00, 0x47, 0x00, 0x00, 0x05, 0x3f, 0x00, 0x44, 0x00,
+			0x00, 0x06, 0x3f, 0x00, 0x42, 0x00, 0x00, 0x07, 0x3f, 0x00, 0x40, 0x00, 0x00, 0x08, 0x3f, 0x00,
+			0x3f, 0x00, 0x00, 0x09, 0x3f, 0x00, 0x3e, 0x00, 0x00, 0x0a, 0x3f, 0x00, 0x3d, 0x00, 0x00, 0x0b,
+			0x3f, 0x00, 0x3c, 0x00, 0x00, 0x0c, 0x3f, 0x00, 0x3b, 0x00, 0x00, 0x0d, 0x3f, 0x00, 0x3a, 0x00,
+			0x00, 0x0e, 0x3f, 0x00, 0x40, 0x00, 0x00, 0x11, 0x3f, 0x00, 0x3b, 0x00, 0x00, 0x11, 0x3f, 0x00,
+			0x3a, 0x00, 0x00, 0x12, 0x3f, 0x00, 0x36, 0x00, 0x00, 0x12, 0x3f, 0x00, 0x3d, 0x00, 0x00, 0x16,
+			0x3f, 0x00, 0x39, 0x00, 0x00, 0x16, 0x3f, 0x00, 0x31, 0x00, 0x00, 0x14, 0x3f, 0x00, 0x37, 0x00,
+			0x00, 0x18, 0x3f, 0x00, 0x38, 0x00, 0x00, 0x1a, 0x3f, 0x00, 0x37, 0x00, 0x00, 0x1b, 0x3f, 0x00,
+			0x2e, 0x00, 0x00, 0x18, 0x3f, 0x00, 0x31, 0x00, 0x00, 0x1b, 0x3f, 0x00, 0x2d, 0x00, 0x00, 0x1a,
+			0x3f, 0x00, 0x2b, 0x00, 0x00, 0x1a, 0x3f, 0x00, 0x2f, 0x00, 0x00, 0x1e, 0x3f, 0x00, 0x2a, 0x00,
+			0x00, 0x1c, 0x3f, 0x00, 0x2b, 0x00, 0x00, 0x1e, 0x3f, 0x00, 0x2d, 0x00, 0x00, 0x21, 0x3f, 0x00,
+			0x2b, 0x00, 0x00, 0x21, 0x3f, 0x00, 0x28, 0x00, 0x00, 0x20, 0x3f, 0x00, 0x2c, 0x00, 0x00, 0x25,
+			0x3f, 0x00, 0x29, 0x00, 0x00, 0x24, 0x3f, 0x00, 0x24, 0x00, 0x00, 0x21, 0x3f, 0x00, 0x2a, 0x00,
+			0x00, 0x28, 0x3f, 0x00, 0x23, 0x00, 0x00, 0x23, 0x3f, 0x00, 0x22, 0x00, 0x00, 0x23, 0x3f, 0x00,
+			0x27, 0x00, 0x00, 0x2a, 0x3f, 0x00, 0x22, 0x00, 0x00, 0x26, 0x3f, 0x00, 0x24, 0x00, 0x00, 0x2a,
+			0x3f, 0x00, 0x25, 0x00, 0x00, 0x2d, 0x3f, 0x00, 0x22, 0x00, 0x00, 0x2b, 0x3f, 0x00, 0x23, 0x00,
+			0x00, 0x2e, 0x3f, 0x00, 0x1e, 0x00, 0x00, 0x29, 0x3f, 0x00, 0x1d, 0x00, 0x00, 0x29, 0x3f, 0x00,
+			0x1e, 0x00, 0x00, 0x2c, 0x3f, 0x00, 0x1d, 0x00, 0x00, 0x2c, 0x3f, 0x00, 0x1c, 0x00, 0x00, 0x2c,
+			0x3f, 0x00, 0x1b, 0x00, 0x00, 0x2c, 0x3f, 0x00, 0x1d, 0x00, 0x00, 0x31, 0x3f, 0x00, 0x1c, 0x00,
+			0x00, 0x31, 0x3f, 0x00, 0x1c, 0x00, 0x00, 0x33, 0x3f, 0x00, 0x1c, 0x00, 0x00, 0x35, 0x3f, 0x00,
+			0x18, 0x00, 0x00, 0x2f, 0x3f, 0x00, 0x1b, 0x00, 0x00, 0x37, 0x3f, 0x00, 0x1a, 0x00, 0x00, 0x37,
+			0x3f, 0x00, 0x16, 0x00, 0x00, 0x30, 0x3f, 0x00, 0x17, 0x00, 0x00, 0x34, 0x3f, 0x00, 0x15, 0x00,
+			0x00, 0x31, 0x3f, 0x00, 0x18, 0x00, 0x00, 0x3a, 0x3f, 0x00, 0x17, 0x00, 0x00, 0x3a, 0x3f, 0x00,
+			0x17, 0x00, 0x00, 0x3c, 0x3f, 0x00, 0x14, 0x00, 0x00, 0x36, 0x3f, 0x00, 0x14, 0x00, 0x00, 0x38,
+			0x3f, 0x00, 0x12, 0x00, 0x00, 0x34, 0x3f, 0x00, 0x12, 0x00, 0x00, 0x36, 0x3f, 0x00, 0x11, 0x00,
+			0x00, 0x34, 0x3f, 0x00, 0x13, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x13, 0x00, 0x00, 0x3f, 0x3f, 0x00,
+			0x10, 0x00, 0x00, 0x37, 0x3f, 0x00, 0x12, 0x00, 0x00, 0x40, 0x3f, 0x00, 0x10, 0x00, 0x00, 0x3b,
+			0x3f, 0x00, 0x0f, 0x00, 0x00, 0x39, 0x3f, 0x00, 0x0e, 0x00, 0x00, 0x37, 0x3f, 0x00, 0x0f, 0x00,
+			0x00, 0x3d, 0x3f, 0x00, 0x0e, 0x00, 0x00, 0x3b, 0x3f, 0x00, 0x0e, 0x00, 0x00, 0x3d, 0x3f, 0x00,
+			0x0e, 0x00, 0x00, 0x3f, 0x3f, 0x00, 0x0d, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x0d, 0x00, 0x00, 0x3f,
+			0x3f, 0x00, 0x0c, 0x00, 0x00, 0x3c, 0x3f, 0x00, 0x0c, 0x00, 0x00, 0x3e, 0x3f, 0x00, 0x0d, 0x00,
+			0x00, 0x46, 0x3f, 0x00, 0x0c, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x0c, 0x00, 0x00, 0x46, 0x3f, 0x00,
+			0x0a, 0x00, 0x00, 0x3c, 0x3f, 0x00, 0x0b, 0x00, 0x00, 0x45, 0x3f, 0x00, 0x0b, 0x00, 0x00, 0x48,
+			0x3f, 0x00, 0x09, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x09, 0x00, 0x00, 0x3f, 0x3f, 0x00, 0x0a, 0x00,
+			0x00, 0x49, 0x3f, 0x00, 0x09, 0x00, 0x00, 0x44, 0x3f, 0x00, 0x09, 0x00, 0x00, 0x47, 0x3f, 0x00,
+			0x09, 0x00, 0x00, 0x4a, 0x3f, 0x00, 0x08, 0x00, 0x00, 0x44, 0x3f, 0x00, 0x07, 0x00, 0x00, 0x3e,
+			0x3f, 0x00, 0x08, 0x00, 0x00, 0x4a, 0x3f, 0x00, 0x07, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x07, 0x00,
+			0x00, 0x46, 0x3f, 0x00, 0x07, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x06, 0x00, 0x00, 0x41, 0x3f, 0x00,
+			0x06, 0x00, 0x00, 0x44, 0x3f, 0x00, 0x06, 0x00, 0x00, 0x47, 0x3f, 0x00, 0x06, 0x00, 0x00, 0x4a,
+			0x3f, 0x00, 0x06, 0x00, 0x00, 0x4d, 0x3f, 0x00, 0x05, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x05, 0x00,
+			0x00, 0x46, 0x3f, 0x00, 0x05, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x05, 0x00, 0x00, 0x4d, 0x3f, 0x00,
+			0x04, 0x00, 0x00, 0x41, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x46,
+			0x3f, 0x00, 0x04, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x4d, 0x3f, 0x00, 0x04, 0x00,
+			0x00, 0x4f, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x42, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x42, 0x3f, 0x00,
+			0x03, 0x00, 0x00, 0x45, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x4d,
+			0x3f, 0x00, 0x03, 0x00, 0x00, 0x50, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x50, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+			0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+			0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+			0x00, 0x43
+		};
+
+		unsigned char b4[] = {
+			0x00, 0x00, 0x00, 0x01,			// blocks
+
+			0x00, 0x00, 0x00, 0x0a,			// bytes 
+			0x00, 0x00, 0x00, 0x04,			// repeat
+//			0xff, 0xff, 0xff, 0xff,			// repeat
+//			0x3f, 0x00, 0x04,				// Level ????
+//			0x00, 0x00, 0x3c				// msec ????
+			0x3f, 0x20, 0x00,				//  "
+			0x00, 0x20, 0x00				// LED mask + clocks
+		};
+
+		printf("~1 send led sequence length %d\n",sizeof(b4));
+		if ((ev = i1pro2_indLEDseq(p, b4, sizeof(b4))) != I1PRO_OK)
+			return ev;
+	}
+#endif /* NEVER */
+
+/* ============================================================ */
+/* key/value dictionary support for EEProm contents */
+
+/* Search the linked list for the given key */
+/* Return NULL if not found */
+static i1keyv *i1data_find_key(i1data *d, i1key key) {
+	i1keyv *k;
+	
+	for (k = d->head; k != NULL; k = k->next) {
+		if (k->key == key)
+			return k;
+	}
+	return NULL;
+}
+
+/* Search the linked list for the given key and */
+/* return it, or add it to the list if it doesn't exist. */
+/* Return NULL on error */ 
+static i1keyv *i1data_make_key(i1data *d, i1key key) {
+	i1keyv *k;
+	
+	for (k = d->head; k != NULL; k = k->next)
+		if (k->key == key)
+			return k;
+
+	if ((k = (i1keyv *)calloc(1, sizeof(i1keyv))) == NULL) {
+		a1logw(d->log, "i1data: malloc failed!\n");
+		return NULL;
+	}
+
+	k->key = key;
+	k->next = NULL;
+	if (d->last == NULL) {
+		d->head = d->last = k;
+	} else {
+		d->last->next = k;
+		d->last = k;
+	}
+	return k;
+}
+
+/* Return type of data associated with key. Return i1_dtype_unknown if not found */
+static i1_dtype i1data_get_type(i1data *d, i1key key) {
+	i1keyv *k;
+
+	if ((k = d->find_key(d, key)) != NULL)
+		return k->type;
+	return i1_dtype_unknown;
+}
+
+/* Return the number of data items in a keyv. Return 0 if not found */
+static unsigned int i1data_get_count(i1data *d, i1key key) {
+	i1keyv *k;
+
+	if ((k = d->find_key(d, key)) != NULL)
+		return k->count;
+	return 0;
+}
+
+/* Return a pointer to the short data for the key. */
+/* Return NULL if not found or wrong type */
+static int *i1data_get_shorts(i1data *d, unsigned int *count, i1key key) {
+	i1keyv *k;
+
+	if ((k = d->find_key(d, key)) == NULL)
+		return NULL;
+
+	if (k->type != i1_dtype_short)
+		return NULL;
+
+	if (count != NULL)
+		*count = k->count;
+
+	return (int *)k->data;
+}
+
+/* Return a pointer to the int data for the key. */
+/* Return NULL if not found or wrong type */
+static int *i1data_get_ints(i1data *d, unsigned int *count, i1key key) {
+	i1keyv *k;
+
+	if ((k = d->find_key(d, key)) == NULL)
+		return NULL;
+
+	if (k->type != i1_dtype_int)
+		return NULL;
+
+	if (count != NULL)
+		*count = k->count;
+
+	return (int *)k->data;
+}
+
+/* Return a pointer to the double data for the key. */
+/* Return NULL if not found or wrong type */
+static double *i1data_get_doubles(i1data *d, unsigned int *count, i1key key) {
+	i1keyv *k;
+
+	if ((k = d->find_key(d, key)) == NULL)
+		return NULL;
+
+	if (k->type != i1_dtype_double)
+		return NULL;
+
+	if (count != NULL)
+		*count = k->count;
+
+	return (double *)k->data;
+}
+
+
+/* Return pointer to one of the int data for the key. */
+/* Return NULL if not found or wrong type or out of range index. */
+static int *i1data_get_int(i1data *d, i1key key, unsigned int index) {
+	i1keyv *k;
+
+	if ((k = d->find_key(d, key)) == NULL)
+		return NULL;
+
+	if (k->type != i1_dtype_int)
+		return NULL;
+
+	if (index >= k->count)
+		return NULL;
+
+	return ((int *)k->data) + index;
+}
+
+/* Return pointer to one of the double data for the key. */
+/* Return NULL if not found or wrong type or out of range index. */
+static double *i1data_get_double(i1data *d, i1key key, double *data, unsigned int index) {
+	i1keyv *k;
+
+	if ((k = d->find_key(d, key)) == NULL)
+		return NULL;
+
+	if (k->type != i1_dtype_double)
+		return NULL;
+
+	if (index >= k->count)
+		return NULL;
+
+	return ((double *)k->data) + index;
+}
+
+/* Un-serialize a char buffer into an i1key keyv */
+static i1pro_code i1data_unser_shorts(
+	i1data *d,
+	i1key key,
+	int addr,
+	unsigned char *buf,
+	unsigned int size
+) {
+	i1keyv *k;
+	int i, count;
+
+	count = size/2;
+
+	if (count == 0)
+		return I1PRO_DATA_COUNT;
+
+	if ((k = d->make_key(d, key)) == NULL)
+		return I1PRO_DATA_MAKE_KEY;
+
+	if (k->data != NULL)
+		free(k->data);
+
+	if ((k->data = (void *)malloc(sizeof(int) * count)) == NULL)
+		return I1PRO_DATA_MEMORY;
+
+	for (i = 0; i < count; i++, buf += 2) {
+		((int *)k->data)[i] = buf2short(buf);
+	}
+
+	k->count = count;
+	k->size = size;
+	k->type = i1_dtype_short;
+	if (addr != -1)
+		k->addr = addr;
+
+	return I1PRO_OK;
+}
+
+/* Un-serialize a char buffer into an i1key keyv */
+static i1pro_code i1data_unser_ints(
+	i1data *d,
+	i1key key,
+	int addr,
+	unsigned char *buf,
+	unsigned int size
+) {
+	i1keyv *k;
+	int i, count;
+
+	count = size/4;
+
+	if (count == 0)
+		return I1PRO_DATA_COUNT;
+
+	if ((k = d->make_key(d, key)) == NULL)
+		return I1PRO_DATA_MAKE_KEY;
+
+	if (k->data != NULL)
+		free(k->data);
+
+	if ((k->data = (void *)malloc(sizeof(int) * count)) == NULL)
+		return I1PRO_DATA_MEMORY;
+
+	for (i = 0; i < count; i++, buf += 4) {
+		((int *)k->data)[i] = buf2int(buf);
+	}
+
+	k->count = count;
+	k->size = size;
+	k->type = i1_dtype_int;
+	if (addr != -1)
+		k->addr = addr;
+
+	return I1PRO_OK;
+}
+
+/* Create an entry for an end of section marker */
+static i1pro_code i1data_add_eosmarker(
+	i1data *d,
+	i1key key,		/* section number */
+	int addr
+) {
+	i1keyv *k;
+
+	if ((k = d->make_key(d, key)) == NULL)
+		return I1PRO_DATA_MAKE_KEY;
+
+	if (k->data != NULL) {
+		free(k->data);
+		k->data = NULL;
+	}
+
+	k->count = 0;
+	k->size = 0;
+	k->type = i1_dtype_section;
+	if (addr != -1)
+		k->addr = addr;
+
+	return I1PRO_OK;
+}
+
+/* Un-serialize a char buffer of floats into a double keyv */
+static i1pro_code i1data_unser_doubles(
+	i1data *d,
+	i1key key,
+	int addr,
+	unsigned char *buf,
+	unsigned int size
+) {
+	i1keyv *k;
+	int i, count;
+
+	count = size/4;
+
+	if (count == 0)
+		return I1PRO_DATA_COUNT;
+
+	if ((k = d->make_key(d, key)) == NULL)
+		return I1PRO_DATA_MAKE_KEY;
+
+	if (k->data != NULL)
+		free(k->data);
+
+	if ((k->data = (void *)malloc(sizeof(double) * count)) == NULL)
+		return I1PRO_DATA_MEMORY;
+
+	for (i = 0; i < count; i++, buf += 4) {
+		int val;
+		val = buf2int(buf);
+		((double *)k->data)[i] = IEEE754todouble((unsigned int)val);
+	}
+
+	k->count = count;
+	k->size = size;
+	k->type = i1_dtype_double;
+	if (addr != -1)
+		k->addr = addr;
+
+	return I1PRO_OK;
+}
+
+
+/* Serialize an i1key keyv into a char buffer. Error if it is outside the buffer */
+static i1pro_code i1data_ser_ints(
+	i1data *d,
+	i1keyv *k,
+	unsigned char *buf,
+	unsigned int size
+) {
+	i1pro *p = d->p;
+	int i, len;
+
+	if (k->type != i1_dtype_int)
+		return I1PRO_DATA_WRONGTYPE;
+
+	len = k->count * 4;
+	if (len > k->size)
+		return I1PRO_DATA_BUFSIZE;
+
+	if (k->addr < 0 || k->addr >= size || (k->addr + k->size) > size)
+		return I1PRO_DATA_BUFSIZE;
+
+	buf += k->addr;
+	for (i = 0; i < k->count; i++, buf += 4) {
+		int2buf(buf, ((int *)k->data)[i]);
+	}
+
+	return I1PRO_OK;
+}
+
+/* Serialize a double keyv as floats into a char buffer. Error if the buf is not big enough */
+static i1pro_code i1data_ser_doubles(
+	i1data *d,
+	i1keyv *k,
+	unsigned char *buf,
+	unsigned int size
+) {
+	i1pro *p = d->p;
+	int i, len;
+
+	if (k->type != i1_dtype_double)
+		return I1PRO_DATA_WRONGTYPE;
+
+	len = k->count * 4;
+	if (len > k->size)
+		return I1PRO_DATA_BUFSIZE;
+
+	if (k->addr < 0 || k->addr >= size || (k->addr + k->size) > size)
+		return I1PRO_DATA_BUFSIZE;
+
+	buf += k->addr;
+	for (i = 0; i < k->count; i++, buf += 4) {
+		int2buf(buf, doubletoIEEE754(((double *)k->data)[i]));
+	}
+
+	return I1PRO_OK;
+}
+
+/* Copy an array full of ints to the key */ 
+/* Note the count must be the same as the existing key value, */
+/* since we are not prepared to re-allocate key/values within */
+/* the EEProm, or re-write the directory. */
+static i1pro_code i1data_add_ints(i1data *d, i1key key, int *data, unsigned int count) {
+	i1keyv *k;
+	int i;
+
+	if ((k = d->make_key(d, key)) == NULL)
+		return I1PRO_DATA_MAKE_KEY;
+
+	if (count != k->count)
+		return I1PRO_DATA_COUNT;
+
+	if (k->data != NULL)
+		free(k->data);
+
+	if ((k->data = (void *)malloc(sizeof(int) * count)) == NULL)
+		return I1PRO_DATA_MEMORY;
+
+	for (i = 0; i < count; i++) {
+		((int *)k->data)[i] = data[i];
+	}
+
+	k->count = count;
+	k->type = i1_dtype_int;
+
+	return I1PRO_OK;
+}
+
+/* Copy an array full of doubles to the key */ 
+/* Note the count must be the same as the existing key value, */
+/* since we are not prepared to re-allocate key/values within */
+/* the EEProm, or re-write the directory. */
+static i1pro_code i1data_add_doubles(i1data *d, i1key key, double *data, unsigned int count) {
+	i1keyv *k;
+	int i;
+
+	if ((k = d->make_key(d, key)) == NULL)
+		return I1PRO_DATA_MAKE_KEY;
+
+	if (count != k->count)
+		return I1PRO_DATA_COUNT;
+
+	if (k->data != NULL)
+		free(k->data);
+
+	if ((k->data = (void *)malloc(sizeof(double) * count)) == NULL)
+		return I1PRO_DATA_MEMORY;
+
+	for (i = 0; i < count; i++) {
+		((double *)k->data)[i] = data[i];
+	}
+
+	k->count = count;
+	k->type = i1_dtype_double;
+
+	return I1PRO_OK;
+}
+
+/* Initialise the data from the EEProm contents */
+static i1pro_code i1data_parse_eeprom(i1data *d, unsigned char *buf, unsigned int len, int extra) {
+	i1pro *p = d->p;
+	int rv = I1PRO_OK;
+	int dir = 0x1000;		/* Location of key directory */
+	int block_id;			/* Block id */
+	int nokeys;
+	i1key key, off, nkey = 0, noff = 0;
+	int size;				/* size of key in bytes */
+	unsigned char *bp;
+	int i;
+
+	if (extra) 
+		dir = 0x2000;	/* Directory is at half way in i1pro2 2nd table */
+
+	a1logd(p->log,3,"i1pro_parse_eeprom called with %d bytes\n",len);
+
+	/* Room for minimum number of keys ? */
+	if ((dir + 300) > len)
+		return I1PRO_DATA_KEY_COUNT;
+
+	block_id = buf2ushort(buf + dir);
+	if ((extra == 0 && block_id != 1)	/* Must be 1 for base data */
+	 || (extra == 1 && block_id != 2))	/* Must be 2 for i1pro2 extra data*/
+		return I1PRO_DATA_KEY_CORRUPT;
+	
+	nokeys = buf2ushort(buf + dir + 2);	/* Bytes in key table */
+	if (nokeys < 300 || nokeys > 512)
+		return I1PRO_DATA_KEY_COUNT;
+
+	nokeys = (nokeys - 4)/6;				/* Number of 6 byte entries */
+
+	a1logd(p->log,3,"%d key/values in EEProm table %d\n",nokeys, extra);
+
+	/* We need current and next value to figure data size out */
+	bp = buf + dir + 4;
+	key = buf2ushort(bp);
+	off = buf2int(bp+2);
+	bp += 6;
+	for (i = 0; i < nokeys; i++, bp += 6, key = nkey, off = noff) {
+		i1_dtype type;
+		
+		if (i < (nokeys-1)) {
+			nkey = buf2ushort(bp);
+			noff = buf2int(bp+2);
+		}
+		size = noff - off;
+		if (size < 0)
+			size = 0;
+		type = d->det_type(d, key);
+
+		a1logd(p->log,3,"Table entry %d is Key 0x%04x, type %d addr 0x%x, size %d\n",
+			                                                   i,key,type,off,size);
+
+		/* Check data is within range */
+		if (off >= len || noff < off || noff > len) {
+			a1logd(p->log,3,"Key 0x%04x offset %d and length %d out of range\n",key,off,noff);
+			return I1PRO_DATA_KEY_MEMRANGE;
+		}
+
+		if (type == i1_dtype_unknown) {
+			if (d->log->debug >= 7) {
+				int i;
+				char oline[100], *bp = oline;
+				bp = oline;
+				a1logd(d->log,7,"Key 0x%04x is unknown type\n",key);
+				for (i = 0; i < size; i++) {
+					if ((i % 16) == 0)
+						bp += sprintf(bp,"    %04x:",i);
+					bp += sprintf(bp," %02x",buf[off + i]);
+					if ((i+1) >= size || ((i+1) % 16) == 0) {
+						bp += sprintf(bp,"\n");
+						a1logd(p->log,7,oline);
+						bp = oline;
+					}
+				}
+			}
+			if (type == i1_dtype_unknown)
+				continue;				/* Ignore it */
+		}
+		if (type == i1_dtype_section) {
+			if ((rv = i1data_add_eosmarker(d, key, off)) != I1PRO_OK) {
+				a1logd(p->log,3,"Key 0x%04x section marker failed with 0x%x\n",key,rv);
+				return rv;
+			}
+			continue;
+		}
+		if (i >= nokeys) {
+			a1logd(p->log,3,"Last key wasn't a section marker!\n");
+			return I1PRO_DATA_KEY_ENDMARK;
+		}
+		if (type == i1_dtype_short) {
+			if ((rv = i1data_unser_shorts(d, key, off, buf + off, size)) != I1PRO_OK) {
+				a1logd(p->log,3,"Key 0x%04x short unserialise failed with 0x%x\n",key,rv);
+				return rv;
+			}
+		} else if (type == i1_dtype_int) {
+			if ((rv = i1data_unser_ints(d, key, off, buf + off, size)) != I1PRO_OK) {
+				a1logd(p->log,3,"Key 0x%04x int unserialise failed with 0x%x\n",key,rv);
+				return rv;
+			}
+		} else if (type == i1_dtype_double) {
+			if ((rv = i1data_unser_doubles(d, key, off, buf + off, size)) != I1PRO_OK) {
+				a1logd(p->log,3,"Key 0x%04x double unserialise failed with 0x%x\n",key,rv);
+				return rv;
+			} 
+		} else {
+			a1logd(p->log,3,"Key 0x%04x has type we can't handle!\n",key);
+		}
+	}
+
+	return I1PRO_OK;
+}
+
+/* Compute and set the checksum, then serialise all the keys up */
+/* to the first marker into a buffer, ready for writing back to */
+/* the EEProm. It is an error if this buffer is not located at */
+/* zero in the EEProm */
+static i1pro_code i1data_prep_section1(
+i1data *d,
+unsigned char **buf,		/* return allocated buffer */
+unsigned int *len
+) {
+	i1pro *p = d->p;
+	i1proimp *m = d->m;
+	int chsum1, *chsum2;
+	i1keyv *k, *sk, *j;
+	i1pro_code ev = I1PRO_OK;
+
+	a1logd(p->log,5,"i1data_prep_section1 called\n");
+
+	/* Compute the checksum for the first copy of the log data */
+	chsum1 = m->data->checksum(m->data, 0);
+
+	/* Locate and then set the checksum */
+	if ((chsum2 = m->data->get_int(m->data, key_checksum, 0)) == NULL) {
+		a1logd(p->log,2,"i1data_prep_section1 failed to locate checksum\n");
+		return I1PRO_INT_PREP_LOG_DATA;
+	}
+	*chsum2 = chsum1;
+
+	/* Locate the first section marker */
+	for (sk = d->head; sk != NULL; sk = sk->next) {
+		if (sk->type == i1_dtype_section)
+			break;
+	}
+	if (sk == NULL) {
+		a1logd(p->log,2,"i1data_prep_section1 failed to find section marker\n");
+		return I1PRO_INT_PREP_LOG_DATA;
+	}
+
+	/* for each key up to the first section marker */
+	/* check it resides within that section, and doesn't */
+	/* overlap any other key. */
+	for (k = d->head; k != NULL; k = k->next) {
+		if (k->type == i1_dtype_section)
+			break;
+		if (k->addr < 0 || k->addr >= sk->addr || (k->addr + k->size) > sk->addr) {
+			a1logd(p->log,2,"i1data_prep_section1 found key outside section\n");
+			return I1PRO_INT_PREP_LOG_DATA;
+		}
+		for (j = k->next; j != NULL; j = j->next) {
+			if (j->type == i1_dtype_section)
+				break;
+			if ((j->addr >= k->addr && j->addr < (k->addr + k->size))
+			 || ((j->addr + j->size) > k->addr && (j->addr + j->size) <= (k->addr + k->size))) {
+				a1logd(p->log,2,"i1data_prep_section1 found key overlap section, 0x%x %d and 0x%x %d\n",
+				k->addr, k->size, j->addr, j->size);
+				return I1PRO_INT_PREP_LOG_DATA;
+			}
+		}
+	}
+
+	/* Allocate the buffer for the data */
+	*len = sk->addr;
+	if ((*buf = (unsigned char *)calloc(sk->addr, sizeof(unsigned char))) == NULL) {
+		a1logw(p->log, "i1data: malloc failed!\n");
+		return I1PRO_INT_MALLOC;
+	}
+
+	/* Serialise it into the buffer */
+	for (k = d->head; k != NULL; k = k->next) {
+		if (k->type == i1_dtype_section)
+			break;
+		else if (k->type == i1_dtype_int) {
+			if ((ev = m->data->ser_ints(m->data, k, *buf, *len)) != I1PRO_OK) {
+				a1logd(p->log,2,"i1data_prep_section1 serializing ints failed\n");
+				return ev;
+			}
+		} else if (k->type == i1_dtype_double) {
+			if ((ev = m->data->ser_doubles(m->data, k, *buf, *len)) != I1PRO_OK) {
+				a1logd(p->log,2,"i1data_prep_section1 serializing doubles failed\n");
+				return ev;
+			}
+		} else {
+			a1logd(p->log,2,"i1data_prep_section1 tried to serialise unknown type\n");
+			return I1PRO_INT_PREP_LOG_DATA;
+		}
+	}
+	a1logd(p->log,5,"a_prep_section1 done\n");
+	return ev;
+}
+
+
+/* Return the data type for the given key identifier */
+static i1_dtype i1data_det_type(i1data *d, i1key key) {
+
+	if (key < 0x100)
+		return i1_dtype_section;
+
+	switch(key) {
+		/* Log keys */
+		case key_meascount:
+		case key_meascount + 1000:
+			return i1_dtype_int;
+		case key_darkreading:
+		case key_darkreading + 1000:
+			return i1_dtype_int;
+		case key_whitereading:
+		case key_whitereading + 1000:
+			return i1_dtype_int;
+		case key_gainmode:
+		case key_gainmode + 1000:
+			return i1_dtype_int;
+		case key_inttime:
+		case key_inttime + 1000:
+			return i1_dtype_double;
+		case key_caldate:
+		case key_caldate + 1000:
+			return i1_dtype_int;
+		case key_calcount:
+		case key_calcount + 1000:
+			return i1_dtype_int;
+		case key_checksum:
+		case key_checksum + 1000:
+			return i1_dtype_int;
+		case key_rpinttime:
+		case key_rpinttime + 1000:
+			return i1_dtype_double;
+		case key_rpcount:
+		case key_rpcount + 1000:
+			return i1_dtype_int;
+		case key_acount:
+		case key_acount + 1000:
+			return i1_dtype_int;
+		case key_lampage:
+		case key_lampage + 1000:
+			return i1_dtype_double;
+
+
+		/* Intstrument calibration keys */
+		case key_ng_lin:
+			return i1_dtype_double;
+		case key_hg_lin:
+			return i1_dtype_double;
+		case key_min_int_time:
+			return i1_dtype_double;
+		case key_max_int_time:
+			return i1_dtype_double;
+		case key_mtx_index:
+			return i1_dtype_int;
+		case key_mtx_nocoef:
+			return i1_dtype_int;
+		case key_mtx_coef:
+			return i1_dtype_double;
+		case key_0bb9:
+			return i1_dtype_int;
+		case key_0bba:
+			return i1_dtype_int;
+		case key_white_ref:
+			return i1_dtype_double;
+		case key_emis_coef:
+			return i1_dtype_double;
+		case key_amb_coef:
+			return i1_dtype_double;
+		case key_0fa0:
+			return i1_dtype_int;
+		case key_0bbf:
+			return i1_dtype_int;
+		case key_cpldrev:
+			return i1_dtype_int;
+		case key_0bc1:
+			return i1_dtype_int;
+		case key_capabilities:
+			return i1_dtype_int;
+		case key_0bc3:
+			return i1_dtype_int;
+		case key_physfilt:
+			return i1_dtype_int;
+		case key_0bc5:
+			return i1_dtype_int;
+		case key_0bc6:
+			return i1_dtype_double;
+		case key_sens_target:
+			return i1_dtype_int;
+		case key_sens_dark:
+			return i1_dtype_int;
+		case key_ng_sens_sat:
+			return i1_dtype_int;
+		case key_hg_sens_sat:
+			return i1_dtype_int;
+		case key_serno:
+			return i1_dtype_int;
+		case key_dom:
+			return i1_dtype_int;
+		case key_hg_factor:
+			return i1_dtype_double;
+		default:
+			return i1_dtype_unknown;
+
+		/* i1pro2 keys */
+		case 0x2ee0:
+			return i1_dtype_unknown;	// ~~
+		case 0x2ee1:
+			return i1_dtype_char;
+		case 0x2ee2:
+			return i1_dtype_int;
+		case 0x2ee3:
+			return i1_dtype_int;
+		case 0x2ee4:
+			return i1_dtype_unknown;	// ~~
+
+		case 0x2eea:
+			return i1_dtype_int;
+		case 0x2eeb:
+			return i1_dtype_int;
+		case 0x2eec:
+			return i1_dtype_int;
+
+		case 0x2ef4:
+			return i1_dtype_double;
+		case 0x2ef5:
+			return i1_dtype_double;
+		case 0x2ef6:
+			return i1_dtype_double;
+		case 0x2ef9:
+			return i1_dtype_double;
+		case 0x2efa:
+			return i1_dtype_double;
+		case 0x2efe:
+			return i1_dtype_int;
+		case 0x2eff:
+			return i1_dtype_int;
+	
+		case 0x2f08:
+			return i1_dtype_double;
+		case 0x2f09:
+			return i1_dtype_double;
+		case 0x2f12:
+			return i1_dtype_double;
+		case 0x2f13:
+			return i1_dtype_double;
+		case 0x2f14:
+			return i1_dtype_double;
+		case 0x2f15:
+			return i1_dtype_double;
+
+		case 0x2f44:					/* Wavelength LED reference shape ? */
+			return i1_dtype_double;
+		case 0x2f45:
+			return i1_dtype_int;
+		case 0x2f46:
+			return i1_dtype_double;
+		case 0x2f4e:
+			return i1_dtype_double;
+		case 0x2f4f:
+			return i1_dtype_double;
+		case 0x2f50:
+			return i1_dtype_double;
+		case 0x2f58:
+			return i1_dtype_short;		/* Stray light compensation table */
+		case 0x2f59:
+			return i1_dtype_double;		/* Stray light scale factor ? */
+		case 0x2f62:
+			return i1_dtype_double;
+		case 0x2f63:
+			return i1_dtype_double;
+		case 0x2f6c:
+			return i1_dtype_double;
+		case 0x2f6d:
+			return i1_dtype_double;
+		case 0x2f6e:
+			return i1_dtype_double;
+		case 0x2f76:
+			return i1_dtype_double;
+		case 0x2f77:
+			return i1_dtype_double;
+	
+		case 0x32c8:
+			return i1_dtype_int;		// Date
+		case 0x32c9:
+			return i1_dtype_int;		// Date
+		case 0x32ca:
+			return i1_dtype_unknown;    // ~~
+		
+		case 0x36b0:
+			return i1_dtype_int;		// Date
+		case 0x36b1:
+			return i1_dtype_int;		// Date
+		case 0x36b2:
+			return i1_dtype_unknown;    // ~~
+		
+		case 0x3a99:
+			return i1_dtype_unknown;    // ~~
+		case 0x3a9a:
+			return i1_dtype_unknown;    // ~~
+		case 0x3a9b:
+			return i1_dtype_unknown;    // ~~
+		case 0x3a9c:
+			return i1_dtype_unknown;    // ~~
+		case 0x3a9d:
+			return i1_dtype_unknown;    // ~~
+
+		case 0x3e81:
+			return i1_dtype_char;		// "X-Rite"
+		case 0x3e82:
+			return i1_dtype_unknown;    // ~~
+		case 0x3e8a:
+			return i1_dtype_unknown;    // ~~
+
+		case 0x3e94:
+			return i1_dtype_unknown;    // ~~
+	
+	}
+	return i1_dtype_unknown;
+}
+
+/* Given an index starting at 0, return the matching key code */
+/* for keys that get checksummed. Return 0 if outside range. */
+static i1key i1data_chsum_keys(
+	i1data *d,
+	int index
+) {
+	switch(index) {
+		case 0:
+			return key_meascount;
+		case 1:
+			return key_darkreading;
+		case 2:
+			return key_whitereading;
+		case 3:
+			return key_gainmode;
+		case 4:
+			return key_inttime;
+		case 5:
+			return key_caldate;
+		case 6:
+			return key_calcount;
+		case 7:
+			return key_rpinttime;
+		case 8:
+			return key_rpcount;
+		case 9:
+			return key_acount;
+		case 10:
+			return key_lampage;
+	}
+	return 0;
+}
+
+/* Compute a checksum. */
+static int i1data_checksum(
+	i1data *d,
+	i1key keyoffset 	/* Offset to apply to keys */
+) {
+	int i, n, j;
+	int chsum = 0;
+
+	for (i = 0; ; i++) {
+		i1key key;
+		i1keyv *k;
+
+		if ((key = d->chsum_keys(d, i)) == 0)
+			break;			/* we're done */
+	
+		key += keyoffset;
+
+		if ((k = d->find_key(d, key)) == NULL)
+			continue;		/* Hmm */
+
+		if (k->type == i1_dtype_int) {
+			for (j = 0; j < k->count; j++)
+				chsum += ((int *)k->data)[j];	
+		} else if (k->type == i1_dtype_double) {
+			for (j = 0; j < k->count; j++)
+				chsum += doubletoIEEE754(((double *)k->data)[j]);
+		}
+	}
+
+	return chsum;
+}
+
+/* Destroy ourselves */
+static void i1data_del(i1data *d) {
+	i1keyv *k, *nk;
+	
+	del_a1log(d->log);		/* Unref it */
+
+	/* Free all the keys and their data */
+	for (k = d->head; k != NULL; k = nk) {
+		nk = k->next;
+		if (k->data != NULL)
+			free(k->data);
+		free(k);
+	}
+	free(d);
+}
+
+/* Constructor for i1data */
+i1data *new_i1data(i1proimp *m) {
+	i1data *d;
+	if ((d = (i1data *)calloc(1, sizeof(i1data))) == NULL) {
+		a1loge(m->p->log, 1, "new_i1data: malloc failed!\n");
+		return NULL;
+	}
+
+	d->p = m->p;
+	d->m = m;
+
+	d->log = new_a1log_d(m->p->log);	/* Take reference */
+
+	d->find_key      = i1data_find_key;
+	d->make_key      = i1data_make_key;
+	d->get_type      = i1data_get_type;
+	d->get_count     = i1data_get_count;
+	d->get_shorts    = i1data_get_shorts;
+	d->get_ints      = i1data_get_ints;
+	d->get_doubles   = i1data_get_doubles;
+	d->get_int       = i1data_get_int;
+	d->get_double    = i1data_get_double;
+	d->unser_ints    = i1data_unser_ints;
+	d->unser_doubles = i1data_unser_doubles;
+	d->ser_ints      = i1data_ser_ints;
+	d->ser_doubles   = i1data_ser_doubles;
+	d->parse_eeprom  = i1data_parse_eeprom;
+	d->prep_section1 = i1data_prep_section1;
+	d->add_ints      = i1data_add_ints;
+	d->add_doubles   = i1data_add_doubles;
+	d->del           = i1data_del;
+
+	d->det_type      = i1data_det_type;
+	d->chsum_keys    = i1data_chsum_keys;
+	d->checksum      = i1data_checksum;
+
+	return d;
+}
+
+/* ----------------------------------------------------------------- */