From f6b8e0eae4374f339487a33e3e4fe5462d5816e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Sat, 25 Nov 2017 10:16:00 +0100 Subject: New upstream version 2.0.0 --- spectro/vtpglut.c | 570 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 570 insertions(+) create mode 100755 spectro/vtpglut.c (limited to 'spectro/vtpglut.c') diff --git a/spectro/vtpglut.c b/spectro/vtpglut.c new file mode 100755 index 0000000..2308466 --- /dev/null +++ b/spectro/vtpglut.c @@ -0,0 +1,570 @@ + +/* Abstract Video Test Patch Generator and/or 3dLUT class implemenation */ + +/* + * Argyll Color Correction System + * + * Author: Graeme W. Gill + * Date: 10/3/2001 + * + * Copyright 2001 - 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. + */ + +#include +#include +#include +#include +#include +#include +#ifndef SALONEINSTLIB +#include "copyright.h" +#include "aconfig.h" +#else +#include "sa_config.h" +#endif /* !SALONEINSTLIB */ +#include "numsup.h" +#include "cgats.h" +#include "xspect.h" +#include "conv.h" + +#include "insttypes.h" +#include "icoms.h" +#include "vtpglut.h" +#include "rspec.h" +#include "vtpgluttypes.h" +#include "sort.h" + +icom_type dev_category(instType itype); + +/* --------------------------------------------------------- */ + +#if defined(ENABLE_FAST_SERIAL) +extern devType fast_ser_dev_type(icoms *p, int tryhard, + inst_code (*uicallback)(void *cntx, inst_ui_purp purp), void *cntx); +# if defined(ENABLE_SERIAL) +static devType ser_vtpglut_type(icoms *p, + vtpglut_code (*uicallback)(void *cntx, vtpglut_ui_purp purp), void *cntx); + +/* Translate vtpglut uicallback into inst callback */ +typedef struct { + void *cntx; + vtpglut_code (*uicallback)(void *cntx, vtpglut_ui_purp purp); +} vtpglut_callback_cntx; + +static inst_code ser_uicallback(void *cntx, inst_ui_purp purp) { + vtpglut_callback_cntx *p = (vtpglut_callback_cntx *)cntx; + vtpglut_ui_purp ser_purp; + + if (purp == vtpglut_negcoms) + ser_purp = inst_negcoms; + else + return inst_internal_error; + return p->uicallback(p->cntx, ser_purp); +} + +# endif /* ENABLE_SERIAL */ +#endif /* ENABLE_FAST_SERIAL */ + + +/* ------------------------------------ */ +/* Default methods for instrument class */ + +/* Establish communications at the indicated baud rate. */ +/* Timout in to seconds, and return non-zero error code */ +static vtpglut_code init_coms( +vtpglut *p) { /* Timeout */ + return vtpglut_unsupported; +} + +/* Initialise or re-initialise the INST */ +/* return non-zero on an error, with inst error code */ +static vtpglut_code init_vtpglut( +vtpglut *p) { + return vtpglut_unsupported; +} + +/* Return the device type */ +static devType get_dtype(vtpglut *p) { + if (p != NULL) + return p->dtype; + return devUnknown; +} + +/* Return the device serial number. */ +/* (This will be an empty string if there is no serial no) */ +static char *get_serial_no(vtpglut *p) { + return ""; +} + +/* Return the device mode/capabilities */ +static void capabilities(vtpglut *p, vtpglut_mode *cap1, + vtpglut_capability *cap2) { + if (cap1 != NULL) + *cap1 = vtpglut_mode_none; + if (cap2 != NULL) + *cap2 = vtpglut2_none; +} + +/* Check the device mode */ +static vtpglut_code check_mode( +vtpglut *p, +vtpglut_mode m) { /* Requested mode */ + return vtpglut_unsupported; +} + +/* Set the device mode */ +static vtpglut_code set_mode( +vtpglut *p, +vtpglut_mode m) { /* Requested mode */ + return vtpglut_unsupported; +} + +/* Get a status or set or get an option (default implementation) */ +vtpglut_code vtpglut_get_set_opt_def( +vtpglut *p, +vtpglut_opt_type m, /* Requested option type */ +va_list args) { /* Option parameters */ + return vtpglut_unsupported; +} + +/* Get a status or set or get an option */ +static vtpglut_code get_set_opt( +vtpglut *p, +vtpglut_opt_type m, /* Requested status type */ +...) { /* Status parameters */ + vtpglut_code rv; + va_list args; + + va_start(args, m); + rv = vtpglut_get_set_opt_def(p, m, args); /* Call the above */ + va_end(args); + + return rv; +} + +/* Supply a user interaction callback function. */ +static void set_uicallback( +vtpglut *pp, +vtpglut_code (*uicallback)(void *cntx, vtpglut_ui_purp purp), +void *cntx) { + pp->uicallback = uicallback; + pp->uic_cntx = cntx; +} + +/* Supply an asynchronous event callback function. */ +static void set_event_callback( +vtpglut *pp, +void (*eventcallback)(void *cntx, vtpglut_event_type event), +void *cntx) { + pp->eventcallback = eventcallback; + pp->event_cntx = cntx; +} + +/* Generic inst error codes interpretation */ +static char *vtpglut_interp_error(vtpglut *p, vtpglut_code ec) { + switch(ec & vtpglut_mask) { + case vtpglut_ok: + return "No error"; + case vtpglut_notify: + return "Notification"; + case vtpglut_warning: + return "Warning"; + case vtpglut_no_coms: + return "Internal error - communications needed but not established"; + case vtpglut_no_init: + return "Internal error - initialisation needed but not done"; + case vtpglut_unsupported: + return "Unsupported function"; + case vtpglut_internal_error: + return "Internal software error"; + case vtpglut_coms_fail: + return "Communications failure"; + case vtpglut_unknown_model: + return "Not expected device model"; + case vtpglut_protocol_error: + return "Communication protocol breakdown"; + case vtpglut_user_abort: + return "User hit Abort Key"; + case vtpglut_user_trig: + return "User hit Trigger Key"; + case vtpglut_unexpected_reply: + return "Unexpected Reply"; + case vtpglut_wrong_setup: + return "Wrong or conflicting setup"; + case vtpglut_hardware_fail: + return "Hardware Failure"; + case vtpglut_system_error: + return "Operating System Error"; + case vtpglut_bad_parameter: + return "Bad Parameter Value"; + case vtpglut_other_error: + return "Non-specific error"; + } + return "Unknown inst error code"; +} + +/* Instrument specific error codes interpretation */ +static char *interp_error(vtpglut *p, int ec) { + return "interp_error is uninplemented in base class!"; +} + +/* Return the last serial communication error code */ +/* (This is used for deciding fallback/retry strategies) */ +static int last_scomerr(vtpglut *p) { + return p->icom->lserr; +} + +/* ---------------------------------------------- */ + +/* Delete things set/done by new_vtpglut() */ +static vtpglut_code virtual_del(vtpglut *p) { + +#if defined(UNIX_APPLE) + osx_latencycritical_end(); +#endif + + return vtpglut_ok; +} + + +/* Virtual constructor. */ +/* Return NULL for unknown instrument, */ +/* or serial instrument if nocoms == 0. */ +extern vtpglut *new_vtpglut( +icompath *path, /* Device path to instrument */ +int nocoms, /* Don't open if communications are needed to establish inst type */ +a1log *log, /* log to use */ +vtpglut_code (*uicallback)(void *cntx, vtpglut_ui_purp purp), /* optional uicallback for abort */ +void *cntx /* Context for callback */ +) { + devType itype = devUnknown; /* Actual type */ + icoms *icom; + vtpglut *p = NULL; + + if (path == NULL) { + a1logd(log, 2, "new_vtpglut: got NULL path\n"); + return NULL; + } + + a1logd(log, 2, "new_vtpglut: called with path '%s' type '%s'\n",path->name,inst_sname(path->itype)); + + if ((icom = new_icoms(path, log)) == NULL) { + a1logd(log, 2, "new_vtpglut: new_icoms failed to open it\n"); + return NULL; + } + + + + /* Set device type from USB port, if not specified */ + itype = icom->itype; /* Instrument type if its known from usb/hid */ + +#if defined(ENABLE_FAST_SERIAL) + if (itype == instUnknown && !nocoms && (icom->dctype & icomt_fastserial)) { + vtpglut_callback_cntx wcntx; + + /* Wrap vtpglut callback in inst callback */ + wcntx.cntx = cntx; + wcntx.uicallback = uicallback; + + itype = fast_ser_dev_type(icom, 1, ser_uicallback, &wcntx); /* Else type from serial */ + icom->dctype = (icom->dctype & ~icomt_cat_mask) | dev_category(itype); + a1logd(log, 8, "new_vtpglut: fast set '%s' dctype 0x%x\n",icom->name,icom->dctype); + } +#endif /* ENABLE_FAST_SERIAL */ + +#if defined(ENABLE_SERIAL) + if (itype == instUnknown && !nocoms) { + itype = ser_vtpglut_type(icom, uicallback, cntx); /* Else type from serial */ + icom->dctype = (icom->dctype & ~icomt_cat_mask) | dev_category(itype); + a1logd(log, 8, "new_vtpglut: set '%s' dctype 0x%x\n",icom->name,icom->dctype); + } +#endif /* ENABLE_SERIAL */ + + +#ifdef ENABLE_SERIAL +// if (itype == devRadiance) +// p = (vtpglut *)new_radiance(icom, itype); +#endif /* ENABLE_SERIAL */ + +#ifdef ENABLE_USB +// if (itype == instXXXX) +// p = (vtpglut *)new_XXXX(icom, itype); +#endif /* ENABLE_USB */ + + + /* Nothing matched */ + if (p == NULL) { + a1logd(log, 2, "new_vtpglut: device type not recognised\n"); + icom->del(icom); + return NULL; + } + + p->vdel = virtual_del; + + /* Add default methods if constructor did not supply them */ + if (p->init_coms == NULL) + p->init_coms = init_coms; + if (p->init_vtpglut == NULL) + p->init_vtpglut = init_vtpglut; + if (p->get_dtype == NULL) + p->get_dtype = get_dtype; + if (p->get_serial_no == NULL) + p->get_serial_no = get_serial_no; + if (p->capabilities == NULL) + p->capabilities = capabilities; + if (p->check_mode == NULL) + p->check_mode = check_mode; + if (p->set_mode == NULL) + p->set_mode = set_mode; + if (p->get_set_opt == NULL) + p->get_set_opt = get_set_opt; + if (p->set_uicallback == NULL) + p->set_uicallback = set_uicallback; + if (p->set_event_callback == NULL) + p->set_event_callback = set_event_callback; + if (p->vtpglut_interp_error == NULL) + p->vtpglut_interp_error = vtpglut_interp_error; + if (p->interp_error == NULL) + p->interp_error = interp_error; + if (p->last_scomerr == NULL) + p->last_scomerr = last_scomerr; + + /* Set the provided user interaction callback */ + p->set_uicallback(p, uicallback, cntx); + +#if defined(UNIX_APPLE) + osx_latencycritical_start(); +#endif + + return p; +} + +/* ============================================================= */ +/* Detect serial device */ + +#ifdef ENABLE_SERIAL +static void hex2bin(char *buf, int len); + +/* Heuristicly determine the device type for */ +/* a serial connection, and devUnknown if not serial. */ +/* Set it in icoms and also return it. */ +static devType ser_vtpglut_type( + icoms *p, + vtpglut_code (*uicallback)(void *cntx, vtpglut_ui_purp purp), /* optional uicallback */ + void *cntx /* Context for callback */ +) { + devType rv = instUnknown; +#define BUFSZ (128 + 10) + char buf[BUFSZ]; + baud_rate brt[] = { baud_9600, baud_57600, baud_115200, baud_230400, baud_nc }; + unsigned int etime; + unsigned int bi, i; + int se, len, bread; + int lumagen = 0, lgchsum = 0; + +#ifdef ENABLE_USB + if (p->usbd != NULL || p->hidd != NULL) + return p->itype; +#endif /* ENABLE_USB */ + + bi = 0; + + /* The tick to give up on */ + etime = msec_time() + (long)(20.0 * 1000.0 + 0.5); + + a1logd(p->log, 1, "ser_vtpglut_type: Trying different baud rates (%u msec to go)\n",etime - msec_time()); + + /* Until we time out, find the correct baud rate */ + for (i = bi; msec_time() < etime; i++) { + lgchsum = 0; + + if (brt[i] == baud_nc) + i = 0; + if ((se = p->set_ser_port(p, fc_None, brt[i], parity_none, + stop_1, length_8)) != ICOM_OK) { + a1logd(p->log, 5, "ser_vtpglut_type: set_ser_port failed with 0x%x\n",se); + return instUnknown; /* Give up */ + } + + a1logd(p->log, 5, "Trying %s baud\n",baud_rate_to_str(brt[i])); + bread = 0; + + /* If Lumagen baud rate */ + if (brt[i] == baud_9600 + || brt[i] == baud_57600 + || brt[i] == baud_115200 + || brt[i] == baud_230400) { + + /* Try a spectrolino/spectroscan command first, so as not to upset it, */ + /* but do first character only and see if there is an echo */ + p->write_read_ex(p, ";", 1, buf, BUFSZ-1, &bread, "\r", 1, 0.2, 1); + if (bread == 1 && buf[0] == ';') + goto check_lumagen; /* It may be a Lumagen, so skip it. */ + + /* Send the rest of the spectrolino command */ + p->write_read_ex(p, "D024\r\n", 0, buf, BUFSZ-1, &bread, "\r", 1, 0.5, 1); + + + if (bread == 0) { + char *bp; + a1logd(p->log, 5, "ser_vtpglut_type: Spectrolino command returned nothing\n"); + + /* It could be a Lumagen Radiance with echo off, */ + /* so poke it and see if it responds. */ + /* (Unfortunately the Lumagen delimeters modes aren't */ + /* backwards compatible, so we may have to poke it twice...) */ + + /* Send "X" first, to get it out of menu mode ? */ + p->write_read_ex(p, "X", 1, buf, BUFSZ, NULL, "\n", 1, 0.1, 1); // Menu off + + a1logd(p->log, 5, "ser_vtpglut_type: Checking for Lumagen Radiance\n"); + p->write_read_ex(p, "#ZQS00\r", 0, buf, BUFSZ, &bread, "\n", 1, 0.5, 1); + if (bread == 0) { + p->write_read_ex(p, "#0ZQS008E\r", 0, buf, BUFSZ, &bread, "\n", 1, 0.5, 1); + lgchsum = 1; + } + + if (bread > 0 + && (bp = strrchr(buf, '!')) != NULL + && strlen(bp) >= 4 + && strncmp(bp,"!S00",4) == 0) { + goto check_lumagen; + } + + /* Nope - look for something at a different baud rate */ + goto continue_looking; + } + buf[bread] = '\000'; + len = strlen(buf); + + /* Is this a Lumagen Radiance with echo on, it responds with ";D024..." */ + if ((len >= 4 && strncmp(buf, ";D024", 4) == 0) + || (len >= 4 && strncmp(buf, "!N\n\r", 4) == 0)) { + char *bp; + + check_lumagen:; + + /* Get the Lumagen device information */ + p->write_read_ex(p, lgchsum ? "#0ZQS018F\r" : "#ZQS01\r", + 0, buf, BUFSZ, &bread, "\n", 1, 0.5, 1); + + /* Might have echo with checksum, so lgchsum not set correctly */ + if (!lgchsum && bread > 0 && strstr(buf, "!N") != NULL) { + p->write_read_ex(p, "#0ZQS018F\r", 0, buf, BUFSZ, &bread, "\n", 1, 0.5, 1); + if (bread >= 11 && strncmp(buf, "#0ZQS018F!Y", 11) == 0) + lgchsum = 1; + } + + /* returns something like "ZQS01!S01,Radiance2020,030115,1016,001309\r\m" */ + if ((bp = strrchr(buf, '!')) != NULL && strlen(bp) >= 13) { + if (strncmp(bp,"!S01,Radiance",13) == 0) { + a1logd(p->log, 5, "ser_vtpglut_type: Found Lumagen Radiance\n"); + lumagen = 1; + break; + } + } + a1logd(p->log, 5, "ser_vtpglut_type: Not Lumagen Radiance\n"); + goto continue_looking; + } + } /* Possibly Lumagen */ + + continue_looking:; + + /* Check for user abort */ + if (uicallback != NULL) { + vtpglut_code ev; + if ((ev = uicallback(cntx, vtpglut_negcoms)) == vtpglut_user_abort) { + a1logd(p->log, 5, "ser_vtpglut_type: User aborted\n"); + return instUnknown; + } + } + } /* next baud */ + + if (rv == instUnknown + && lumagen == 0 + && msec_time() >= etime) { /* We haven't established comms */ + a1logd(p->log, 5, "ser_vtpglut_type: Failed to establish coms\n"); + return instUnknown; + } + + a1logd(p->log, 5, "ser_vtpglut_type: Got coms with device\n"); + + if (lumagen) { + char *bp; + + /* Get the Lumagen device information */ + if ((se = p->write_read_ex(p, "ZQS01", 0, buf, BUFSZ, NULL, "\n", 1, 2.5, 1)) != 0) + return instUnknown; + + /* returns something like "ZQS01!S01,Radiance2020,030115,1016,001309\r\m" */ + if ((bp = strstr(buf, "!")) != NULL && strlen(bp) >= 13) { + if (strncmp(bp,"!S01,Radiance",13) == 0) { + rv = devRadiance; + } + } + } + + a1logd(p->log, 5, "ser_vtpglut_type: Device type is '%s'\n", inst_name(rv)); + + p->close_port(p); /* Or should we leave it open ?? */ + + p->itype = rv; + + return rv; +} +#undef BUFSZ + +#endif /* ENABLE_SERIAL */ + +#if defined(ENABLE_SERIAL) || defined(ENABLE_FAST_SERIAL) + +/* Convert an ASCII Hex character to an integer. */ +static int h2b(char c) { + if (c >= '0' && c <= '9') + return (c-(int)'0'); + if (c >= 'A' && c <= 'F') + return (10 + c-(int)'A'); + if (c >= 'a' && c <= 'f') + return (10 + c-(int)'a'); + return 0; +} + +/* Convert a Hex encoded buffer into binary. */ +/* len is number of bytes out */ +static void hex2bin(char *buf, int len) { + int i; + + for (i = 0; i < len; i++) { + buf[i] = (char)((h2b(buf[2 * i + 0]) << 4) + | (h2b(buf[2 * i + 1]) << 0)); + } +} + +#endif /* ENABLE_SERIAL */ + + + + + + + + + + + + + + + + + + + + + + + -- cgit v1.2.3