From 3d0baaf770e1221e1080aeba006a044c992e5021 Mon Sep 17 00:00:00 2001 From: Iocuser Date: Thu, 23 Jun 2022 10:38:38 +0200 Subject: [PATCH] added trigger out --- ADHamaApp/Db/hama.template | 1017 +++++++++++++++++++++ ADHamaApp/src/hama.cpp | 552 +++++++++++- ADHamaApp/src/hama.h | 152 ++-- cmds/st.cmd | 6 + support/dcamsdk4/inc/dcamapi4.h | 1136 ++++++++++++++++++++++++ support/dcamsdk4/inc/dcamprop.h | 1017 +++++++++++++++++++++ support/dcamsdk4/lib/.DS_Store | Bin 0 -> 6148 bytes support/dcamsdk4/lib/win32/dcamapi.lib | Bin 0 -> 26828 bytes support/dcamsdk4/lib/win64/dcamapi.lib | Bin 0 -> 24984 bytes support/dcamsdk4/misc/common.cpp | 243 +++++ support/dcamsdk4/misc/common.h | 12 + support/dcamsdk4/misc/console4.h | 153 ++++ support/dcamsdk4/misc/dcamapix.h | 5 + support/dcamsdk4/misc/dyndcam4.cpp | 648 ++++++++++++++ support/dcamsdk4/misc/qthread.cpp | 85 ++ support/dcamsdk4/misc/qthread.h | 34 + 16 files changed, 4959 insertions(+), 101 deletions(-) create mode 100644 support/dcamsdk4/inc/dcamapi4.h create mode 100644 support/dcamsdk4/inc/dcamprop.h create mode 100644 support/dcamsdk4/lib/.DS_Store create mode 100644 support/dcamsdk4/lib/win32/dcamapi.lib create mode 100644 support/dcamsdk4/lib/win64/dcamapi.lib create mode 100644 support/dcamsdk4/misc/common.cpp create mode 100644 support/dcamsdk4/misc/common.h create mode 100644 support/dcamsdk4/misc/console4.h create mode 100644 support/dcamsdk4/misc/dcamapix.h create mode 100644 support/dcamsdk4/misc/dyndcam4.cpp create mode 100644 support/dcamsdk4/misc/qthread.cpp create mode 100644 support/dcamsdk4/misc/qthread.h diff --git a/ADHamaApp/Db/hama.template b/ADHamaApp/Db/hama.template index a4422fc..3875f43 100644 --- a/ADHamaApp/Db/hama.template +++ b/ADHamaApp/Db/hama.template @@ -90,4 +90,1021 @@ record(mbbi, "$(P)$(R)ColorMode_RBV") { field(SVVL, "") } +record(longin, "$(P)$(R)ArrayCounter_RBV") +{ + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR=0),$(TIMEOUT=1))ARRAY_COUNTER") + field(SCAN, "I/O Intr") +} + +########################################################################## +# General properties # +########################################################################## +record(stringin, "$(P)$(R)Vendor-RB"){ + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynOctetRead") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_VENDOR") +} + +record(stringin, "$(P)$(R)Model-RB"){ + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynOctetRead") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MODEL") +} + +record(stringin, "$(P)$(R)CameraID-RB"){ + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynOctetRead") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CAMERAID") +} + +record(stringin, "$(P)$(R)Bus-RB"){ + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynOctetRead") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUS") +} + +record(stringin, "$(P)$(R)CameraVersion-RB"){ + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynOctetRead") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CAMERA_VERSION") +} + +record(stringin, "$(P)$(R)DriverVersion-RB"){ + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynOctetRead") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_DRIVER_VERSION") +} + +record(stringin, "$(P)$(R)ModuleVersion-RB"){ + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynOctetRead") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MODULE_VERSION") +} + +record(stringin, "$(P)$(R)DcamApiVersion-RB"){ + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynOctetRead") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_DCAM_API_VERSION") +} + + +########################################################################## +# Sensor Mode and Speed # +########################################################################## +# Sensor Mode (mode 4) +record(mbbo, "$(P)$(R)SensorMode-S") { + field(DESC,"") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(ZRVL, "0") + field(ZRST, "Area") + field(ZRVL, "1") + field(ZRST, "Progressive") + field(TWVL, "2") + field(TWST, "Splitview") + field(THVL, "3") + field(THST, "Duallightsheet") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_MODE") + field(VAL, "0") +} + +record(mbbi, "$(P)$(R)SensorMode-RB") { + field(DESC,"") + field(DTYP, "asynInt32") + field(ZRVL, "0") + field(ZRST, "Area") + field(ZRVL, "1") + field(ZRST, "Progressive") + field(TWVL, "2") + field(TWST, "Splitview") + field(THVL, "3") + field(THST, "Duallightsheet") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_MODE") + field(SCAN, "I/O Intr") +} + +########################################################################## +# Readout Speed (long) +record(ao, "$(P)$(R)ReadoutSpeed-S") { + field(DESC,"") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_READOUT_SPEED") + field(VAL, "2") +} + +record(ai, "$(P)$(R)ReadoutSpeed-RB") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_READOUT_SPEED") + field(SCAN, "I/O Intr") +} + +########################################################################## +# Readout Direction (mode 3) +record(mbbo, "$(P)$(R)ReadoutDirection-S") { + field(DESC,"") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(ZRVL, "0") + field(ZRST, "Diverge") + field(ONVL, "1") + field(ONST, "Forward") + field(TWVL, "2") + field(TWST, "Backward") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_READOUT_DIRECTION") + field(VAL, "1") +} + +record(mbbi, "$(P)$(R)ReadoutDirection-RB") { + field(DESC,"") + field(ZRVL, "0") + field(ZRST, "Diverge") + field(ONVL, "1") + field(ONST, "Forward") + field(TWVL, "2") + field(TWST, "Backward") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_READOUT_DIRECTION") + field(SCAN, "I/O Intr") +} + +########################################################################## +# Trigger # +########################################################################## +# Trigger source (mode 4) +record(mbbo, "$(P)$(R)TriggerSource-S") { + field(DESC,"") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Internal") + field(ONVL, "2") + field(ONST, "External") + field(TWVL, "3") + field(TWST, "Software") + field(THVL, "4") + field(THST, "Master Pulse") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_SOURCE") + field(VAL, "1") +} + +record(mbbi, "$(P)$(R)TriggerSource-RB") { + field(DESC,"") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Internal") + field(ONVL, "2") + field(ONST, "External") + field(TWVL, "3") + field(TWST, "Software") + field(THVL, "4") + field(THST, "Master Pulse") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_SOURCE") + field(SCAN, "I/O Intr") +} +########################################################################## +# Trigger mode (mode 2) +record(mbbo, "$(P)$(R)TriggerMode-S") { + field(DESC,"") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Normal") + field(ONVL, "6") + field(ONST, "Start") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_MODE") + field(VAL, "1") +} + +record(mbbi, "$(P)$(R)TriggerMode-RB") { + field(DESC,"") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Normal") + field(ONVL, "6") + field(ONST, "Start") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_MODE") + field(SCAN, "I/O Intr") +} +########################################################################## +# Trigger Active (mode 3) +record(mbbo, "$(P)$(R)TriggerActive-S") { + field(DESC,"") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Edge") + field(ONVL, "2") + field(ONST, "Level") + field(TWVL, "3") + field(TWST, "Sync Readout") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_ACTIVE") + field(VAL, "1") +} + +record(mbbi, "$(P)$(R)TriggerActive-RB") { + field(DESC,"") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Edge") + field(ONVL, "2") + field(ONST, "Level") + field(TWVL, "3") + field(TWST, "Sync Readout") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_ACTIVE") + field(SCAN, "I/O Intr") +} +########################################################################## +# Trigger Global Exposure (mode 2) +record(mbbo, "$(P)$(R)TriggerGlobalExposure-S") { + field(DESC,"") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(ZRVL, "3") + field(ZRST, "Global Exposure Delay") + field(ONVL, "5") + field(ONST, "Global Exposure Reset") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_GLOBAL_EXPOSURE") + field(VAL, "3") +} + +record(mbbi, "$(P)$(R)TriggerGlobalExposure-RB") { + field(DESC, "") + field(DTYP, "asynInt32") + field(ZRVL, "3") + field(ZRST, "Global Exposure Delay") + field(ONVL, "5") + field(ONST, "Global Exposure Reset") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_GLOBAL_EXPOSURE") + field(SCAN, "I/O Intr") +} +########################################################################## +# Trigger Polarity (mode 2) +record(mbbo, "$(P)$(R)TriggerPolarity-S") { + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Negative") + field(ONVL, "2") + field(ONST, "Positive") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_POLARITY") + field(VAL, "1") +} + +record(mbbi, "$(P)$(R)TriggerPolarity-RB") { + field(DESC, "") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Negative") + field(ONVL, "2") + field(ONST, "Positive") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_POLARITY") + field(SCAN, "I/O Intr") +} +########################################################################## +# Trigger Connector (mode 2) +record(mbbo, "$(P)$(R)TriggerConnector-S") { + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Connector Interface") + field(ONVL, "2") + field(ONST, "Connector BNC") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_CONNECTOR") + field(VAL, "1") + field(TPRO, "1") +} + +record(mbbi, "$(P)$(R)TriggerConnector-RB") { + field(DESC, "") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Connector Interface") + field(ONVL, "2") + field(ONST, "Connector BNC") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_CONNECTOR") + field(SCAN, "I/O Intr") +} +########################################################################## +# Trigger Times +record(ao, "$(P)$(R)TriggerTimes-S") { + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(DRVL, "1") + field(DRVH, "10000") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_TIMES") + field(VAL, "1") +} + +record(ai, "$(P)$(R)TriggerTimes-RB") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_TIMES") + field(SCAN, "I/O Intr") +} +########################################################################## +# Trigger Delay +record(ao, "$(P)$(R)TriggerDelay-S") { + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynFloat64") + field(DRVL, "0") + field(DRVH, "10.0") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_DELAY") + field(VAL, "0") +} + +record(ai, "$(P)$(R)TriggerDelay-RB") { + field(DESC, "") + field(DTYP, "asynFloat64") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_DELAY") + field(SCAN, "I/O Intr") +} +########################################################################## +# Internal Trigger Handling (mode 2) +record(mbbo, "$(P)$(R)InternalTriggerHandling-S") { + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Short Exposure") + field(ONVL, "7") + field(ONST, "Individual") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_TRIGGER_HANDLING") + field(VAL, "1") +} + +record(mbbi, "$(P)$(R)InternalTriggerHandling-RB") { + field(DESC, "") + field(ZRVL, "1") + field(ZRST, "Short Exposure") + field(ONVL, "7") + field(ONST, "Individual") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_TRIGGER_HANDLING") + field(SCAN, "I/O Intr") +} + + +########################################################################## +# Sensor Cooler # +########################################################################## + +record(ai, "$(P)$(R)Temperature-R") { + field(DESC, "") + field(DTYP, "asynFloat64") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_COOLER_STATUS") + field(SCAN, "I/O Intr") +} + +record(mbbo, "$(P)$(R)Cooler-S") { + field(DESC, "") + field(ZRVL, "0") + field(ZRST, "OFF") + field(ONVL, "1") + field(ONST, "ON") + field(TWVL, "2") + field(TWST, "MAX") + field(DTYP, "asynInt32") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_COOLER") +} + +record(mbbi, "$(P)$(R)Cooler-RB") { + field(DESC, "") + field(ZRVL, "0") + field(ZRST, "OFF") + field(ONVL, "1") + field(ONST, "ON") + field(TWVL, "2") + field(TWST, "MAX") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_COOLER") + field(SCAN, "I/O Intr") +} + +record(mbbi, "$(P)$(R)CoolerStatus-R") { + field(DESC, "") + field(ZRVL, "0") + field(ZRST, "OFF") + field(ONVL, "1") + field(ONST, "Ready") + field(TWVL, "2") + field(TWST, "Busy") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_COOLER_STATUS") + field(SCAN, "I/O Intr") +} + + +########################################################################## +# Binning and ROI # +########################################################################## + + +########################################################################## +# Feature # +########################################################################## + + +########################################################################## +# ALU # +########################################################################## + + +########################################################################## +# Output Trigger # +########################################################################## +#Output Trigger Connector +record(ai, "$(P)$(R)OutputTriggerConnector-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_CONNECTOR") + field(SCAN, "I/O Intr") +} + +########################################################################## +# Output Trigger Source 0 (mode 4) +record(mbbo, "$(P)$(R)OutputTriggerSource0-S") { + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(ZRVL, "2") + field(ZRST, "Read Out End") + field(ONVL, "3") + field(ONST, "VSync") + field(TWVL, "4") + field(TWST, "HSync") + field(THVL, "6") + field(THST, "Trigger") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_SOURCE0") + field(VAL, "2") +} + +record(mbbi, "$(P)$(R)OutputTriggerSource0-RB") { + field(DESC, "") + field(DTYP, "asynInt32") + field(ZRVL, "2") + field(ZRST, "Read Out End") + field(ONVL, "3") + field(ONST, "VSync") + field(TWVL, "4") + field(THST, "HSync") + field(THVL, "6") + field(THST, "Trigger") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_SOURCE0") + field(SCAN, "I/O Intr") +} + +########################################################################## +# Output Trigger Polarity 0 (mode 2) +record(mbbo, "$(P)$(R)OutputTriggerPolarity0-S") { + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Negative") + field(ONVL, "2") + field(ONST, "Positive") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_POLARITY0") + field(VAL, "1") +} + +record(mbbi, "$(P)$(R)OutputTriggerPolarity0-RB") { + field(DESC, "") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Negative") + field(ONVL, "2") + field(ONST, "Positive") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_POLARITY0") + field(SCAN, "I/O Intr") +} +########################################################################## +# Internal Trigger Active (mode 1) +record(mbbo, "$(P)$(R)OutputTriggerActive0-S") { + field(DESC, "") + field(DTYP, "asynInt32") + field(PINI, "YES") + field(ZRVL, "1") + field(ZRST, "Edge") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_ACTIVE0") + field(VAL, "1") +} + +record(mbbi, "$(P)$(R)OutputTriggerActive0-RB") { + field(DESC, "") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Edge") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_ACTIVE0") + field(SCAN, "I/O Intr") +} + +########################################################################## +# Output Trigger Delay 0 +record(ao, "$(P)$(R)OutputTriggerDelay0-S") { + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynFloat64") + field(DRVL, "0") + field(DRVH, "10.0") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_DELAY0") + field(VAL, "0") +} + +record(ai, "$(P)$(R)OutputTriggerDelay0-RB") { + field(DESC, "") + field(DTYP, "asynFloat64") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_DELAY0") + field(SCAN, "I/O Intr") +} + +########################################################################## +# Output Trigger Period 0 +record(ao, "$(P)$(R)OutputTriggerPeriod0-S") { + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynFloat64") + field(DRVL, "0.000001") + field(DRVH, "10.0") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PERIOD0") + field(VAL, "0") +} + +record(ai, "$(P)$(R)OutputTriggerPeriod0-RB") { + field(DESC, "") + field(DTYP, "asynFloat64") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PERIOD0") + field(SCAN, "I/O Intr") +} + +########################################################################## +# Output Trigger Kind 0 (mode 5) +record(mbbo, "$(P)$(R)OutputTriggerKind0-S") { + field(DESC, "") + field(DTYP, "asynInt32") + field(PINI, "YES") + field(ZRVL, "1") + field(ZRST, "Low") + field(ONVL, "2") + field(ONST, "Global Exposure") + field(TWVL, "3") + field(TWST, "Programable") + field(THVL, "4") + field(THST, "Trigger Ready") + field(FRVL, "5") + field(FRST, "High") + field(FVVL, "6") + field(FVST, "Any Row Exposure") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_KIND0") + field(VAL, "1") +} + +record(mbbi, "$(P)$(R)OutputTriggerKind0-RB") { + field(DESC, "") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "Low") + field(ONVL, "2") + field(ONST, "Global Exposure") + field(TWVL, "3") + field(TWST, "Programable") + field(THVL, "4") + field(THST, "Trigger Ready") + field(FRVL, "5") + field(FRST, "High") + field(FVVL, "6") + field(FVST, "Any Row Exposure") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_KIND0") + field(SCAN, "I/O Intr") +} + +########################################################################## +# Output Trigger PreHsyncCount +record(ao, "$(P)$(R)OutputTriggerPreHsyncCount-S") { + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(DRVL, "0") + field(DRVH, "2047") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT") + field(VAL, "0") +} + +record(ai, "$(P)$(R)OutputTriggerPreHsyncCount-RB") { + field(DESC, "") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT") + field(SCAN, "I/O Intr") +} + +########################################################################## +# Output Trigger Base Sensor 0 (mode 4) +record(mbbo, "$(P)$(R)OutputTriggerBaseSensor0-S") { + field(DESC, "") + field(PINI, "YES") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "View 1") + field(ONVL, "2") + field(ONST, "View 2") + field(TWVL, "15") + field(TWST, "Any View") + field(THVL, "16") + field(THST, "All Views") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_TRIGGER_HANDLING0") + field(VAL, "1") +} + +record(mbbi, "$(P)$(R)OutputTriggerBaseSensor0-RB") { + field(DESC, "") + field(DTYP, "asynInt32") + field(ZRVL, "1") + field(ZRST, "View 1") + field(ONVL, "2") + field(ONST, "View 2") + field(TWVL, "15") + field(TWST, "Any View") + field(THVL, "16") + field(THST, "All Views") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_TRIGGER_HANDLING0") + field(SCAN, "I/O Intr") +} + +########################################################################## +# Master Pulse # +########################################################################## + + +########################################################################## +# Synchronious Timing # +########################################################################## + + +########################################################################## +# System Information # +########################################################################## + +record(mbbi, "$(P)$(R)ColorType-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(ZRVL, "0") + field(ZRST, "BW") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_COLOR_TYPE") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)BitsPerChannel-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BIT_PER_CHANNEL") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)ImageWidth-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_WIDTH") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)ImageHeight-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_HEIGHT") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)RowBytes-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_ROWBYTES") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)FrameBytes-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_FRAMEBYTES") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)TopOffsetBytes-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_TOP_OFFSETBYTES") + field(SCAN, "I/O Intr") +} + +record(mbbo, "$(P)$(R)PixelType-S") { + field(DESC,"") + field(ZRVL, "0") + field(ZRST, "MONO8") + field(ONVL, "1") + field(ONST, "MONO16") + field(TWVL, "2") + field(TWST, "MONO12") + field(DTYP, "asynInt32") + field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_PIXEL_TYPE") + field(VAL, "1") +} + +record(mbbi, "$(P)$(R)PixelType-RB") { + field(DESC,"") + field(ZRVL, "0") + field(ZRST, "MONO8") + field(ONVL, "1") + field(ONST, "MONO16") + field(TWVL, "2") + field(TWST, "MONO12") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_PIXEL_TYPE") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)BufRowBytes-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUFFER_ROWBYTES") + field(SCAN, "I/O Intr") +} +record(ai, "$(P)$(R)BufFrameBytes-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUFFER_FRAMEBYTES") + field(SCAN, "I/O Intr") +} +record(ai, "$(P)$(R)BufTopOffsetBytes-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUFFER_TOP_OFFSETBYTES") + field(SCAN, "I/O Intr") +} + +record(mbbi, "$(P)$(R)BufPixelType-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(ZRVL, "0") + field(ZRST, "MONO8") + field(ONVL, "1") + field(ONST, "MONO16") + field(TWVL, "2") + field(TWST, "MONO12") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUFFER_PIXEL_TYPE") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)RecBytesPerFile-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_RECORD_FIXED_BYTES_PER_FILE") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)RecBytesPerSesion-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_RECORD_FIXED_BYTES_PER_SESION") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)RecBytesPerFrame-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_RECORD_FIXED_BYTES_PER_FRAME") + field(SCAN, "I/O Intr") +} + +record(mbbi, "$(P)$(R)SystemAlive-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(ZRVL, "0") + field(ZRST, "OFFLINE") + field(ONVL, "1") + field(ONST, "ONLINE") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SYSTEM_ALIVE") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)ConversionOffset-R") { + field(DESC,"") + field(DTYP, "asynFloat64") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CONVERSION_FACTOR_OFFSET") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)ConversionCoef-R") { + field(DESC,"") + field(DTYP, "asynFloat64") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CONVERSION_FACTOR_COEF") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)NumberOfView-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_NUMBER_OF_VIEW") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)ImageWidth-R") { + field(DESC,"") + field(DTYP, "asynFloat64") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_DETECTOR_PIXEL_WIDTH") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)ImageHeight-R") { + field(DESC,"") + field(DTYP, "asynFloat64") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_DETECTOR_PIXEL_HEIGHT") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)ImagePixelNumHorz-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_DETECTOR_PIXEL_NUM_HORZ") + field(SCAN, "I/O Intr") +} + +record(ai, "$(P)$(R)ImagePixelNumVert-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_DETECTOR_PIXEL_NUM_VERT") + field(SCAN, "I/O Intr") +} + +record(mbbi, "$(P)$(R)TimeStampProd-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(ZRVL, "0") + field(ZRST, "TimeStamp DCAM Module") + field(ONVL, "1") + field(ONST, "TimeStamp Image Dev") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMESTAMP_PRODUCER") + field(SCAN, "I/O Intr") +} + +record(mbbi, "$(P)$(R)TimeFrameProd-R") { + field(DESC,"") + field(DTYP, "asynInt32") + field(ZRVL, "0") + field(ZRST, "TimeStamp DCAM Module") + field(ONVL, "1") + field(ONST, "TimeStamp Image Dev") + field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMEFRAME_PRODUCER") + field(SCAN, "I/O Intr") +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +# (mode) +#record(ao, "$(P)$(R)") { +# field(DESC,"") +# field(PINI, "YES") +# field(DTYP, "asynInt32") +# field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))") +# field(VAL, "1") +#} +# +#record(ai, "$(P)$(R)") { +# field(DESC,"") +# field(DTYP, "asynInt32") +# field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))") +# field(SCAN, "I/O Intr") +#} + +# +#"H_SENSOR_TEMPERATURE" /* asynFloat64 ro */ +#"H_SENSOR_COOLER" /* asynInt32 rw */ +#"H_SENSOR_COOLER_STATUS" /* asynInt32 ro */ +# +# +#BINNING" /* asynInt32 rw */ +#"H_SUBARRAY_HPOST" /* asynInt32 rw */ +#_SUBARRAY_HSIZE" /* asynInt32 rw */ +#"H_SUBARRAY_VPOS" /* asynInt32 rw */ +#_SUBARRAY_VPOS" /* asynInt32 rw */ +#"H_SUBARRAY_MODE" /* asynInt32 rw */ +#b3 only not implemented) +#b3 only not implemented) +# +# +#"H_EXPOSURE_TIME" /* asynFloat64 rw */ +# +# +#"H_DEFECT_CORRECT_MODE" /* asynInt32 rw */ +#"H_HOT_PIXEL_CORRECT_LEVEL" /* asynInt32 rw */ +#"H_INTENSITY_LUT_MODE" /* asynInt32 rw */ +#"H_INTENSITY_LUT_PAGE" /* asynInt32 ro */ +#H_EXTRACTION_MODE" /* asynInt32 ro */ +# +# +#"H_NUMBER_OUTPUT_TRIGGER_CONNECTORS"/* asynInt3 +#"H_OUTPUT_TRIGGER_SOURCE0" /* asynInt32 rw */ +#"H_OUTPUT_TRIGGER_SOURCE1" /* asynInt32 rw */ +#"H_OUTPUT_TRIGGER_SOURCE2" /* asynInt32 rw */ +#"H_OUTPUT_TRIGGER_POLARITY0" /* asynInt32 rw */ +#"H_OUTPUT_TRIGGER_POLARITY1" /* asynInt32 rw */ +#"H_OUTPUT_TRIGGER_POLARITY2" /* asynInt32 rw */ +#"H_OUTPUT_TRIGGER_ACTIVE0" /* asynInt32 ro */ +#"H_OUTPUT_TRIGGER_ACTIVE1" /* asynInt32 ro */ +#"H_OUTPUT_TRIGGER_ACTIVE2" /* asynInt32 ro */ +#"H_OUTPUT_TRIGGER_DELAY0" /* asynFloat64 rw */ +#"H_OUTPUT_TRIGGER_DELAY1" /* asynFloat64 rw */ +#"H_OUTPUT_TRIGGER_DELAY2" /* asynFloat64 rw */ +#"H_OUTPUT_TRIGGER_PERIOD0" /* asynFloat64 rw */ +#"H_OUTPUT_TRIGGER_PERIOD1" /* asynFloat64 rw */ +#"H_OUTPUT_TRIGGER_PERIOD2" /* asynFloat64 rw */ +#"H_OUTPUT_TRIGGER_KIND0" /* asynInt32 rw */ +#"H_OUTPUT_TRIGGER_KIND1" /* asynInt32 rw */ +#"H_OUTPUT_TRIGGER_KIND2" /* asynInt32 rw */ +#"H_OUTPUT_TRIGGER_BASE_SENSOR0" /* asynInt32 rw */ +#"H_OUTPUT_TRIGGER_BASE_SENSOR1" /* asynInt32 rw */ +#"H_OUTPUT_TRIGGER_BASE_SENSOR2" /* asynInt32 rw */ +#"H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT" /* asynInt32 rw */ +# +# +#"H_MASTERPULSE_MODE" /* asynInt32 rw */ +#"H_MASTERPULSE_TRIGGER_SOURCE" /* asynInt32 rw */ +#"H_MASTERPULSE_INTERVAL" /* asynFloat64 rw */ +#"H_MASTERPULSE_BURST_TIMES" /* asynInt32 rw */ +# +# +#"H_TIMING_READOUT_TIME" /* asynFloat64 ro */ +#"H_TIMING_CYCLIC_TRIGGER_PERIOD" /* asynFloat64 ro */ +#"H_TIMING_MIN_TRIGGER_BLANKING" /* asynFloat64 ro */ +#"H_TIMING_MIN_TRIGGER_INTERVAL" /* asynFloat64 ro */ +#"H_TIMING_GLOBAL_EXPOSURE_DELAY" /* asynFloat64 ro */ +#"H_TIMING_EXPOSURE" /* asynInt32 ro */ +#"H_TIMING_INVALID_EXPOSURE_PERIOD" /* asynFloat64 r +#"H_INTERNAL_FRAME_RATE" /* asynFloat64 rw */ +#"H_INTERNAL_FRAME_INTERVAL" /* asynFloat64 rw */ +#"H_INTERNAL_LINE_SPEED" /* asynFloat64 rw */ +#"H_INTERNAL_LINE_INTERVAL" /* asynFloat64 rw */ +# +# +#"H_COLOR_TYPE" /* asynInt32 ro */ +#"H_BIT_PER_CHANNEL /* asynInt32 rw */ +#"H_IMAGE_WIDTH" /* asynInt32 ro */ +#"H_IMAGE_HEIGHT" /* asynInt32 ro */ +#"H_IMAGE_ROWBYTES" /* asynInt32 ro */ +#"H_IMAGE_FRAMEBYTES" /* asynInt32 ro */ +#"H_IMAGE_TOP_OFFSETBYTES" /* asynInt32 ro */ +#"H_IMAGE_PIXEL_TYPE" /* asynInt32 rw */ +#"H_BUFFER_ROWBYTES" /* asynInt32 ro */ +#"H_BUFFER_FRAMEBYTES" /* asynInt32 ro */ +#"H_BUFFER_TOP_OFFSETBYTES" /* asynInt32 ro */ +#"H_BUFFER_PIXEL_TYPE" /* asynInt32 ro */ +#"H_RECORD_FIXED_BYTES_PER_FILE" /* asynInt32 ro */ +#"H_RECORD_FIXED_BYTES_PER_SESION" /* asynInt32 ro */ +#"H_RECORD_FIXED_BYTES_PER_FRAME" /* asynInt32 ro */ +#"H_SYSTEM_ALIVE" /* asynInt32 ro */ +#"H_CONVERSION_FACTOR_COEF" /* asynFloat64 ro */ +#"H_CONVERSION_FACTOR_OFFSET" /* asynFloat64 ro */ +#"H_NUMBER_OF_VIEW" /* asynInt32 ro */ +#"H_IMAGE_DETECTOR_PIXEL_WIDTH" /* asynFloat64 ro */ +#"H_IMAGE_DETECTOR_PIXEL_HEIGHT" /* asynFloat64 ro */ +#"H_IMAGE_DETECTOR_PIXEL_NUM_HORZ" /* asynInt32 ro */ +#"H_IMAGE_DETECTOR_PIXEL_NUM_VERT" /* asynInt32 ro */ \ No newline at end of file diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp index 4e832d0..e872313 100644 --- a/ADHamaApp/src/hama.cpp +++ b/ADHamaApp/src/hama.cpp @@ -14,7 +14,7 @@ #include "hama.h" // --- includes from DCMAPI ---- -// #include +#include "dcamprop.h" // @@ -36,12 +36,27 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory, printf("[DEBUG] === Constructor ADHama ===\n"); printf("[DEBUG] driverName: %s\n", driverName); - createParam( HamaName, asynParamOctet, &hHamaName); - createParam( hSensorModeString, asynParamInt32, &hSensorMode); - createParam( hReadoutSpeedString, asynParamInt32, &hReadoutSpeed); - createParam( hReadoutDirectionString, asynParamInt32, &hReadoutDirection); +//General + + createParam( HamaName, asynParamOctet, &hHamaName); + createParam( hVendorString, asynParamOctet, &hVendor); + createParam( hModelString, asynParamOctet, &hModel); + createParam( hCameraIDString, asynParamOctet, &hCameraID); + createParam( hBusString, asynParamOctet, &hBus); + createParam( hCameraVersionString, asynParamOctet, &hCameraVersion); + createParam( hDriverVersionString, asynParamOctet, &hDriverVersion); + createParam( hModuleVersionString, asynParamOctet, &hModuleVersion); + createParam( hDcamApiVersionString, asynParamOctet, &hDcamApiVersion); + +//Sensor Mode and Speed + createParam( hSensorModeString, asynParamInt32, &hSensorMode); + createParam( hReadoutSpeedString, asynParamInt32, &hReadoutSpeed); + createParam( hReadoutDirectionString, asynParamInt32, &hReadoutDirection); + +//Trigger createParam( hTriggerModeString, asynParamInt32, &hTriggerMode); + createParam( hTriggerSourceString, asynParamInt32, &hTriggerSource); createParam( hTriggerActiveString, asynParamInt32, &hTriggerActive); createParam( hTriggerGlobalExposureString, asynParamInt32, &hTriggerGlobalExposure); createParam( hTriggerPolarityString, asynParamInt32, &hTriggerPolarity); @@ -50,22 +65,339 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory, createParam( hTriggerDelayString, asynParamFloat64, &hTriggerDelay); createParam( hInternalTriggerHandlingString, asynParamInt32, &hInternalTriggerHandling); - createParam( hSensorTemperatureString, asynParamFloat64, &hSensorTemperature); - createParam( hSensorCoolerString, asynParamInt32, &hSensorCooler); - createParam( hSensorCoolerStatusString, asynParamInt32, &hSensorCoolerStatus); -// createParam( +//Sensor cooler + createParam( hSensorTemperatureString, asynParamFloat64, &hSensorTemperature); + createParam( hSensorCoolerString, asynParamInt32, &hSensorCooler); + createParam( hSensorCoolerStatusString, asynParamInt32, &hSensorCoolerStatus); + +//Binning and ROI + createParam( hBinningString, asynParamInt32, &hBinning); + createParam( hSubarrayHPosString, asynParamInt32, &hSubarrayHPos); + createParam( hSubarrayHSizeString, asynParamInt32, &hSubarrayHSize); + createParam( hSubarrayVPosString, asynParamInt32, &hSubarrayVPos); + createParam( hSubarrayVSizeString, asynParamInt32, &hSubarrayVSize); + createParam( hSubarrayModeString, asynParamInt32, &hSubarrayMode); + +//Feature + createParam( hExposureTimeString, asynParamFloat64, &hExposureTime); + +//ALU + createParam( hDefectCorrectModeString, asynParamInt32, &hDefectCorrectMode); + createParam( hHotPixelCorrectLevelString, asynParamInt32, &hHotPixelCorrectLevel); + createParam( hIntensityLutModeString, asynParamInt32, &hIntensityLutMode); + createParam( hIntensityLutPageString, asynParamInt32, &hIntensityLutPage); + +//output trigger + createParam( hNumberOfOutputTriggerConnectorString, asynParamInt32, &hNumberOfOutputTriggerConnector); + createParam( hOutputTriggerSource0String, asynParamInt32, &hOutputTriggerSource0), + createParam( hOutputTriggerSource1String, asynParamInt32, &hOutputTriggerSource1); + createParam( hOutputTriggerSource2String, asynParamInt32, &hOutputTriggerSource2); + createParam( hOutputTriggerPolarity0String, asynParamInt32, &hOutputTriggerPolarity0); + createParam( hOutputTriggerPolarity1String, asynParamInt32, &hOutputTriggerPolarity1); + createParam( hOutputTriggerPolarity2String, asynParamInt32, &hOutputTriggerPolarity2); + createParam( hOutputTriggerActive0String, asynParamInt32, &hOutputTriggerActive0); + createParam( hOutputTriggerActive1String, asynParamInt32, &hOutputTriggerActive1); + createParam( hOutputTriggerActive2String, asynParamInt32, &hOutputTriggerActive2); + createParam( hOutputTriggerDelay0String, asynParamFloat64, &hOutputTriggerDelay0); + createParam( hOutputTriggerDelay1String, asynParamFloat64, &hOutputTriggerDelay1); + createParam( hOutputTriggerDelay2String, asynParamFloat64, &hOutputTriggerDelay2); + createParam( hOutputTriggerPeriod0String, asynParamFloat64, &hOutputTriggerPeriod0); + createParam( hOutputTriggerPeriod1String, asynParamFloat64, &hOutputTriggerPeriod1); + createParam( hOutputTriggerPeriod2String, asynParamFloat64, &hOutputTriggerPeriod2); + createParam( hOutputTriggerKind0String, asynParamInt32, &hOutputTriggerKind0); + createParam( hOutputTriggerKind1String, asynParamInt32, &hOutputTriggerKind1); + createParam( hOutputTriggerKind2String, asynParamInt32, &hOutputTriggerKind2); + createParam( hOutputTriggerBaseSensor0String, asynParamInt32, &hOutputTriggerBaseSensor0); + createParam( hOutputTriggerBaseSensor1String, asynParamInt32, &hOutputTriggerBaseSensor1); + createParam( hOutputTriggerBaseSensor2String, asynParamInt32, &hOutputTriggerBaseSensor2); + createParam( hOutTriggerPreHsyncCountString, asynParamInt32, &hOutTriggerPreHsyncCount); + +//Master Puls +//Synchronious Timing +//System Information + + createParam( hColorTypeString, asynParamInt32, &hColorType); + createParam( hBitPerChannelString, asynParamInt32, &hBitPerChannel); + createParam( hImageWidthString, asynParamInt32, &hImageWidth); + createParam( hImageHeightString, asynParamInt32, &hImageHeight); + createParam( hImageRowBytesString, asynParamInt32, &hImageRowbytes); + createParam( hImageFrameBytesString, asynParamInt32, &hImageFramebytes); + createParam( hImageTopOffsetBytesString, asynParamInt32, &hImageTopOffsetBytes); + createParam( hImagePixelTypeString, asynParamInt32, &hImagePixelType); + createParam( hBufferRowbytesString, asynParamInt32, &hBufferRowbytes); + createParam( hBufferFramebytesString, asynParamInt32, &hBufferFramebytes); + createParam( hBufferTopOffsetBytesString, asynParamInt32, &hBufferTopOffsetBytes); + createParam( hBufferPixelTypeString, asynParamInt32, &hBufferPixelType); + createParam( hRecordFixedBytesPerFileString, asynParamInt32, &hRecordFixedBytesPerFile); + createParam( hRecordFixedBytesPerSessionString, asynParamInt32, &hRecordFixedBytesPerSession); + createParam( hRecordFixedBytesPerFrameString, asynParamInt32, &hRecordFixedBytesPerFrame); + createParam( hSystemAliveString, asynParamInt32, &hSystemAlive); + createParam( hConversionFactorCoeffString, asynParamFloat64, &hConversionFactorCoeff); + createParam( hConversionFactorOffsetString, asynParamFloat64, &hConversionFactorOffset); + createParam( hNumberOfViewString, asynParamInt32, &hNumberOfView); + createParam( hImageDetectorPixelWidthString, asynParamFloat64, &hImageDetectorPixelWidth); + createParam( hImageDetectorPixelHeightString, asynParamFloat64, &hImageDetectorPixelHeight); + createParam( hImageDetectorPixelNumHorzString, asynParamInt32, &hImageDetectorPixelNumHorz); + createParam( hImageDetectorPixelNumVertString, asynParamInt32, &hImageDetectorPixelNumVert); - connectCamera(); + connectCamera(); + + int err = 0; + /* + err |= getParameter(DCAM_IDPROP_SENSORMODE); + err |= getParameter(DCAM_IDPROP_READOUTSPEED); + err |= getParameter(DCAM_IDPROP_READOUT_DIRECTION); + err |= getParameter(DCAM_IDPROP_TRIGGERSOURCE); + err |= getParameter(DCAM_IDPROP_TRIGGER_MODE); + err |= getParameter(DCAM_IDPROP_TRIGGERACTIVE); + err |= getParameter(DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE); + err |= getParameter(DCAM_IDPROP_TRIGGERPOLARITY); + err |= getParameter(DCAM_IDPROP_TRIGGER_CONNECTOR); + err |= getParameter(DCAM_IDPROP_TRIGGERTIMES); + err |= getParameter(DCAM_IDPROP_TRIGGERDELAY); + err |= getParameter(DCAM_IDPROP_INTERNALTRIGGER_HANDLING); + */ + + err |= getParameterStr(DCAM_IDSTR_VENDOR); + err |= getParameterStr(DCAM_IDSTR_MODEL); + err |= getParameterStr(DCAM_IDSTR_CAMERAID); + err |= getParameterStr(DCAM_IDSTR_BUS); + err |= getParameterStr(DCAM_IDSTR_CAMERAVERSION); + err |= getParameterStr(DCAM_IDSTR_DRIVERVERSION); + err |= getParameterStr(DCAM_IDSTR_MODULEVERSION); + err |= getParameterStr(DCAM_IDSTR_DCAMAPIVERSION); + + printf("[DEBUG] Error = %d\n", err); printf("[DEBUG] === END Constructor ADHama ===\n"); } //============================================================================ -Hama::~Hama(){ - // not sure if the destructor has to be define here... - printf("[DEBUG] === Destructor ADHama ===\n"); +//Hama::~Hama(){ +// // not sure if the destructor has to be define here... +// printf("[DEBUG] === Destructor ADHama ===\n"); +//} + +//============================================================================ +int Hama::getParameterStr(int propertyID){ + + asynStatus status = asynSuccess; + + char text[256]; + DCAMDEV_STRING param; + memset( ¶m, 0, sizeof(param) ); + param.size = sizeof(param); + param.text = text; + param.textbytes = sizeof(text); + param.iString = propertyID; + + switch (propertyID){ + case DCAM_IDSTR_VENDOR: + dcamdev_getstring(m_hdcam, ¶m); + status = setStringParam(hVendor, text); + printf("[DEBUG]::VENDOR %s\n", text); + break; + case DCAM_IDSTR_MODEL: + dcamdev_getstring(m_hdcam, ¶m); + status = setStringParam(hModel, text); + printf("[DEBUG]::MODEL %s\n", text); + break; + case DCAM_IDSTR_CAMERAID: + dcamdev_getstring(m_hdcam, ¶m); + status = setStringParam(hCameraID, text); + printf("[DEBUG]::CAMERAID %s\n", text); + break; + case DCAM_IDSTR_BUS: + dcamdev_getstring(m_hdcam, ¶m); + status = setStringParam(hBus, text); + printf("[DEBUG]::BUS %s\n", text); + break; + case DCAM_IDSTR_CAMERAVERSION: + dcamdev_getstring(m_hdcam, ¶m); + status = setStringParam(hCameraVersion, text); + printf("[DEBUG]::CAMERAVERSION %s\n", text); + break; + case DCAM_IDSTR_DRIVERVERSION: + dcamdev_getstring(m_hdcam, ¶m); + status = setStringParam(hDriverVersion, text); + printf("[DEBUG]::DRIVERVERSION %s\n", text); + break; + case DCAM_IDSTR_MODULEVERSION: + dcamdev_getstring(m_hdcam, ¶m); + status = setStringParam(hModuleVersion, text); + printf("[DEBUG]::MODULEVERSION %s\n", text); + break; + case DCAM_IDSTR_DCAMAPIVERSION: + dcamdev_getstring(m_hdcam, ¶m); + status = setStringParam(hDcamApiVersion, text); + printf("[DEBUG]::DCAMPVERSION %s\n", text); + break; + default: + printf("[DEBUG]::NOT SUPPORTED\n"); + break; + + } + + /* Do callbacks so higher layers see any changes */ + status = (asynStatus) callParamCallbacks(); + + // asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: port=%s, value=%d, status=%d\n", + // driverName, functionName, this->portName, value, (int)status); +return int(status); +} +//============================================================================ +int Hama::getParameter(int propertyID){ + printf("\n[DEBUG] Function:getProperty\n"); + + double value = 0; + dcamprop_getvalue(m_hdcam, propertyID, &value); + + switch (propertyID){ + case DCAM_IDPROP_SENSORMODE: + printf("The SENSOR MODE = %f\n", value); + break; + + case DCAM_IDPROP_READOUTSPEED: + printf("The READOUT SPEED = %f\n", value); + break; + + case DCAM_IDPROP_READOUT_DIRECTION: + printf("The READOUT DIRECTION = %f\n", value); + break; + + case DCAM_IDPROP_TRIGGERSOURCE: + printf("The = TRIGGER SOURCE = %f\n", value); + break; + + case DCAM_IDPROP_TRIGGER_MODE: + printf("The TRIGGER MODE = %f\n", value); + break; + + case DCAM_IDPROP_TRIGGERACTIVE: + printf("The TRIGGER ACTIVE = %f\n", value); + break; + + case DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE: + printf("The TRIGGER GLOBAL EXPOSURE = %f\n", value); + break; + + case DCAM_IDPROP_TRIGGERPOLARITY: + printf("The TRIGGER POLARITY = %f\n", value); + break; + + case DCAM_IDPROP_TRIGGER_CONNECTOR: + printf("The TRIGGER CONNECTOR = %f\n", value); + break; + + case DCAM_IDPROP_TRIGGERTIMES: + printf("The TRIGGER TIMES = %f\n", value); + break; + + case DCAM_IDPROP_TRIGGERDELAY: + printf("The TRIGGER DELAY = %f\n", value); + break; + + case DCAM_IDPROP_INTERNALTRIGGER_HANDLING: + printf("The INTERNAL TRIGGE HANDLING = %f\n", value); + break; + + default: + printf("The = %f\n", value); + break; + + + + } + +return 0; } +//============================================================================ +int Hama::setParameter(int paramIndex){ +/* + setIntegerParam(ADBinY, 2048); + setIntegerParam(ADBinX, 2048); + setIntegerParam(NDNDimensions, 1); + setIntegerParam(NDArrayCounter, 1); + setIntegerParam(NDDataType, NDUInt16); + setIntegerParam(NDColorMode, NDColorModeMono); + setIntegerParam(NDArraySizeZ, 0); + setIntegerParam(NDArraySize, 5000000); + setStringParam(ADStringToServer, ""); + setStringParam(ADStringFromServer, ""); + setStringParam(ADManufacturer, "Hamamatsu"); +*/ + + +return 0; +} + +//============================================================================ +int Hama::getProperties(){ + printf("\n[DEBUG] Function:getProperties\n"); + + int32 iProp = 0; // property IDs + + double value = 50; + dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORTEMPERATURE, &value); + printf("The SENSOR TEMPERATURE = %f\n", value); + + DCAMERR err; + err = dcamprop_getnextid( m_hdcam, &iProp, DCAMPROP_OPTION_SUPPORT ); + if( failed(err) ) { + printError( m_hdcam, err, "dcamprop_getnextid()", "IDPROP:0x%08x, OPTION:SUPPORT", 0 ); + return err; + } + + do{ + // get property name + char text[ 64 ]; + err = dcamprop_getname( m_hdcam, iProp, text, sizeof(text) ); + if( failed(err) ) { + printError( m_hdcam, err, "dcamprop_getname()", "IDPROP:0x%08x", iProp ); + return err; + } + + printf( "0x%08x: %s\n", iProp, text ); + + // get property attribute + DCAMPROP_ATTR basepropattr; + memset( &basepropattr, 0, sizeof(basepropattr) ); + basepropattr.cbSize = sizeof(basepropattr); + basepropattr.iProp = iProp; + + err = dcamprop_getattr( m_hdcam, &basepropattr ); + if( !failed(err) ) { + + #if SHOW_PROPERTY_ATTRIBUTE + // show property attribute + //dcamcon_show_propertyattr( basepropattr ); + #endif + + #if SHOW_PROPERTY_MODEVALUELIST + // show mode value list of property + //if( (basepropattr.attribute & DCAMPROP_TYPE_MASK) == DCAMPROP_TYPE_MODE ) + // dcamcon_show_supportmodevalues( m_hdcam, iProp, basepropattr.valuemin ); + #endif + + #if SHOW_PROPERTY_ARRAYELEMENT + // show array element + //if( basepropattr.attribute2 & DCAMPROP_ATTR2_ARRAYBASE ) + // dcamcon_show_arrayelement( m_hdcam, basepropattr ); + #endif + } + + // get next property id + err = dcamprop_getnextid( m_hdcam, &iProp, DCAMPROP_OPTION_SUPPORT ); + if( failed(err) ) { + // no more supported property id + return err; + } + + } while( iProp != 0 ); + +return 0; +} //============================================================================ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ @@ -76,42 +408,82 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ int function = pasynUser->reason; asynStatus status = asynSuccess; - // getParamName(index, ¶mName); + printf("[DEBUG]::writeInt32\t"); - if (function == hSensorMode) { - //set_integration_time(); + getParamName(function, ¶mName); + + + if (function == ADAcquire) { + printf("function ADAcquire\n"); + } + else if (function == ADImageMode) { + printf("function ADImageMode\n"); + } + else if (function == ADTriggerMode) { + printf("function ADTriggerMode\n"); + } + else if (function == ADNumExposures) { + printf("function ADNumExposures\n"); + } + else if (function == ADMinX) { + printf("function ADMinX\n"); + } + else if (function == ADMinY) { + printf("function ADMinY\n"); + } + else if (function == ADSizeX) { + printf("function ADSizeX\n"); + } + else if (function == ADSizeY) { + printf("function ADSizeY\n"); + } + else if (function == ADReadStatus) { + printf("function ADReadStatus\n"); + } + else if (function == hSensorMode) { + setIntegerParam(function, value); + printf("function SensorMode\n"); } else if (function == hReadoutSpeed) { + printf("function ReadoutSpeed\n"); } else if (function == hReadoutDirection) { - // Update the calculated spectrum - //update_data_spectrum(); + printf("function ReadoutDirection\n"); } else if (function == hColorType) { - // Check if implmemented in QEPro + printf("function ColorType\n"); } else if (function == hBitPerChannel) { - // Check if implmemented in QEPro + printf("function BitPerChannel\n"); } else if (function == hTriggerSource) { - //getIntegerParam(P_triggerMode, &triggerMode); - //api->spectrometerSetTriggerMode( device_id, spectrometer_feature_id, &error, triggerMode); + printf("function TriggerSorce\n"); + double value_d = 0; + getIntegerParam(function, &value); + printf("value = %d, value_d = %f\n", value, value_d); + dcamprop_setvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, value); + dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &value_d); + printf("value = %d, value_d = %f\n", value, value_d); + setIntegerParam(function, value_d); } else{ + printf("function ELSE.... \n"); } - - - - /* Do callbacks so higher layers see any changes */ status = (asynStatus) callParamCallbacks(); - asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: port=%s, value=%d, status=%d\n", - driverName, functionName, this->portName, value, (int)status); + if (status) + asynPrint(pasynUser, ASYN_TRACE_ERROR, + "%s:%s: error, status=%d function=%d, paramName=%s, value=%d\n", + driverName, functionName, status, function, paramName, value); + else + asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, + "%s:%s: function=%d, paramName=%s, value=%d\n", + driverName, functionName, function, paramName, value); return status; } @@ -120,23 +492,137 @@ return status; asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){ + printf("[DEBUG]::writeFloat64\t"); + const char* functionName = "writeFloat64"; + const char *paramName; + + int function = pasynUser->reason; + asynStatus status = asynSuccess; + + + getParamName(function, ¶mName); + + setDoubleParam(function, value); + + status = (asynStatus) callParamCallbacks(); + + if (status) + asynPrint(pasynUser, ASYN_TRACE_ERROR, + "%s:%s: error, status=%d function=%d, paramName=%s, value=%f\n", + driverName, functionName, status, function, paramName, value); + else + asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, + "%s:%s: function=%d, paramName=%s, value=%f\n", + driverName, functionName, function, paramName, value); + + return(asynSuccess); } //============================================================================ - +/* asynStatus Hama::readEnum(asynUser *pasynUser, char *strings[], int values[], int severities[], size_t nElements, size_t *nIn){ - + printf("[DEBUG]::readEnum\t"); + const char* functionName = "readEnum"; + const char *paramName; + + int function = pasynUser->reason; + asynStatus status = asynSuccess; + + + getParamName(function, ¶mName); + + + double value = 0; + dcamprop_getvalue(m_hdcam, function, &value); + +// dcamprop_setvalue(m_hdcam, function, value); + + if (function == hSensorMode) { + printf("function Sensor Mode\n"); + } + else if (function == hReadoutDirection) { + printf("function Readout Direction\n"); + } + else if (function == hTriggerSource) { + printf("function Trigger Source\n"); + dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &value); + setIntegerParam(function, value); + + } + else if (function == hTriggerMode) { + printf("function Trigger Mode\n"); + } + else if (function == hTriggerActive) { + printf("function Trigger Active\n"); + } + else if (function == hTriggerGlobalExposure) { + printf("function Trigger Global Exposure\n"); + } + else if (function == hTriggerPolarity) { + printf("function Trigger Polarity\n"); + } + else if (function == hTriggerConnector) { + printf("function TriggerConnector\n"); + } + else if (function == hInternalTriggerHandling) { + printf("function Internal Trigger Handling\n"); + } + else if (function == hSensorCooler) { + printf("function Sensor Cooler\n"); + } + else if (function == hSensorCoolerStatus){ + printf("function Sensor Cooler Status\n"); + } + /////////////////////////////////////////////////////////////////// + else if (function == hColorType) { + printf("function Color Type\n"); + } + else if (function == hImagePixelType) { + printf("function Image Pixel Type\n"); + } + else if (function == hBufferPixelType) { + printf("function Buffer Pixel Type\n"); + } + else if (function == hSystemAlive) { + printf("function System Alive\n"); + } + else if (function == hTimeStampProducer) { + printf("function Time Stamp Producer\n"); + } + else if (function == hFrameStampProducer) { + printf("function Frame Stamp producer\n"); + } +// else if (function == ) { +// printf("function \n"); +// } +// else if (function == ) { +// printf("function \n"); +// } +// else if (function == ) { +// printf("function \n"); +// } + else { + printf("function ELSE....\n"); + } + *nIn = 0; + + status = (asynStatus) callParamCallbacks(); + + asynPrint(pasynUserSelf, ASYN_TRACEIO_DRIVER, + "%s:%s: entry, function=%d, string=%s\n", driverName, functionName, function, strings[0]); + return(asynSuccess); } - +*/ //============================================================================ void Hama::report(FILE *fp, int details){ + printf("[DEBUG]::report\n"); } //============================================================================ @@ -204,7 +690,7 @@ int Hama::disconnectCamera(void){ static const char *functionName = "disconnectCamera"; - int status; + int status = 0; if(m_hdcam == NULL) { @@ -260,7 +746,7 @@ void Hama::printError(HDCAM hdcam, DCAMERR errid, const char* apiname, const cha DCAMERR err; dcamdev_string( err, hdcam, errid, errtext, sizeof(errtext) ); - printf( "FAILED: (DCAMERR)0x%08X %s @ %s", errid, errtext, apiname ); + printf( "-[ERROR]- (DCAMERR) 0x%08X %s @ %s", errid, errtext, apiname ); if( fmt != NULL ) { printf( " : " ); diff --git a/ADHamaApp/src/hama.h b/ADHamaApp/src/hama.h index 1ac807e..4ec5681 100644 --- a/ADHamaApp/src/hama.h +++ b/ADHamaApp/src/hama.h @@ -6,58 +6,66 @@ -#define HamaName "Name" /* asynOctet ro */ -#define hFrameRateString "H_FRAME_RATE" /* asynOctet ro */ +#define hFrameRateString "H_FRAME_RATE" /* asynOctet ro */ +#define HamaName "Name" /* asynOctet ro */ +#define hVendorString "H_VENDOR" /* asynOctet ro */ +#define hModelString "H_MODEL" /* asynOctet ro */ +#define hCameraIDString "H_CAMERAID" /* asynOctet ro */ +#define hBusString "H_BUS" /* asynOctet ro */ +#define hCameraVersionString "H_CAMERA_VERSION" /* asynOctet ro */ +#define hDriverVersionString "H_DRIVER_VERSION" /* asynOctet ro */ +#define hModuleVersionString "H_MODULE_VERSION" /* asynOctet ro */ +#define hDcamApiVersionString "H_DCAM_API_VERSION" /* asynOctet ro */ // Sensor mode and speed -#define hSensorModeString "H_SENSOR_MODE" /* asynint32 rw */ -#define hReadoutSpeedString "H_READOUT_SPEED" /* asynInt32 rw */ -#define hReadoutDirectionString "H_READOUT_DIRECTION" /* asynInt32 rw */ +#define hSensorModeString "H_SENSOR_MODE" /* asynint32 rw */ +#define hReadoutSpeedString "H_READOUT_SPEED" /* asynInt32 rw */ +#define hReadoutDirectionString "H_READOUT_DIRECTION" /* asynIekt32 rw */ // Trigger -#define hTriggerSourceString "H_TRIGGER_SOURCE" /* asynInt32 rw */ -#define hTriggerModeString "H_TRIGGER_MODE" /* asynInt32 rw */ -#define hTriggerActiveString "H_TRIGGER_ACTIVE" /* asynInt32 rw */ -#define hTriggerGlobalExposureString "H_TRIGGER_GLOBAR_EXPOSURE" /* asynInt32 rw */ -#define hTriggerPolarityString "H_TRIGGER_POLARITY" /* asynInt32 rw */ -#define hTriggerConnectorString "H_TRIGGER_CONNECTOR" /* asynInt32 rw */ -#define hTriggerTimesString "H_TRIGGER_TIMES" /* asynInt32 rw */ -#define hTriggerDelayString "H_TRIGGER_DELAY" /* asynFloat64 rw */ -#define hInternalTriggerHandlingString "H_INTERNAL_TRIGGER_HANDLING" /* asynInt32 rw */ +#define hTriggerSourceString "H_TRIGGER_SOURCE" /* asynInt32 rw */ +#define hTriggerModeString "H_TRIGGER_MODE" /* asynInt32 rw */ +#define hTriggerActiveString "H_TRIGGER_ACTIVE" /* asynInt32 rw */ +#define hTriggerGlobalExposureString "H_TRIGGER_GLOBAL_EXPOSURE" /* asynInt32 rw */ +#define hTriggerPolarityString "H_TRIGGER_POLARITY" /* asynInt32 rw */ +#define hTriggerConnectorString "H_TRIGGER_CONNECTOR" /* asynInt32 rw */ +#define hTriggerTimesString "H_TRIGGER_TIMES" /* asynInt32 rw */ +#define hTriggerDelayString "H_TRIGGER_DELAY" /* asynFloat64 rw */ +#define hInternalTriggerHandlingString "H_INTERNAL_TRIGGER_HANDLING" /* asynInt32 rw */ // Sensor cooler #define hSensorTemperatureString "H_SENSOR_TEMPERATURE" /* asynFloat64 ro */ -#define hSensorCoolerString "H_SENSOR_COOLER" /* asynInt32 rw */ +#define hSensorCoolerString "H_SENSOR_COOLER" /* asynInt32 rw */ #define hSensorCoolerStatusString "H_SENSOR_COOLER_STATUS" /* asynInt32 ro */ // Binning and ROI -#define hBinningString "H_BINNING" /* asynInt32 rw */ -#define hSubarrayHPosString "H_SUBARRAY_HPOST" /* asynInt32 rw */ -#define hSubarrayHSizeString "H_SUBARRAY_HSIZE" /* asynInt32 rw */ -#define hSubarrayVPosString "H_SUBARRAY_VPOS" /* asynInt32 rw */ -#define hSubarrayVSizeString "H_SUBARRAY_VPOS" /* asynInt32 rw */ -#define hSubarrayModeString "H_SUBARRAY_MODE" /* asynInt32 rw */ +#define hBinningString "H_BINNING" /* asynInt32 rw */ +#define hSubarrayHPosString "H_SUBARRAY_HPOST" /* asynInt32 rw */ +#define hSubarrayHSizeString "H_SUBARRAY_HSIZE" /* asynInt32 rw */ +#define hSubarrayVPosString "H_SUBARRAY_VPOS" /* asynInt32 rw */ +#define hSubarrayVSizeString "H_SUBARRAY_VPOS" /* asynInt32 rw */ +#define hSubarrayModeString "H_SUBARRAY_MODE" /* asynInt32 rw */ // #define hFrameBundleMode (usb3 only not implemented) // #define hFrameBundleNumber (usb3 only not implemented) // Feature -#define hExposureTimeString "H_EXPOSURE_TIME" /* asynFloat64 rw */ +#define hExposureTimeString "H_EXPOSURE_TIME" /* asynFloat64 rw */ // ALU #define hDefectCorrectModeString "H_DEFECT_CORRECT_MODE" /* asynInt32 rw */ #define hHotPixelCorrectLevelString "H_HOT_PIXEL_CORRECT_LEVEL" /* asynInt32 rw */ #define hIntensityLutModeString "H_INTENSITY_LUT_MODE" /* asynInt32 rw */ #define hIntensityLutPageString "H_INTENSITY_LUT_PAGE" /* asynInt32 ro */ -#define hExtractionModeString "H_EXTRACTION_MODE" /* asynInt32 ro */ +#define hExtractionModeString "H_EXTRACTION_MODE" /* asynInt32 ro */ // output trigger -#define hNumberOfOutputTriggerConnectorsString "H_NUMBER_OUTPUT_TRIGGER_CONNECTORS" /* asynInt32 ro */ +#define hNumberOfOutputTriggerConnectorString "H_NUMBER_OUTPUT_TRIGGER_CONNECTOR" /* asynInt32 ro */ #define hOutputTriggerSource0String "H_OUTPUT_TRIGGER_SOURCE0" /* asynInt32 rw */ #define hOutputTriggerSource1String "H_OUTPUT_TRIGGER_SOURCE1" /* asynInt32 rw */ #define hOutputTriggerSource2String "H_OUTPUT_TRIGGER_SOURCE2" /* asynInt32 rw */ -#define hOutputTriggerPolarity0String "H_OUTPUT_TRIGGER_POLARITY0" /* asynInt32 rw */ -#define hOutputTriggerPolarity1String "H_OUTPUT_TRIGGER_POLARITY1" /* asynInt32 rw */ -#define hOutputTriggerPolarity2String "H_OUTPUT_TRIGGER_POLARITY2" /* asynInt32 rw */ +#define hOutputTriggerPolarity0String "H_OUTPUT_TRIGGER_POLARITY0" /* asynInt32 rw */ +#define hOutputTriggerPolarity1String "H_OUTPUT_TRIGGER_POLARITY1" /* asynInt32 rw */ +#define hOutputTriggerPolarity2String "H_OUTPUT_TRIGGER_POLARITY2" /* asynInt32 rw */ #define hOutputTriggerActive0String "H_OUTPUT_TRIGGER_ACTIVE0" /* asynInt32 ro */ #define hOutputTriggerActive1String "H_OUTPUT_TRIGGER_ACTIVE1" /* asynInt32 ro */ #define hOutputTriggerActive2String "H_OUTPUT_TRIGGER_ACTIVE2" /* asynInt32 ro */ @@ -70,56 +78,54 @@ #define hOutputTriggerKind0String "H_OUTPUT_TRIGGER_KIND0" /* asynInt32 rw */ #define hOutputTriggerKind1String "H_OUTPUT_TRIGGER_KIND1" /* asynInt32 rw */ #define hOutputTriggerKind2String "H_OUTPUT_TRIGGER_KIND2" /* asynInt32 rw */ -#define hOutputTriggerBaseSensor0String "H_OUTPUT_TRIGGER_BASE_SENSOR0" /* asynInt32 rw */ -#define hOutputTriggerBaseSensor1String "H_OUTPUT_TRIGGER_BASE_SENSOR1" /* asynInt32 rw */ -#define hOutputTriggerBaseSensor2String "H_OUTPUT_TRIGGER_BASE_SENSOR2" /* asynInt32 rw */ -#define hOutTriggerPreHsyncCountString "H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT" /* asynInt32 rw */ +#define hOutputTriggerBaseSensor0String "H_OUTPUT_TRIGGER_BASE_SENSOR0" /* asynInt32 rw */ +#define hOutputTriggerBaseSensor1String "H_OUTPUT_TRIGGER_BASE_SENSOR1" /* asynInt32 rw */ +#define hOutputTriggerBaseSensor2String "H_OUTPUT_TRIGGER_BASE_SENSOR2" /* asynInt32 rw */ +#define hOutTriggerPreHsyncCountString "H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT" /* asynInt32 rw */ // Master Puls #define hMasterPulseModeString "H_MASTERPULSE_MODE" /* asynInt32 rw */ -#define hMasterPulseTriggerSourceString "H_MASTERPULSE_TRIGGER_SOURCE" /* asynInt32 rw */ +#define hMasterPulseTriggerSourceString "H_MASTERPULSE_TRIGGER_SOURCE" /* asynInt32 rw */ #define hMasterPulseIntervalString "H_MASTERPULSE_INTERVAL" /* asynFloat64 rw */ -#define hMasterPulseBurstTimesString "H_MASTERPULSE_BURST_TIMES" /* asynInt32 rw */ +#define hMasterPulseBurstTimesString "H_MASTERPULSE_BURST_TIMES" /* asynInt32 rw */ // Synchronious Timing #define hTimingReadoutTimeString "H_TIMING_READOUT_TIME" /* asynFloat64 ro */ -#define hTimingCyclicTriggerPeriodString "H_TIMING_CYCLIC_TRIGGER_PERIOD" /* asynFloat64 ro */ -#define hTimingMinTriggerBlankingString "H_TIMING_MIN_TRIGGER_BLANKING" /* asynFloat64 ro */ -#define hTimingMinTriggerIntervalString "H_TIMING_MIN_TRIGGER_INTERVAL" /* asynFloat64 ro */ -#define hTimingGlobalExposureDelayString "H_TIMING_GLOBAL_EXPOSURE_DELAY" /* asynFloat64 ro */ +#define hTimingCyclicTriggerPeriodString "H_TIMING_CYCLIC_TRIGGER_PERIOD" /* asynFloat64 ro */ +#define hTimingMinTriggerBlankingString "H_TIMING_MIN_TRIGGER_BLANKING" /* asynFloat64 ro */ +#define hTimingMinTriggerIntervalString "H_TIMING_MIN_TRIGGER_INTERVAL" /* asynFloat64 ro */ +#define hTimingGlobalExposureDelayString "H_TIMING_GLOBAL_EXPOSURE_DELAY" /* asynFloat64 ro */ #define hTimingExposureString "H_TIMING_EXPOSURE" /* asynInt32 ro */ #define hTimingInvalidExposurePeriodString "H_TIMING_INVALID_EXPOSURE_PERIOD" /* asynFloat64 ro */ -#define hInternalFrameRateString "H_INTERNAL_FRAME_RATE" /* asynFloat64 rw */ -#define hInternalFrameIntervalString "H_INTERNAL_FRAME_INTERVAL" /* asynFloat64 rw */ -#define hInternalLineSpeedString "H_INTERNAL_LINE_SPEED" /* asynFloat64 rw */ -#define hInternalLineIntervalString "H_INTERNAL_LINE_INTERVAL" /* asynFloat64 rw */ +#define hInternalFrameRateString "H_INTERNAL_FRAME_RATE" /* asynFloat64 rw */ +#define hInternalFrameIntervalString "H_INTERNAL_FRAME_INTERVAL" /* asynFloat64 rw */ +#define hInternalLineSpeedString "H_INTERNAL_LINE_SPEED" /* asynFloat64 rw */ +#define hInternalLineIntervalString "H_INTERNAL_LINE_INTERVAL" /* asynFloat64 rw */ // System information -#define hColorTypeString "H_COLOR_TYPE" /* asynInt32 ro */ -#define hBitPerChannelString "H_BIT_PER_CHANNEL" /* asynInt32 rw */ -#define hImageWidthString "H_IMAGE_WIDTH" /* asynInt32 ro */ -#define hImageHeightString "H_IMAGE_HEIGHT" /* asynInt32 ro */ +#define hColorTypeString "H_COLOR_TYPE" /* asynInt32 ro */ +#define hBitPerChannelString "H_BIT_PER_CHANNEL" /* asynInt32 rw */ +#define hImageWidthString "H_IMAGE_WIDTH" /* asynInt32 ro */ +#define hImageHeightString "H_IMAGE_HEIGHT" /* asynInt32 ro */ #define hImageRowBytesString "H_IMAGE_ROWBYTES" /* asynInt32 ro */ -#define hImageFrameBytesString "H_IMAGE_FRAMEBYTES" /* asynInt32 ro */ -#define hImageTopOffsetBytesString "H_IMAGE_TOP_OFFSETBYTES" /* asynInt32 ro */ -#define hImagePixelTypeString "H_IMAGE_PIXEL_TYPE" /* asynInt32 rw */ +#define hImageFrameBytesString "H_IMAGE_FRAMEBYTES" /* asynInt32 ro */ +#define hImageTopOffsetBytesString "H_IMAGE_TOP_OFFSETBYTES" /* asynInt32 ro */ +#define hImagePixelTypeString "H_IMAGE_PIXEL_TYPE" /* asynInt32 rw */ #define hBufferRowbytesString "H_BUFFER_ROWBYTES" /* asynInt32 ro */ -#define hBufferFramebytesString "H_BUFFER_FRAMEBYTES" /* asynInt32 ro */ -#define hBufferTopOffsetBytesString "H_BUFFER_TOP_OFFSETBYTES" /* asynInt32 ro */ -#define hBufferPixelTypeString "H_BUFFER_PIXEL_TYPE" /* asynInt32 ro */ -#define hRecordFixedBytesPerFileString "H_RECORD_FIXED_BYTES_PER_FILE" /* asynInt32 ro */ +#define hBufferFramebytesString "H_BUFFER_FRAMEBYTES" /* asynInt32 ro */ +#define hBufferTopOffsetBytesString "H_BUFFER_TOP_OFFSETBYTES" /* asynInt32 ro */ +#define hBufferPixelTypeString "H_BUFFER_PIXEL_TYPE" /* asynInt32 ro */ +#define hRecordFixedBytesPerFileString "H_RECORD_FIXED_BYTES_PER_FILE" /* asynInt32 ro */ #define hRecordFixedBytesPerSessionString "H_RECORD_FIXED_BYTES_PER_SESION" /* asynInt32 ro */ -#define hRecordFixedBytesPerFrameString "H_RECORD_FIXED_BYTES_PER_FRAME" /* asynInt32 ro */ -#define hSystemAliveString "H_SYSTEM_ALIVE" /* asynInt32 ro */ -#define hConversionFactorCoeffString "H_CONVERSION_FACTOR_COEF" /* asynFloat64 ro */ -#define hConversionFactorOffsetString "H_CONVERSION_FACTOR_OFFSET" /* asynFloat64 ro */ -#define hNumberOfViewString "H_NUMBER_OF_VIEW" /* asynInt32 ro */ -#define hImageDetectorPixelWidthString "H_IMAGE_DETECTOR_PIXEL_WIDTH" /* asynFloat64 ro */ -#define hImageDetectorPixelHeightString "H_IMAGE_DETECTOR_PIXEL_HEIGHT" /* asynFloat64 ro */ -#define hImageDetectorPixelNumHorzString "H_IMAGE_DETECTOR_PIXEL_NUM_HORZ" /* asynInt32 ro */ -#define hImageDetectorPixelNumVertString "H_IMAGE_DETECTOR_PIXEL_NUM_VERT" /* asynInt32 ro */ -#define hTimeStampProducerString "H_TIMESTAMP_PRODUCER" /* asynInt32 ro */ -#define hFrameStampProducerString "H_FRAMESTAMP_PRODUCER" /* asynInt32 ro */ +#define hRecordFixedBytesPerFrameString "H_RECORD_FIXED_BYTES_PER_FRAME" /* asynInt32 ro */ +#define hSystemAliveString "H_SYSTEM_ALIVE" /* asynInt32 ro */ +#define hConversionFactorCoeffString "H_CONVERSION_FACTOR_COEF" /* asynFloat64 ro */ +#define hConversionFactorOffsetString "H_CONVERSION_FACTOR_OFFSET"/* asynFloat64 ro */ +#define hNumberOfViewString "H_NUMBER_OF_VIEW" /* asynInt32 ro */ +#define hImageDetectorPixelWidthString "H_IMAGE_DETECTOR_PIXEL_WIDTH" /* asynFloat64 ro */ +#define hImageDetectorPixelHeightString "H_IMAGE_DETECTOR_PIXEL_HEIGHT" /* asynFloat64 ro */ +#define hImageDetectorPixelNumHorzString "H_IMAGE_DETECTOR_PIXEL_NUM_HORZ" /* asynInt32 ro */ +#define hImageDetectorPixelNumVertString "H_IMAGE_DETECTOR_PIXEL_NUM_VERT" /* asynInt32 ro */ @@ -128,18 +134,26 @@ class Hama : public ADDriver { public: Hama(const char*, int, int, size_t, int, int, int); - ~Hama(); +// ~Hama(); /* override ADDriver methods */ virtual asynStatus writeInt32(asynUser *pasynUser, epicsInt32 value); virtual asynStatus writeFloat64(asynUser *pasynUser, epicsFloat64 value); - virtual asynStatus readEnum(asynUser *pasynUser, char *strings[], int values[], - int severities[], size_t nElements, size_t *nIn); + //virtual asynStatus readEnum(asynUser *pasynUser, char *strings[], int values[], + // int severities[], size_t nElements, size_t *nIn); virtual void report(FILE *fp, int details); protected: int hFrameRate; #define FIRST_HAMA_PARAM hFrameRate int hHamaName; + int hVendor; + int hModel; + int hCameraID; + int hBus; + int hCameraVersion; + int hDriverVersion; + int hModuleVersion; + int hDcamApiVersion; int hSensorMode; int hReadoutSpeed; int hReadoutDirection; @@ -193,7 +207,7 @@ protected: int hRecordFixedBytesPerFile; int hRecordFixedBytesPerSession; int hRecordFixedBytesPerFrame; - int hNumberOfOutputTriggerConnectors; + int hNumberOfOutputTriggerConnector; int hOutputTriggerSource0; int hOutputTriggerSource1; int hOutputTriggerSource2; @@ -218,7 +232,7 @@ protected: int hOutTriggerPreHsyncCount; int hMasterPulseMode; int hMasterPulseTriggerSource; - int hMAsterPulseInterval; + int hMasterPulseInterval; int hMasterPulseBurstTimes; int hSystemAlive; int hConversionFactorCoeff; @@ -255,6 +269,8 @@ private: int dcamdev_string( DCAMERR& err, HDCAM hdcam, int32 idStr, char* text, int32 textbytes ); int setParameter(int paramIndex); int getParameter(int paramIndex); + int getParameterStr(int paramIndex); + int getProperties(); }; #endif diff --git a/cmds/st.cmd b/cmds/st.cmd index 278061c..0c25018 100644 --- a/cmds/st.cmd +++ b/cmds/st.cmd @@ -13,8 +13,14 @@ epicsEnvSet("NCHANS", "2048") # iocshLoad("$(adhama_DIR)ADHama.iocsh") devHamamatsuConfig("$(PORT)", $(CAMERA), 0, 0, 0, 0, 10) + dbLoadRecords("$(adhama_DIR)db/hama.db","P=$(PREFIX),R=cam1:,PORT=$(PORT),ADDR=0,TIMEOUT=1") +asynSetTraceMask("$(PORT)",-1,0x9) +asynSetTraceIOMask("$(PORT)",-1,0x2) + + iocInit() +dbpf Hama:cam1:PoolUsedMem.SCAN 0 # end-of-line required diff --git a/support/dcamsdk4/inc/dcamapi4.h b/support/dcamsdk4/inc/dcamapi4.h new file mode 100644 index 0000000..a4919b0 --- /dev/null +++ b/support/dcamsdk4/inc/dcamapi4.h @@ -0,0 +1,1136 @@ +/* **************************************************************** * + + dcamapi4.h: Jun 18, 2021 + + Copyright (C) 2011 - 2021 Hamamatsu Photonics K.K.. All right reserved. + + * **************************************************************** */ + +#ifndef _INCLUDE_DCAMAPI4_H_ + +#pragma pack(8) + +#ifndef DCAMAPI_VER +#define DCAMAPI_VER 4000 +#endif + +/* **************************************************************** * + + language absorber + + * **************************************************************** */ + +#ifdef __cplusplus + +/* C++ */ + +#define DCAM_DECLARE_BEGIN( kind, tag ) kind tag +#define DCAM_DECLARE_END( tag ) ; + +#define DCAM_DEFAULT_ARG = 0 +#define DCAMINIT_DEFAULT_ARG = DCAMINIT_DEFAULT + +extern "C" { + +#else + +/* C */ + +#define DCAM_DECLARE_BEGIN( kind, tag ) typedef kind +#define DCAM_DECLARE_END( tag ) tag; + +#define DCAM_DEFAULT_ARG +#define DCAMINIT_DEFAULT_ARG + +#endif + +/* **************************************************************** * + + defines + + * **************************************************************** */ + +/* define - HDCAM */ + +typedef struct tag_dcam* HDCAM; + +/* define - DCAMAPI */ + +#ifndef DCAMAPI +#ifdef PASCAL +#define DCAMAPI PASCAL /* DCAM-API based on PASCAL calling */ +#else +#define DCAMAPI +#endif +#endif /* DCAMAPI */ + +/* define - int32 & _ui32 */ + +#if defined(_WIN32) || defined(WIN32) || defined(_INC_WINDOWS) +typedef long int32; +typedef unsigned long _ui32; +#else +typedef int int32; +typedef unsigned int _ui32; +#endif + +/* **************************************************************** * + + constant declaration + + * **************************************************************** */ + +/*** --- values --- ***/ + +#define DCAMCONST_FRAMESTAMP_MISMATCH 0xFFFFFFFF + +/*** --- errors --- ***/ + +DCAM_DECLARE_BEGIN( enum, DCAMERR ) +{ + /* status error */ + DCAMERR_BUSY = 0x80000101,/* API cannot process in busy state. */ + DCAMERR_NOTREADY = 0x80000103,/* API requires ready state. */ + DCAMERR_NOTSTABLE = 0x80000104,/* API requires stable or unstable state. */ + DCAMERR_UNSTABLE = 0x80000105,/* API does not support in unstable state. */ + DCAMERR_NOTBUSY = 0x80000107,/* API requires busy state. */ + + DCAMERR_EXCLUDED = 0x80000110,/* some resource is exclusive and already used */ + + DCAMERR_COOLINGTROUBLE = 0x80000302,/* something happens near cooler */ + DCAMERR_NOTRIGGER = 0x80000303,/* no trigger when necessary. Some camera supports this error. */ + DCAMERR_TEMPERATURE_TROUBLE = 0x80000304,/* camera warns its temperature */ + DCAMERR_TOOFREQUENTTRIGGER = 0x80000305,/* input too frequent trigger. Some camera supports this error. */ + + /* wait error */ + DCAMERR_ABORT = 0x80000102,/* abort process */ + DCAMERR_TIMEOUT = 0x80000106,/* timeout */ + DCAMERR_LOSTFRAME = 0x80000301,/* frame data is lost */ + DCAMERR_MISSINGFRAME_TROUBLE= 0x80000f06,/* frame is lost but reason is low lever driver's bug */ + DCAMERR_INVALIDIMAGE = 0x80000321,/* hpk format data is invalid data */ + + /* initialization error */ + DCAMERR_NORESOURCE = 0x80000201,/* not enough resource except memory */ + DCAMERR_NOMEMORY = 0x80000203,/* not enough memory */ + DCAMERR_NOMODULE = 0x80000204,/* no sub module */ + DCAMERR_NODRIVER = 0x80000205,/* no driver */ + DCAMERR_NOCAMERA = 0x80000206,/* no camera */ + DCAMERR_NOGRABBER = 0x80000207,/* no grabber */ + DCAMERR_NOCOMBINATION = 0x80000208,/* no combination on registry */ + + DCAMERR_FAILOPEN = 0x80001001,/* DEPRECATED */ + DCAMERR_FRAMEGRABBER_NEEDS_FIRMWAREUPDATE = 0x80001002,/* need to update frame grabber firmware to use the camera */ + DCAMERR_INVALIDMODULE = 0x80000211,/* dcam_init() found invalid module */ + DCAMERR_INVALIDCOMMPORT = 0x80000212,/* invalid serial port */ + DCAMERR_FAILOPENBUS = 0x81001001,/* the bus or driver are not available */ + DCAMERR_FAILOPENCAMERA = 0x82001001,/* camera report error during opening */ + DCAMERR_DEVICEPROBLEM = 0x82001002,/* initialization failed(for maico) */ + + /* calling error */ + DCAMERR_INVALIDCAMERA = 0x80000806,/* invalid camera */ + DCAMERR_INVALIDHANDLE = 0x80000807,/* invalid camera handle */ + DCAMERR_INVALIDPARAM = 0x80000808,/* invalid parameter */ + DCAMERR_INVALIDVALUE = 0x80000821,/* invalid property value */ + DCAMERR_OUTOFRANGE = 0x80000822,/* value is out of range */ + DCAMERR_NOTWRITABLE = 0x80000823,/* the property is not writable */ + DCAMERR_NOTREADABLE = 0x80000824,/* the property is not readable */ + DCAMERR_INVALIDPROPERTYID = 0x80000825,/* the property id is invalid */ + DCAMERR_NEWAPIREQUIRED = 0x80000826,/* old API cannot present the value because only new API need to be used */ + DCAMERR_WRONGHANDSHAKE = 0x80000827,/* this error happens DCAM get error code from camera unexpectedly */ + DCAMERR_NOPROPERTY = 0x80000828,/* there is no altenative or influence id, or no more property id */ + DCAMERR_INVALIDCHANNEL = 0x80000829,/* the property id specifies channel but channel is invalid */ + DCAMERR_INVALIDVIEW = 0x8000082a,/* the property id specifies channel but channel is invalid */ + DCAMERR_INVALIDSUBARRAY = 0x8000082b,/* the combination of subarray values are invalid. e.g. DCAM_IDPROP_SUBARRAYHPOS + DCAM_IDPROP_SUBARRAYHSIZE is greater than the number of horizontal pixel of sensor. */ + DCAMERR_ACCESSDENY = 0x8000082c,/* the property cannot access during this DCAM STATUS */ + DCAMERR_NOVALUETEXT = 0x8000082d,/* the property does not have value text */ + DCAMERR_WRONGPROPERTYVALUE = 0x8000082e,/* at least one property value is wrong */ + DCAMERR_DISHARMONY = 0x80000830,/* the paired camera does not have same parameter */ + DCAMERR_FRAMEBUNDLESHOULDBEOFF=0x80000832,/* framebundle mode should be OFF under current property settings */ + DCAMERR_INVALIDFRAMEINDEX = 0x80000833,/* the frame index is invalid */ + DCAMERR_INVALIDSESSIONINDEX = 0x80000834,/* the session index is invalid */ + DCAMERR_NOCORRECTIONDATA = 0x80000838,/* not take the dark and shading correction data yet. */ + DCAMERR_CHANNELDEPENDENTVALUE= 0x80000839,/* each channel has own property value so can't return overall property value. */ + DCAMERR_VIEWDEPENDENTVALUE = 0x8000083a,/* each view has own property value so can't return overall property value. */ + DCAMERR_NODEVICEBUFFER = 0x8000083b,/* the frame count is larger than device momory size on using device memory. */ + DCAMERR_REQUIREDSNAP = 0x8000083c,/* the capture mode is sequence on using device memory. */ + DCAMERR_LESSSYSTEMMEMORY = 0x8000083f,/* the sysmte memory size is too small. PC doesn't have enough memory or is limited memory by 32bit OS. */ + + DCAMERR_NOTSUPPORT = 0x80000f03,/* camera does not support the function or property with current settings */ + + /* camera or bus trouble */ + DCAMERR_FAILREADCAMERA = 0x83001002,/* failed to read data from camera */ + DCAMERR_FAILWRITECAMERA = 0x83001003,/* failed to write data to the camera */ + DCAMERR_CONFLICTCOMMPORT = 0x83001004,/* conflict the com port name user set */ + DCAMERR_OPTICS_UNPLUGGED = 0x83001005,/* Optics part is unplugged so please check it. */ + DCAMERR_FAILCALIBRATION = 0x83001006,/* fail calibration */ + + DCAMERR_MISMATCH_CONFIGURATION= 0x83001011,/* mismatch between camera output(connection) and frame grabber specs */ + + /* 0x84000100 - 0x840001FF, DCAMERR_INVALIDMEMBER_x */ + DCAMERR_INVALIDMEMBER_3 = 0x84000103,/* 3th member variable is invalid value */ + DCAMERR_INVALIDMEMBER_5 = 0x84000105,/* 5th member variable is invalid value */ + DCAMERR_INVALIDMEMBER_7 = 0x84000107,/* 7th member variable is invalid value */ + DCAMERR_INVALIDMEMBER_8 = 0x84000108,/* 7th member variable is invalid value */ + DCAMERR_INVALIDMEMBER_9 = 0x84000109,/* 9th member variable is invalid value */ + DCAMERR_FAILEDOPENRECFILE = 0x84001001,/* DCAMREC failed to open the file */ + DCAMERR_INVALIDRECHANDLE = 0x84001002,/* DCAMREC is invalid handle */ + DCAMERR_FAILEDWRITEDATA = 0x84001003,/* DCAMREC failed to write the data */ + DCAMERR_FAILEDREADDATA = 0x84001004,/* DCAMREC failed to read the data */ + DCAMERR_NOWRECORDING = 0x84001005,/* DCAMREC is recording data now */ + DCAMERR_WRITEFULL = 0x84001006,/* DCAMREC writes full frame of the session */ + DCAMERR_ALREADYOCCUPIED = 0x84001007,/* DCAMREC handle is already occupied by other HDCAM */ + DCAMERR_TOOLARGEUSERDATASIZE= 0x84001008,/* DCAMREC is set the large value to user data size */ + DCAMERR_INVALIDWAITHANDLE = 0x84002001,/* DCAMWAIT is invalid handle */ + DCAMERR_NEWRUNTIMEREQUIRED = 0x84002002,/* DCAM Module Version is older than the version that the camera requests */ + DCAMERR_VERSIONMISMATCH = 0x84002003,/* Camre returns the error on setting parameter to limit version */ + DCAMERR_RUNAS_FACTORYMODE = 0x84002004,/* Camera is running as a factory mode */ + DCAMERR_IMAGE_UNKNOWNSIGNATURE = 0x84003001,/* sigunature of image header is unknown or corrupted */ + DCAMERR_IMAGE_NEWRUNTIMEREQUIRED= 0x84003002,/* version of image header is newer than version that used DCAM supports */ + DCAMERR_IMAGE_ERRORSTATUSEXIST = 0x84003003,/* image header stands error status */ + DCAMERR_IMAGE_HEADERCORRUPTED = 0x84004004,/* image header value is strange */ + DCAMERR_IMAGE_BROKENCONTENT = 0x84004005,/* image content is corrupted */ + + /* calling error for DCAM-API 2.1.3 */ + DCAMERR_UNKNOWNMSGID = 0x80000801,/* unknown message id */ + DCAMERR_UNKNOWNSTRID = 0x80000802,/* unknown string id */ + DCAMERR_UNKNOWNPARAMID = 0x80000803,/* unkown parameter id */ + DCAMERR_UNKNOWNBITSTYPE = 0x80000804,/* unknown bitmap bits type */ + DCAMERR_UNKNOWNDATATYPE = 0x80000805,/* unknown frame data type */ + + /* internal error */ + DCAMERR_NONE = 0, /* no error, nothing to have done */ + DCAMERR_INSTALLATIONINPROGRESS=0x80000f00,/* installation progress */ + DCAMERR_UNREACH = 0x80000f01,/* internal error */ + DCAMERR_UNLOADED = 0x80000f04,/* calling after process terminated */ + DCAMERR_THRUADAPTER = 0x80000f05,/* */ + DCAMERR_NOCONNECTION = 0x80000f07,/* HDCAM lost connection to camera */ + + DCAMERR_NOTIMPLEMENT = 0x80000f02,/* not yet implementation */ + + DCAMERR_DELAYEDFRAME = 0x80000f09,/* the frame waiting re-load from hardware buffer with SNAPSHOT of DEVICEBUFFER MODE */ + + DCAMERR_DEVICEINITIALIZING = 0xb0000001, + + DCAMERR_APIINIT_INITOPTIONBYTES = 0xa4010003,/* DCAMAPI_INIT::initoptionbytes is invalid */ + DCAMERR_APIINIT_INITOPTION = 0xa4010004,/* DCAMAPI_INIT::initoption is invalid */ + + DCAMERR_INITOPTION_COLLISION_BASE=0xa401C000, + DCAMERR_INITOPTION_COLLISION_MAX= 0xa401FFFF, + + /* Between DCAMERR_INITOPTION_COLLISION_BASE and DCAMERR_INITOPTION_COLLISION_MAX means there is collision with initoption in DCAMAPI_INIT. */ + /* The value "(error code) - DCAMERR_INITOPTION_COLLISION_BASE" indicates the index which second INITOPTION group happens. */ + + DCAMERR_MISSPROP_TRIGGERSOURCE = 0xE0100110,/* the trigger mode is internal or syncreadout on using device memory. */ + + /* success */ + DCAMERR_SUCCESS = 1 /* no error, general success code, app should check the value is positive */ +} +DCAM_DECLARE_END( DCAMERR ) + +DCAM_DECLARE_BEGIN( enum, DCAMBUF_FRAME_OPTION ) +{ + DCAMBUF_FRAME_OPTION__VIEW_ALL = 0x00000000, + DCAMBUF_FRAME_OPTION__VIEW_1 = 0x00100000, + DCAMBUF_FRAME_OPTION__VIEW_2 = 0x00200000, + DCAMBUF_FRAME_OPTION__VIEW_3 = 0x00300000, + DCAMBUF_FRAME_OPTION__VIEW_4 = 0x00400000, + + DCAMBUF_FRAME_OPTION__PROC_HIGHCONTRAST = 0x00000010, + + DCAMBUF_FRAME_OPTION__VIEW__STEP = 0x00100000, + DCAMBUF_FRAME_OPTION__VIEW__MASK = 0x00F00000, + DCAMBUF_FRAME_OPTION__PROC__MASK = 0x00000FF0, + + end_of_dcambuf_frame_option +} +DCAM_DECLARE_END( DCAMBUF_FRAME_OPTION ) + +DCAM_DECLARE_BEGIN( enum, DCAMREC_FRAME_OPTION ) +{ + DCAMREC_FRAME_OPTION__VIEW_CURRENT = 0x00000000, + DCAMREC_FRAME_OPTION__VIEW_1 = 0x00100000, + DCAMREC_FRAME_OPTION__VIEW_2 = 0x00200000, + DCAMREC_FRAME_OPTION__VIEW_3 = 0x00300000, + DCAMREC_FRAME_OPTION__VIEW_4 = 0x00400000, + + DCAMREC_FRAME_OPTION__PROC_HIGHCONTRAST = 0x00000010, + + DCAMREC_FRAME_OPTION__VIEW__STEP = 0x00100000, + DCAMREC_FRAME_OPTION__VIEW__MASK = 0x00F00000, + DCAMREC_FRAME_OPTION__PROC__MASK = 0x00000FF0, + + endof_dcamrec_frame_option +} +DCAM_DECLARE_END( DCAMREC_FRAME_OPTION ) + +DCAM_DECLARE_BEGIN( enum, DCAMBUF_METADATAOPTION ) +{ + DCAMBUF_METADATAOPTION__VIEW_ALL = DCAMBUF_FRAME_OPTION__VIEW_ALL, + DCAMBUF_METADATAOPTION__VIEW_1 = DCAMBUF_FRAME_OPTION__VIEW_1, + DCAMBUF_METADATAOPTION__VIEW_2 = DCAMBUF_FRAME_OPTION__VIEW_2, + DCAMBUF_METADATAOPTION__VIEW_3 = DCAMBUF_FRAME_OPTION__VIEW_3, + DCAMBUF_METADATAOPTION__VIEW_4 = DCAMBUF_FRAME_OPTION__VIEW_4, + DCAMBUF_METADATAOPTION__VIEW__STEP = DCAMBUF_FRAME_OPTION__VIEW__STEP, + DCAMBUF_METADATAOPTION__VIEW__MASK = DCAMBUF_FRAME_OPTION__VIEW__MASK +} +DCAM_DECLARE_END( DCAMBUF_METADATAOPTION ) + +DCAM_DECLARE_BEGIN( enum, DCAMREC_METADATAOPTION ) +{ + DCAMREC_METADATAOPTION__LOCATION_FRAME = 0x00000000, + DCAMREC_METADATAOPTION__LOCATION_FILE = 0x01000000, + DCAMREC_METADATAOPTION__LOCATION_SESSION= 0x02000000, + DCAMREC_METADATAOPTION__LOCATION__MASK = 0xFF000000 +} +DCAM_DECLARE_END( DCAMREC_METADATAOPTION ) + +DCAM_DECLARE_BEGIN( enum, DCAM_PIXELTYPE ) +{ + DCAM_PIXELTYPE_MONO8 = 0x00000001, + DCAM_PIXELTYPE_MONO16 = 0x00000002, + DCAM_PIXELTYPE_MONO12 = 0x00000003, + DCAM_PIXELTYPE_MONO12P = 0x00000005, + + DCAM_PIXELTYPE_RGB24 = 0x00000021, + DCAM_PIXELTYPE_RGB48 = 0x00000022, + DCAM_PIXELTYPE_BGR24 = 0x00000029, + DCAM_PIXELTYPE_BGR48 = 0x0000002a, + + DCAM_PIXELTYPE_NONE = 0x00000000 +} +DCAM_DECLARE_END( DCAM_PIXELTYPE ) + +DCAM_DECLARE_BEGIN( enum, DCAMBUF_ATTACHKIND ) +{ + DCAMBUF_ATTACHKIND_TIMESTAMP = 1, + DCAMBUF_ATTACHKIND_FRAMESTAMP = 2, + + DCAMBUF_ATTACHKIND_PRIMARY_TIMESTAMP = 3, + DCAMBUF_ATTACHKIND_PRIMARY_FRAMESTAMP = 4, + + DCAMBUF_ATTACHKIND_FRAME = 0 +} +DCAM_DECLARE_END( DCAM_ATTACHKIND ) + +DCAM_DECLARE_BEGIN( enum, DCAMCAP_TRANSFERKIND ) +{ + DCAMCAP_TRANSFERKIND_FRAME = 0 +} +DCAM_DECLARE_END( DCAMCAP_TRANSFERKIND ) + +/*** --- status --- ***/ +DCAM_DECLARE_BEGIN( enum, DCAMCAP_STATUS ) +{ + DCAMCAP_STATUS_ERROR = 0x0000, + DCAMCAP_STATUS_BUSY = 0x0001, + DCAMCAP_STATUS_READY = 0x0002, + DCAMCAP_STATUS_STABLE = 0x0003, + DCAMCAP_STATUS_UNSTABLE = 0x0004, + + end_of_dcamcap_status +} +DCAM_DECLARE_END( DCAMCAP_STATUS ) + +DCAM_DECLARE_BEGIN( enum, DCAMWAIT_EVENT ) +{ + DCAMWAIT_CAPEVENT_TRANSFERRED = 0x0001, + DCAMWAIT_CAPEVENT_FRAMEREADY = 0x0002, /* all modules support */ + DCAMWAIT_CAPEVENT_CYCLEEND = 0x0004, /* all modules support */ + DCAMWAIT_CAPEVENT_EXPOSUREEND = 0x0008, + DCAMWAIT_CAPEVENT_STOPPED = 0x0010, + DCAMWAIT_CAPEVENT_RELOADFRAME = 0x0020, + + DCAMWAIT_RECEVENT_STOPPED = 0x0100, + DCAMWAIT_RECEVENT_WARNING = 0x0200, + DCAMWAIT_RECEVENT_MISSED = 0x0400, + DCAMWAIT_RECEVENT_DISKFULL = 0x1000, + DCAMWAIT_RECEVENT_WRITEFAULT = 0x2000, + DCAMWAIT_RECEVENT_SKIPPED = 0x4000, + DCAMWAIT_RECEVENT_WRITEFRAME = 0x8000, /* DCAMCAP_START_BUFRECORD only */ + + end_of_dcamwait_event +} +DCAM_DECLARE_END( DCAMWAIT_EVENT ) + +/*** --- dcamcap_start --- ***/ +DCAM_DECLARE_BEGIN( enum, DCAMCAP_START ) +{ + DCAMCAP_START_SEQUENCE = -1, + DCAMCAP_START_SNAP = 0 +} +DCAM_DECLARE_END( DCAMCAP_START ) + +/*** --- string id --- ***/ +DCAM_DECLARE_BEGIN( enum, DCAM_IDSTR ) +{ + + DCAM_IDSTR_BUS = 0x04000101, + DCAM_IDSTR_CAMERAID = 0x04000102, + DCAM_IDSTR_VENDOR = 0x04000103, + DCAM_IDSTR_MODEL = 0x04000104, + DCAM_IDSTR_CAMERAVERSION = 0x04000105, + DCAM_IDSTR_DRIVERVERSION = 0x04000106, + DCAM_IDSTR_MODULEVERSION = 0x04000107, + DCAM_IDSTR_DCAMAPIVERSION = 0x04000108, + DCAM_IDSTR_SUBUNIT_INFO1 = 0x04000110, + DCAM_IDSTR_SUBUNIT_INFO2 = 0x04000111, + DCAM_IDSTR_SUBUNIT_INFO3 = 0x04000112, + DCAM_IDSTR_SUBUNIT_INFO4 = 0x04000113, + + DCAM_IDSTR_CAMERA_SERIESNAME = 0x0400012c, + + DCAM_IDSTR_OPTICALBLOCK_MODEL = 0x04001101, + DCAM_IDSTR_OPTICALBLOCK_ID = 0x04001102, + DCAM_IDSTR_OPTICALBLOCK_DESCRIPTION = 0x04001103, + DCAM_IDSTR_OPTICALBLOCK_CHANNEL_1 = 0x04001104, + DCAM_IDSTR_OPTICALBLOCK_CHANNEL_2 = 0x04001105 +} +DCAM_DECLARE_END( DCAM_IDSTR ) + +/*** --- wait timeout --- ***/ +DCAM_DECLARE_BEGIN( enum, DCAMWAIT_TIMEOUT ) +{ + DCAMWAIT_TIMEOUT_INFINITE = 0x80000000, + + end_of_dcamwait_timeout +} +DCAM_DECLARE_END( DCAMWAIT_TIMEOUT ) + +#if DCAMAPI_VER >= 4000 + +/*** --- initialize parameter --- ***/ +DCAM_DECLARE_BEGIN( enum, DCAMAPI_INITOPTION ) +{ + DCAMAPI_INITOPTION_APIVER__LATEST = 0x00000001, + DCAMAPI_INITOPTION_APIVER__4_0 = 0x00000400, + DCAMAPI_INITOPTION_MULTIVIEW__DISABLE = 0x00010002, + DCAMAPI_INITOPTION_ENDMARK = 0x00000000 +} +DCAM_DECLARE_END( DCAMAPI_INITOPTION ) + +/*** --- meta data kind --- ***/ + +DCAM_DECLARE_BEGIN( enum, DCAMBUF_METADATAKIND ) +{ + DCAMBUF_METADATAKIND_TIMESTAMPS = 0x00010000, + DCAMBUF_METADATAKIND_FRAMESTAMPS = 0x00020000, + + end_of_dcambuf_metadatakind +} +DCAM_DECLARE_END( DCAMBUF_METADATAKIND ) + +DCAM_DECLARE_BEGIN( enum, DCAMREC_METADATAKIND ) +{ + DCAMREC_METADATAKIND_USERDATATEXT = 0x00000001, + DCAMREC_METADATAKIND_USERDATABIN = 0x00000002, + DCAMREC_METADATAKIND_TIMESTAMPS = 0x00010000, + DCAMREC_METADATAKIND_FRAMESTAMPS = 0x00020000, + + end_of_dcamrec_metadatakind +} +DCAM_DECLARE_END( DCAMREC_METADATAKIND ) + +/*** --- DCAM data option --- ***/ + +DCAM_DECLARE_BEGIN( enum, DCAMDATA_OPTION ) +{ + DCAMDATA_OPTION__VIEW_ALL = DCAMBUF_FRAME_OPTION__VIEW_ALL, + DCAMDATA_OPTION__VIEW_1 = DCAMBUF_FRAME_OPTION__VIEW_1, + DCAMDATA_OPTION__VIEW_2 = DCAMBUF_FRAME_OPTION__VIEW_2, + DCAMDATA_OPTION__VIEW_3 = DCAMBUF_FRAME_OPTION__VIEW_3, + DCAMDATA_OPTION__VIEW_4 = DCAMBUF_FRAME_OPTION__VIEW_4, + + DCAMDATA_OPTION__VIEW__STEP = DCAMBUF_FRAME_OPTION__VIEW__STEP, + DCAMDATA_OPTION__VIEW__MASK = DCAMBUF_FRAME_OPTION__VIEW__MASK, +} +DCAM_DECLARE_END( DCAMDATA_OPTION ) + +/*** --- DCAM data kind --- ***/ + +DCAM_DECLARE_BEGIN( enum, DCAMDATA_KIND ) +{ + DCAMDATA_KIND__REGION = 0x00000001, + DCAMDATA_KIND__LUT = 0x00000002, + DCAMDATA_KIND__NONE = 0x00000000 +} +DCAM_DECLARE_END( DCAMDATA_KIND ) + +/*** --- DCAM data attribute --- ***/ +DCAM_DECLARE_BEGIN( enum, DCAMDATA_ATTRIBUTE ) +{ + DCAMDATA_ATTRIBUTE__ACCESSREADY = 0x01000000, /* This value can get or set at READY status */ + DCAMDATA_ATTRIBUTE__ACCESSBUSY = 0x02000000, /* This value can get or set at BUSY status */ + + DCAMDATA_ATTRIBUTE__HASVIEW = 0x10000000, /* value can set the value for each views */ + + DCAMDATA_ATTRIBUTE__MASK = 0xFF000000, +} +DCAM_DECLARE_END( DCAMDATA_ATTRIBUTE ) + +/*** --- DCAM data region type --- ***/ +DCAM_DECLARE_BEGIN( enum, DCAMDATA_REGIONTYPE ) +{ + DCAMDATA_REGIONTYPE__BYTEMASK = 0x00000001, + DCAMDATA_REGIONTYPE__RECT16ARRAY = 0x00000002, + + DCAMDATA_REGIONTYPE__ACCESSREADY = DCAMDATA_ATTRIBUTE__ACCESSREADY, + DCAMDATA_REGIONTYPE__ACCESSBUSY = DCAMDATA_ATTRIBUTE__ACCESSBUSY, + DCAMDATA_REGIONTYPE__HASVIEW = DCAMDATA_ATTRIBUTE__HASVIEW, + + DCAMDATA_REGIONTYPE__BODYMASK = 0x00FFFFFF, + DCAMDATA_REGIONTYPE__ATTRIBUTEMASK = DCAMDATA_ATTRIBUTE__MASK, + + DCAMDATA_REGIONTYPE__NONE = 0x00000000 +} +DCAM_DECLARE_END( DCAMDATA_REGIONTYPE ) + +/*** --- DCAM data lut type --- ***/ +DCAM_DECLARE_BEGIN( enum, DCAMDATA_LUTTYPE ) +{ + DCAMDATA_LUTTYPE__SEGMENTED_LINEAR = 0x00000001, + DCAMDATA_LUTTYPE__MONO16 = 0x00000002, // reserved + + DCAMDATA_LUTTYPE__ACCESSREADY = DCAMDATA_ATTRIBUTE__ACCESSREADY, + DCAMDATA_LUTTYPE__ACCESSBUSY = DCAMDATA_ATTRIBUTE__ACCESSBUSY, + + DCAMDATA_LUTTYPE__BODYMASK = 0x00FFFFFF, + DCAMDATA_LUTTYPE__ATTRIBUTEMASK = DCAMDATA_ATTRIBUTE__MASK, + + DCAMDATA_LUTTYPE__NONE = 0x00000000 +} +DCAM_DECLARE_END( DCAMDATA_LUTTYPE ) + +/*** --- DCAMBUF proc type --- ***/ +DCAM_DECLARE_BEGIN( enum, DCAMBUF_PROCTYPE ) +{ + DCAMBUF_PROCTYPE__HIGHCONTRASTMODE = DCAMBUF_FRAME_OPTION__PROC_HIGHCONTRAST, + + DCAMBUF_PROCTYPE__NONE = 0x00000000 +} +DCAM_DECLARE_END( DCAMBUF_PROCTYPE ) + +/*** --- Code Page --- ***/ + +DCAM_DECLARE_BEGIN( enum, DCAM_CODEPAGE ) +{ + DCAM_CODEPAGE__SHIFT_JIS = 932, // Shift JIS + + DCAM_CODEPAGE__UTF16_LE = 1200, // UTF-16 (Little Endian) + DCAM_CODEPAGE__UTF16_BE = 1201, // UTF-16 (Big Endian) + + DCAM_CODEPAGE__UTF7 = 65000, // UTF-7 translation + DCAM_CODEPAGE__UTF8 = 65001, // UTF-8 translation + + DCAM_CODEPAGE__NONE = 0x00000000 +} +DCAM_DECLARE_END( DCAM_CODEPAGE ) + +/*** --- capability --- ***/ +DCAM_DECLARE_BEGIN( enum, DCAMDEV_CAPDOMAIN ) +{ + DCAMDEV_CAPDOMAIN__DCAMDATA = 0x00000001, + DCAMDEV_CAPDOMAIN__FRAMEOPTION = 0x00000002, + + DCAMDEV_CAPDOMAIN__FUNCTION = 0x00000000 +} +DCAM_DECLARE_END( DCAMDEV_CAPDOMAIN ) + +DCAM_DECLARE_BEGIN( enum, DCAMDEV_CAPFLAG ) +{ + DCAMDEV_CAPFLAG_FRAMESTAMP = 0x00000001, + DCAMDEV_CAPFLAG_TIMESTAMP = 0x00000002, + DCAMDEV_CAPFLAG_CAMERASTAMP = 0x00000004, + + DCAMDEV_CAPFLAG_NONE = 0x00000000 +} +DCAM_DECLARE_END( DCAMDEV_CAPFLAG ) +DCAM_DECLARE_BEGIN( enum, DCAMREC_STATUSFLAG ) +{ + DCAMREC_STATUSFLAG_NONE = 0x00000000, + DCAMREC_STATUSFLAG_RECORDING = 0x00000001, + + end_of_dcamrec_statusflag +} +DCAM_DECLARE_END( DCAMREC_STATUSFLAG ) + +/* **************************************************************** * + + structures (ver 4.x) + + * **************************************************************** */ + +typedef struct DCAMWAIT* HDCAMWAIT; +typedef struct DCAMREC* HDCAMREC; + +DCAM_DECLARE_BEGIN( struct, DCAM_GUID ) +{ + _ui32 Data1; + unsigned short Data2; + unsigned short Data3; + unsigned char Data4[ 8 ]; +} +DCAM_DECLARE_END( DCAM_GUID ) + +DCAM_DECLARE_BEGIN( struct, DCAMAPI_INIT ) +{ + int32 size; // [in] + int32 iDeviceCount; // [out] + int32 reserved; // reserved + int32 initoptionbytes; // [in] maximum bytes of initoption array. + const int32* initoption; // [in ptr] initialize options. Choose from DCAMAPI_INITOPTION + const DCAM_GUID* guid; // [in ptr] +} +DCAM_DECLARE_END( DCAMAPI_INIT ) + +DCAM_DECLARE_BEGIN( struct, DCAMDEV_OPEN ) +{ + int32 size; // [in] + int32 index; // [in] + HDCAM hdcam; // [out] +} +DCAM_DECLARE_END( DCAMDEV_OPEN ) + +DCAM_DECLARE_BEGIN( struct, DCAMDEV_CAPABILITY ) +{ + int32 size; // [in] + int32 domain; // [in] DCAMDEV_CAPDOMAIN__* + int32 capflag; // [out] available flags in current condition. + int32 kind; // [in] data kind in domain +} +DCAM_DECLARE_END( DCAMDEV_CAPABILITY ) + +DCAM_DECLARE_BEGIN( struct, DCAMDEV_CAPABILITY_LUT ) +{ + DCAMDEV_CAPABILITY hdr; // [in] size: size of this structure + // [in] domain: DCAMDEV_CAPDOMAIN__DCAMDATA + // [out]capflag: DCAMDATA_LUTTYPE__* + // [in] kind: DCAMDATA_KIND__LUT + + int32 linearpointmax; // [out] max of linear lut point +} +DCAM_DECLARE_END( DCAMDEV_CAPABILITY_LUT ) + +DCAM_DECLARE_BEGIN( struct, DCAMDEV_CAPABILITY_REGION ) +{ + DCAMDEV_CAPABILITY hdr; // [in] size: size of this structure + // [in] domain: DCAMDEV_CAPDOMAIN__DCAMDATA + // [out]capflag: DCAMDATA_REGIONTYPE__* + // [in] kind: DCAMDATA_KIND__REGION + + int32 horzunit; // [out] horizontal step + int32 vertunit; // [out] vertical step +} +DCAM_DECLARE_END( DCAMDEV_CAPABILITY_REGION ) + +DCAM_DECLARE_BEGIN( struct, DCAMDEV_CAPABILITY_FRAMEOPTION ) +{ + DCAMDEV_CAPABILITY hdr; // [in] size: size of this structure + // [in] domain: DCAMDEV_CAPDOMAIN__FRAMEOPTION + // [out]capflag: available DCAMBUF_PROCTYPE__* flags in current condition. + // [in] kind: 0 reserved + + int32 supportproc; // [out] support DCAMBUF_PROCTYPE__* flags in the camera. hdr.capflag may be 0 if the function doesn't work in current condition. +} +DCAM_DECLARE_END( DCAMDEV_CAPABILITY_FRAMEOPTION ) + +DCAM_DECLARE_BEGIN( struct, DCAMDEV_STRING ) +{ + int32 size; // [in] + int32 iString; // [in] + char* text; // [in,obuf] + int32 textbytes; // [in] +} +DCAM_DECLARE_END( DCAMDEV_STRING ) + +DCAM_DECLARE_BEGIN( struct, DCAMDATA_HDR ) +{ + int32 size; // [in] size of whole structure, not only this + int32 iKind; // [in] DCAMDATA_KIND__* + int32 option; // [in] DCAMDATA_OPTION__* + int32 reserved2; // [in] 0 reserved +} +DCAM_DECLARE_END( DCAMDATA_HDR ) + +DCAM_DECLARE_BEGIN( struct, DCAMDATA_REGION ) +{ + DCAMDATA_HDR hdr; // [in] iKind = DCAMDATA_KIND__REGION + + int32 option; // 0 reserved + int32 type; // [in] DCAMDATA_REGIONTYPE + void* data; // Byte array or DCAMDATA_REGIONRECT array + int32 datasize; // size of data + int32 reserved; // 0 reserved +} +DCAM_DECLARE_END( DCAMDATA_REGION ) + +DCAM_DECLARE_BEGIN( struct, DCAMDATA_REGIONRECT ) +{ + short left; + short top; + short right; + short bottom; +} +DCAM_DECLARE_END( DCAMDATA_REGIONRECT ) + +DCAM_DECLARE_BEGIN( struct, DCAMDATA_LUT ) +{ + DCAMDATA_HDR hdr; // [in] iKind = DCAMDATA_KIND__LUT + + int32 type; // [in] DCAMDATA_LUTTYPE + int32 page; // [in] use to load or store + void* data; // WORD array or DCAMDATA_LINEARLUT array + int32 datasize; // size of data + int32 reserved; // 0 reserved +} +DCAM_DECLARE_END( DCAMDATA_LUT ) + +DCAM_DECLARE_BEGIN( struct, DCAMDATA_LINEARLUT ) +{ + int32 lutin; + int32 lutout; +} +DCAM_DECLARE_END( DCAMDATA_LINEARLUT ) + +DCAM_DECLARE_BEGIN( struct, DCAMPROP_ATTR ) +{ + /* input parameters */ + int32 cbSize; // [in] size of this structure + int32 iProp; // DCAMIDPROPERTY + int32 option; // DCAMPROPOPTION + int32 iReserved1; // must be 0 + + /* output parameters */ + int32 attribute; // DCAMPROPATTRIBUTE + int32 iGroup; // 0 reserved; + int32 iUnit; // DCAMPROPUNIT + int32 attribute2; // DCAMPROPATTRIBUTE2 + + double valuemin; // minimum value + double valuemax; // maximum value + double valuestep; // minimum stepping between a value and the next + double valuedefault; // default value + + int32 nMaxChannel; // max channel if supports + int32 iReserved3; // reserved to 0 + int32 nMaxView; // max view if supports + + int32 iProp_NumberOfElement; // property id to get number of elements of this property if it is array + int32 iProp_ArrayBase; // base id of array if element + int32 iPropStep_Element; // step for iProp to next element +} +DCAM_DECLARE_END( DCAMPROP_ATTR ) + +DCAM_DECLARE_BEGIN( struct, DCAMPROP_VALUETEXT ) +{ + int32 cbSize; // [in] size of this structure + int32 iProp; // [in] DCAMIDPROP + double value; // [in] value of property + char* text; // [in,obuf] text of the value + int32 textbytes; // [in] text buf size +} +DCAM_DECLARE_END( DCAMPROP_VALUETEXT ) + +DCAM_DECLARE_BEGIN( struct, DCAMBUF_ATTACH ) +{ + int32 size; // [in] size of this structure. + int32 iKind; // [in] DCAMBUF_ATTACHKIND + void** buffer; // [in,ptr] + int32 buffercount; // [in] +} +DCAM_DECLARE_END( DCAMBUF_ATTACH ) + +DCAM_DECLARE_BEGIN( struct, DCAM_TIMESTAMP ) +{ + _ui32 sec; // [out] + int32 microsec; // [out] +} +DCAM_DECLARE_END( DCAM_TIMESTAMP ) + +DCAM_DECLARE_BEGIN( struct, DCAMCAP_TRANSFERINFO ) +{ + int32 size; // [in] size of this structure. + int32 iKind; // [in] DCAMCAP_TRANSFERKIND + int32 nNewestFrameIndex; // [out] + int32 nFrameCount; // [out] +} +DCAM_DECLARE_END( DCAMCAP_TRANSFERINFO ) + +DCAM_DECLARE_BEGIN( struct, DCAMBUF_FRAME ) +{ + // copyframe() and lockframe() use this structure. Some members have different direction. + // [i:o] means, the member is input at copyframe() and output at lockframe(). + // [i:i] and [o:o] means always input and output at both function. + // "input" means application has to set the value before calling. + // "output" means function filles a value at returning. + int32 size; // [i:i] size of this structure. + int32 iKind; // reserved. set to 0. + int32 option; // reserved. set to 0. + int32 iFrame; // [i:i] frame index + void* buf; // [i:o] pointer for top-left image + int32 rowbytes; // [i:o] byte size for next line. + DCAM_PIXELTYPE type; // reserved. set to 0. + int32 width; // [i:o] horizontal pixel count + int32 height; // [i:o] vertical line count + int32 left; // [i:o] horizontal start pixel + int32 top; // [i:o] vertical start line + DCAM_TIMESTAMP timestamp; // [o:o] timestamp + int32 framestamp; // [o:o] framestamp + int32 camerastamp; // [o:o] camerastamp +} +DCAM_DECLARE_END( DCAMBUF_FRAME ) + +DCAM_DECLARE_BEGIN( struct, DCAMREC_FRAME ) // currently the structure is same as DCAM_FRAME. option flag means are different. +{ + // copyframe() and lockframe() use this structure. Some members have different direction. + // [i:o] means, the member is input at copyframe() and output at lockframe(). + // [i:i] and [o:o] means always input and output at both function. + // "input" means application has to set the value before calling. + // "output" means function filles a value at returning. + int32 size; // [i:i] size of this structure. + int32 iKind; // reserved. set to 0. + int32 option; // DCAMREC_FRAME_OPTION + int32 iFrame; // [i:i] frame index + void* buf; // [i:o] pointer for top-left image + int32 rowbytes; // [i:o] byte size for next line. + DCAM_PIXELTYPE type; // reserved. set to 0. + int32 width; // [i:o] horizontal pixel count + int32 height; // [i:o] vertical line count + int32 left; // [i:o] horizontal start pixel + int32 top; // [i:o] vertical start line + DCAM_TIMESTAMP timestamp; // [o:o] timestamp + int32 framestamp; // [o:o] framestamp + int32 camerastamp; // [o:o] camerastamp +} +DCAM_DECLARE_END( DCAMREC_FRAME ) + +DCAM_DECLARE_BEGIN( struct, DCAMWAIT_OPEN ) +{ + int32 size; // [in] size of this structure. + int32 supportevent; // [out]; + HDCAMWAIT hwait; // [out]; + HDCAM hdcam; // [in]; +} +DCAM_DECLARE_END( DCAMWAIT_OPEN ) + +DCAM_DECLARE_BEGIN( struct, DCAMWAIT_START) +{ + int32 size; // [in] size of this structure. + int32 eventhappened; // [out] + int32 eventmask; // [in] + int32 timeout; // [in] +} +DCAM_DECLARE_END( DCAMWAIT_START ) + +#if defined(_WIN32) || defined(WIN32) + +DCAM_DECLARE_BEGIN( struct, DCAMREC_OPENA ) +{ + int32 size; // [in] size of this structure. + int32 reserved; // [in] + HDCAMREC hrec; // [out] + const char* path; // [in] + const char* ext; // [in] + int32 maxframepersession; // [in] + int32 userdatasize; // [in] + int32 userdatasize_session; // [in] + int32 userdatasize_file; // [in] + int32 usertextsize; // [in] + int32 usertextsize_session; // [in] + int32 usertextsize_file; // [in] +} +DCAM_DECLARE_END( DCAMREC_OPENA ) + +DCAM_DECLARE_BEGIN( struct, DCAMREC_OPENW ) +{ + int32 size; // [in] size of this structure. + int32 reserved; // [in] + HDCAMREC hrec; // [out] + const wchar_t* path; // [in] + const wchar_t* ext; // [in] + int32 maxframepersession; // [in] + int32 userdatasize; // [in] + int32 userdatasize_session; // [in] + int32 userdatasize_file; // [in] + int32 usertextsize; // [in] + int32 usertextsize_session; // [in] + int32 usertextsize_file; // [in] +} +DCAM_DECLARE_END( DCAMREC_OPENW ) + +#else + +DCAM_DECLARE_BEGIN( struct, DCAMREC_OPEN ) +{ + int32 size; // [in] size of this structure. + int32 reserved; // [in] + HDCAMREC hrec; // [out] + const char* path; // [in] + const char* ext; // [in] + int32 maxframepersession; // [in] + int32 userdatasize; // [in] + int32 userdatasize_session; // [in] + int32 userdatasize_file; // [in] + int32 usertextsize; // [in] + int32 usertextsize_session; // [in] + int32 usertextsize_file; // [in] +} +DCAM_DECLARE_END( DCAMREC_OPEN ) + +#endif + +DCAM_DECLARE_BEGIN( struct, DCAMREC_STATUS ) +{ + int32 size; + int32 currentsession_index; + int32 maxframecount_per_session; + int32 currentframe_index; + int32 missingframe_count; + int32 flags; // DCAMREC_STATUSFLAG + int32 totalframecount; + int32 reserved; +} +DCAM_DECLARE_END( DCAMREC_STATUS ) + +DCAM_DECLARE_BEGIN( struct, DCAM_METADATAHDR ) +{ + int32 size; // [in] size of whole structure, not only this. + int32 iKind; // [in] DCAM_METADATAKIND + int32 option; // [in] value meaning depends on DCAM_METADATAKIND + int32 iFrame; // [in] frame index +} +DCAM_DECLARE_END( DCAM_METADATAHDR ) + +DCAM_DECLARE_BEGIN( struct, DCAM_METADATABLOCKHDR ) +{ + int32 size; // [in] size of whole structure, not only this. + int32 iKind; // [in] DCAM_METADATAKIND + int32 option; // [in] value meaning depends on DCAMBUF_METADATAOPTION or DCAMREC_METADATAOPTION + int32 iFrame; // [in] start frame index + int32 in_count; // [in] max count of meta data + int32 outcount; // [out] count of got meta data. +} +DCAM_DECLARE_END( DCAM_METADATABLOCKHDR ) + +DCAM_DECLARE_BEGIN( struct, DCAM_USERDATATEXT ) +{ + DCAM_METADATAHDR hdr; // [in] size member should be size of this structure + // [in] iKind should be DCAMREC_METADATAKIND_USERDATATEXT. + // [in] option should be one of DCAMREC_METADATAOPTION + + char* text; // [in] UTF-8 encoding + int32 text_len; // [in] byte size of meta data. + int32 codepage; // [in] DCAM_CODEPAGE. +} +DCAM_DECLARE_END( DCAM_USERDATATEXT ) + +DCAM_DECLARE_BEGIN( struct, DCAM_USERDATABIN ) +{ + DCAM_METADATAHDR hdr; // [in] size member should be size of this structure + // [in] iKind should be DCAMREC_METADATAKIND_USERDATABIN. + // [in] option should be one of DCAMREC_METADATAOPTION + + void* bin; // [in] binary meta data + int32 bin_len; // [in] byte size of binary meta data. + int32 reserved; // [in] 0 reserved. +} +DCAM_DECLARE_END( DCAM_USERDATABIN ) + +DCAM_DECLARE_BEGIN( struct, DCAM_TIMESTAMPBLOCK ) +{ + DCAM_METADATABLOCKHDR hdr; // [in] size member should be size of this structure + // [in] iKind should be DCAMREC_METADATAKIND_TIMESTAMPS. + // [in] option should be one of DCAMBUF_METADATAOPTION or DCAMREC_METADATAOPTION + + DCAM_TIMESTAMP* timestamps; // [in] pointer for TIMESTAMP block + int32 timestampsize; // [in] sizeof(DCAM_TIMESTRAMP) + int32 timestampvaildsize; // [o] return the written data size of DCAM_TIMESTRAMP. + int32 timestampkind; // [o] return timestamp kind(Hardware, Driver, DCAM etc..) + int32 reserved; +} +DCAM_DECLARE_END( DCAM_TIMESTAMPBLOCK ) + +DCAM_DECLARE_BEGIN( struct, DCAM_FRAMESTAMPBLOCK ) +{ + DCAM_METADATABLOCKHDR hdr; // [in] size member should be size of this structure + // [in] iKind should be DCAM_METADATAKIND_FRAMESTAMPS. + // [in] option should be one of DCAMBUF_METADATAOPTION or DCAMREC_METADATAOPTION + + int32* framestamps; // [in] pointer for framestamp block + int32 reserved; +} +DCAM_DECLARE_END( DCAM_FRAMESTAMPBLOCK ) + +DCAM_DECLARE_BEGIN( struct, DCAM_METADATATEXTBLOCK ) +{ + DCAM_METADATABLOCKHDR hdr; + + void* text; // [i/o] see below. + int32* textsizes; // [i/o] see below. + int32 bytesperunit; // [i/o] see below. + int32 reserved; // [in] reserved to 0 + int32* textcodepage; // [i/o] see below. + +// Note + // dcamrec_copymetadatablock() + // buf // [in] pointer for filling userdatatext block + // unitsizes // [in] pointer for filling each text size of METADATA + // bytesperunit // [in] max bytes per unit for filling each METADATA + // textcodepage // [in] pointer for filling each text codepage of METADATA + + // dcamrec_lockmetadatablock() + // buf // [out] return DCAM internal pointer of userdatatext block + // unitsizes // [out] return DCAM internal array pointer of each size + // bytesperunit // [out] max bytes per unit which is set at DCAMREC_OPEN + // textcodepage // [out] return DCAM internal array pointer of each codepage +} +DCAM_DECLARE_END( DCAM_METADATATEXTBLOCK ) + +DCAM_DECLARE_BEGIN( struct, DCAM_METADATABINBLOCK ) +{ + DCAM_METADATABLOCKHDR hdr; + + void* bin; // [i/o] see below. + int32* binsizes; // [i/o] see below. + int32 bytesperunit; // [i/o] see below. + int32 reserved; // [in] reserved to 0 + +// Note + // dcamrec_copymetadatablock() + // bin // [in] pointer for filling userdatabin block + // binsizes // [in] pointer for filling each bin size of METADATA + // bytesperunit // [in] max bytes per unit for filling each METADATA + + // dcamrec_lockmetadatablock() + // bin // [out] return DCAM internal pointer of userdata bin block + // binsizes // [out] return DCAM internal array pointer of each bin size + // bytesperunit // [out] max bytes per unit which is set at DCAMREC_OPEN +} +DCAM_DECLARE_END( DCAM_METADATABINBLOCK ) + +/* **************************************************************** * + + functions (ver 4.x) + + * **************************************************************** */ + +// Initialize, uninitialize and misc. +DCAMERR DCAMAPI dcamapi_init ( DCAMAPI_INIT* param DCAM_DEFAULT_ARG ); +DCAMERR DCAMAPI dcamapi_uninit (); +DCAMERR DCAMAPI dcamdev_open ( DCAMDEV_OPEN* param ); +DCAMERR DCAMAPI dcamdev_close ( HDCAM h ); +DCAMERR DCAMAPI dcamdev_showpanel ( HDCAM h, int32 iKind ); +DCAMERR DCAMAPI dcamdev_getcapability ( HDCAM h, DCAMDEV_CAPABILITY* param ); +DCAMERR DCAMAPI dcamdev_getstring ( HDCAM h, DCAMDEV_STRING* param ); +DCAMERR DCAMAPI dcamdev_setdata ( HDCAM h, DCAMDATA_HDR* param ); +DCAMERR DCAMAPI dcamdev_getdata ( HDCAM h, DCAMDATA_HDR* param ); + +// Property control +DCAMERR DCAMAPI dcamprop_getattr ( HDCAM h, DCAMPROP_ATTR* param ); +DCAMERR DCAMAPI dcamprop_getvalue ( HDCAM h, int32 iProp, double* pValue ); +DCAMERR DCAMAPI dcamprop_setvalue ( HDCAM h, int32 iProp, double fValue ); +DCAMERR DCAMAPI dcamprop_setgetvalue ( HDCAM h, int32 iProp, double* pValue, int32 option DCAM_DEFAULT_ARG ); +DCAMERR DCAMAPI dcamprop_queryvalue ( HDCAM h, int32 iProp, double* pValue, int32 option DCAM_DEFAULT_ARG ); +DCAMERR DCAMAPI dcamprop_getnextid ( HDCAM h, int32* pProp, int32 option DCAM_DEFAULT_ARG ); +DCAMERR DCAMAPI dcamprop_getname ( HDCAM h, int32 iProp, char* text, int32 textbytes ); +DCAMERR DCAMAPI dcamprop_getvaluetext ( HDCAM h, DCAMPROP_VALUETEXT* param ); + +// Buffer control +DCAMERR DCAMAPI dcambuf_alloc ( HDCAM h, int32 framecount ); // call dcambuf_release() to free. +DCAMERR DCAMAPI dcambuf_attach ( HDCAM h, const DCAMBUF_ATTACH* param ); +DCAMERR DCAMAPI dcambuf_release ( HDCAM h, int32 iKind DCAM_DEFAULT_ARG ); +DCAMERR DCAMAPI dcambuf_lockframe ( HDCAM h, DCAMBUF_FRAME* pFrame ); +DCAMERR DCAMAPI dcambuf_copyframe ( HDCAM h, DCAMBUF_FRAME* pFrame ); +DCAMERR DCAMAPI dcambuf_copymetadata ( HDCAM h, DCAM_METADATAHDR* hdr ); + +// Capturing +DCAMERR DCAMAPI dcamcap_start ( HDCAM h, int32 mode ); +DCAMERR DCAMAPI dcamcap_stop ( HDCAM h ); +DCAMERR DCAMAPI dcamcap_status ( HDCAM h, int32* pStatus ); +DCAMERR DCAMAPI dcamcap_transferinfo ( HDCAM h, DCAMCAP_TRANSFERINFO* param ); +DCAMERR DCAMAPI dcamcap_firetrigger ( HDCAM h, int32 iKind DCAM_DEFAULT_ARG ); +DCAMERR DCAMAPI dcamcap_record ( HDCAM h, HDCAMREC hrec ); + +// Wait abort handle control +DCAMERR DCAMAPI dcamwait_open ( DCAMWAIT_OPEN* param ); +DCAMERR DCAMAPI dcamwait_close ( HDCAMWAIT hWait ); +DCAMERR DCAMAPI dcamwait_start ( HDCAMWAIT hWait, DCAMWAIT_START* param ); +DCAMERR DCAMAPI dcamwait_abort ( HDCAMWAIT hWait ); + +// Recording +#if defined(_WIN32) || defined(WIN32) +DCAMERR DCAMAPI dcamrec_openA ( DCAMREC_OPENA* param ); +DCAMERR DCAMAPI dcamrec_openW ( DCAMREC_OPENW* param ); + +#if defined(UNICODE) || defined(_UNICODE) +#define DCAMREC_OPEN DCAMREC_OPENW +#define dcamrec_open dcamrec_openW +#else +#define DCAMREC_OPEN DCAMREC_OPENA +#define dcamrec_open dcamrec_openA +#endif + +#else +DCAMERR DCAMAPI dcamrec_open ( DCAMREC_OPEN* param ); +#endif + +DCAMERR DCAMAPI dcamrec_close ( HDCAMREC hrec ); +DCAMERR DCAMAPI dcamrec_lockframe ( HDCAMREC hrec, DCAMREC_FRAME* pFrame ); +DCAMERR DCAMAPI dcamrec_copyframe ( HDCAMREC hrec, DCAMREC_FRAME* pFrame ); +DCAMERR DCAMAPI dcamrec_writemetadata ( HDCAMREC hrec, const DCAM_METADATAHDR* hdr ); +DCAMERR DCAMAPI dcamrec_lockmetadata ( HDCAMREC hrec, DCAM_METADATAHDR* hdr ); +DCAMERR DCAMAPI dcamrec_copymetadata ( HDCAMREC hrec, DCAM_METADATAHDR* hdr ); +DCAMERR DCAMAPI dcamrec_lockmetadatablock( HDCAMREC hrec, DCAM_METADATABLOCKHDR* hdr ); +DCAMERR DCAMAPI dcamrec_copymetadatablock( HDCAMREC hrec, DCAM_METADATABLOCKHDR* hdr ); + +DCAMERR DCAMAPI dcamrec_pause ( HDCAMREC hrec ); +DCAMERR DCAMAPI dcamrec_resume ( HDCAMREC hrec ); +DCAMERR DCAMAPI dcamrec_status ( HDCAMREC hrec, DCAMREC_STATUS* pStatus ); + +DCAM_DECLARE_BEGIN( struct, DCAM_METADATABLOCK ) +{ + DCAM_METADATABLOCKHDR hdr; + + void* buf; // [i/o] see below. + int32* unitsizes; // [i/o] see below. + int32 bytesperunit; // [i/o] see below. + int32 userdata_kind; // [in] choose userdata kind(File, Session, Frame) + +// Note + // dcamrec_copymetadatablock() + // buf // [in] pointer for filling userdata block + // unitsizes // [in] pointer for filling each unit size of METADATA + // bytesperunit // [in] max bytes per unit for filling each METADATA + + // dcamrec_lockmetadatablock() + // buf // [out] return DCAM internal pointer of userdata block + // unitsizes // [out] return DCAM internal array pointer of each size + // bytesperunit // [out] max bytes per unit which is set at DCAMREC_OPEN +} +DCAM_DECLARE_END( DCAM_METADATABLOCK ) + +#endif // DCAMAPI_VER >= 4000 + +/* **************************************************************** */ + +#ifdef __cplusplus + +/* end of extern "C" */ +}; + +/*** C++ utility ***/ + +inline int failed( DCAMERR err ) +{ + return int(err) < 0; +} + +#endif + +#if (defined(_MSC_VER)&&defined(_LINK_DCAMAPI_LIB)) +#pragma comment(lib, "dcamapi.lib") +#endif + +#pragma pack() + +#define _INCLUDE_DCAMAPI4_H_ +#endif diff --git a/support/dcamsdk4/inc/dcamprop.h b/support/dcamsdk4/inc/dcamprop.h new file mode 100644 index 0000000..fd28336 --- /dev/null +++ b/support/dcamsdk4/inc/dcamprop.h @@ -0,0 +1,1017 @@ +/* **************************************************************** * + + dcamprop.h: Jun 18, 2021 + + Copyright (C) 2011 - 2021 Hamamatsu Photonics K.K.. All right reserved. + + * **************************************************************** */ + +#ifndef _INCLUDE_DCAMPROP_H_ + +/* **************************************************************** * + + language absorber + + * **************************************************************** */ + +#ifdef __cplusplus + +/* C++ */ + +#ifndef DCAM_DEFAULT_ARG +#define DCAM_DEFAULT_ARG = 0 +#endif + +extern "C" { + +#else + +/* C */ + +#ifndef DCAM_DEFAULT_ARG +#define DCAM_DEFAULT_ARG +#endif + +#endif + +/* **************************************************************** * + + constant declaration + + * **************************************************************** */ + +typedef enum _DCAMPROPOPTION +{ + /*** direction flag for dcam_getnextpropertyid(), dcam_querypropertyvalue() ***/ + DCAMPROP_OPTION_PRIOR = 0xFF000000, /* prior value */ + DCAMPROP_OPTION_NEXT = 0x01000000, /* next value or id */ + + /*** direction flag for dcam_querypropertyvalue() ***/ + DCAMPROP_OPTION_NEAREST = 0x80000000, /* nearest value */ /* reserved */ + + /*** option for dcam_getnextpropertyid() ***/ + DCAMPROP_OPTION_SUPPORT = 0x00000000, /* default option */ + DCAMPROP_OPTION_UPDATED = 0x00000001, /* UPDATED and VOLATILE can be used at same time */ + DCAMPROP_OPTION_VOLATILE = 0x00000002, /* UPDATED and VOLATILE can be used at same time */ + DCAMPROP_OPTION_ARRAYELEMENT= 0x00000004, /* ARRAYELEMENT */ + + /*** for all option parameter ***/ + DCAMPROP_OPTION_NONE = 0x00000000 /* no option */ + +} DCAMPROPOPTION; + +/* property information */ + +typedef enum _DCAMPROPATTRIBUTE +{ + /* supporting information of DCAM_PROPERTYATTR */ + DCAMPROP_ATTR_HASRANGE = 0x80000000, + DCAMPROP_ATTR_HASSTEP = 0x40000000, + DCAMPROP_ATTR_HASDEFAULT = 0x20000000, + DCAMPROP_ATTR_HASVALUETEXT = 0x10000000, + + /* property id information */ + DCAMPROP_ATTR_HASCHANNEL = 0x08000000, /* value can set the value for each channels */ + + /* property attribute */ + DCAMPROP_ATTR_AUTOROUNDING = 0x00800000, \ + /* The dcam_setproperty() or dcam_setgetproperty() will failure if this bit exists. */ + /* If this flag does not exist, the value will be round up when it is not supported. */ + DCAMPROP_ATTR_STEPPING_INCONSISTENT = 0x00400000, + /* The valuestep of DCAM_PROPERTYATTR is not consistent across the entire range of */ + /* values. */ + DCAMPROP_ATTR_DATASTREAM = 0x00200000, /* value is releated to image attribute */ + + DCAMPROP_ATTR_HASRATIO = 0x00100000, /* value has ratio control capability */ + + DCAMPROP_ATTR_VOLATILE = 0x00080000, /* value may be changed by user or automatically */ + + DCAMPROP_ATTR_WRITABLE = 0x00020000, /* value can be set when state is manual */ + DCAMPROP_ATTR_READABLE = 0x00010000, /* value is readable when state is manual */ + + DCAMPROP_ATTR_HASVIEW = 0x00008000, /* value can set the value for each views */ + DCAMPROP_ATTR__SYSTEM = 0x00004000, /* system id */ /* reserved */ + + DCAMPROP_ATTR_ACCESSREADY = 0x00002000, /* This value can get or set at READY status */ + DCAMPROP_ATTR_ACCESSBUSY = 0x00001000, /* This value can get or set at BUSY status */ + + DCAMPROP_ATTR_ADVANCED = 0x00000800, /* User has to take care to change this value *//* reserved */ + DCAMPROP_ATTR_ACTION = 0x00000400, /* writing value takes related effect */ /* reserved */ + DCAMPROP_ATTR_EFFECTIVE = 0x00000200, /* value is effective */ + + /* property value type */ + DCAMPROP_TYPE_NONE = 0x00000000, /* undefined */ + DCAMPROP_TYPE_MODE = 0x00000001, /* 01: mode, 32bit integer in case of 32bit OS */ + DCAMPROP_TYPE_LONG = 0x00000002, /* 02: 32bit integer in case of 32bit OS */ + DCAMPROP_TYPE_REAL = 0x00000003, /* 03: 64bit float */ + /* no 32bit float */ + + /* application has to use double-float type variable even the property is not REAL. */ + + DCAMPROP_TYPE_MASK = 0x0000000F /* mask for property value type */ +} DCAMPROPATTRIBUTE; + +typedef enum _DCAMPROPATTRIBUTE2 +{ + + DCAMPROP_ATTR2_ARRAYBASE = 0x08000000, + DCAMPROP_ATTR2_ARRAYELEMENT = 0x04000000, + + DCAMPROP_ATTR2_REAL32 = 0x02000000, + DCAMPROP_ATTR2_INITIALIZEIMPROPER= 0x00000001, + DCAMPROP_ATTR2_CHANNELSEPARATEDDATA= 0x00040000, /* Channel 0 value is total of each channels. */ + + DCAMPROP_ATTR2__FUTUREUSE = 0x0003FFFC /* reserved */ +} DCAMPROPATTRIBUTE2; + +/* property information */ + +typedef enum _DCAMPROPUNIT +{ + DCAMPROP_UNIT_SECOND = 1, /* sec */ + DCAMPROP_UNIT_CELSIUS = 2, /* for sensor temperature */ + DCAMPROP_UNIT_KELVIN = 3, /* for color temperature */ + DCAMPROP_UNIT_METERPERSECOND= 4, /* for LINESPEED */ + DCAMPROP_UNIT_PERSECOND = 5, /* for FRAMERATE and LINERATE */ + DCAMPROP_UNIT_DEGREE = 6, /* for OUTPUT ROTATION */ + DCAMPROP_UNIT_MICROMETER = 7, /* for length */ + + DCAMPROP_UNIT_NONE = 0 /* no unit */ +} DCAMPROPUNIT; + +typedef enum _DCAMPROPMODEVALUE +{ + /* DCAM_IDPROP_SENSORMODE */ + DCAMPROP_SENSORMODE__AREA = 1, /* "AREA" */ + DCAMPROP_SENSORMODE__SLIT = 2, /* "SLIT" */ /* reserved */ + DCAMPROP_SENSORMODE__LINE = 3, /* "LINE" */ + DCAMPROP_SENSORMODE__TDI = 4, /* "TDI" */ + DCAMPROP_SENSORMODE__FRAMING = 5, /* "FRAMING" */ /* reserved */ + DCAMPROP_SENSORMODE__PARTIALAREA = 6, /* "PARTIAL AREA" */ /* reserved */ + DCAMPROP_SENSORMODE__SLITLINE = 9, /* "SLIT LINE" */ /* reserved */ + DCAMPROP_SENSORMODE__TDI_EXTENDED = 10, /* "TDI EXTENDED" */ + DCAMPROP_SENSORMODE__PANORAMIC = 11, /* "PANORAMIC" */ /* reserved */ + DCAMPROP_SENSORMODE__PROGRESSIVE = 12, /* "PROGRESSIVE" */ + DCAMPROP_SENSORMODE__SPLITVIEW = 14, /* "SPLIT VIEW" */ + DCAMPROP_SENSORMODE__DUALLIGHTSHEET = 16, /* "DUAL LIGHTSHEET" */ + DCAMPROP_SENSORMODE__PHOTONNUMBERRESOLVING = 18, /* "PHOTON NUMBER RESOLVING" */ + + /* DCAM_IDPROP_SHUTTER_MODE */ + DCAMPROP_SHUTTER_MODE__GLOBAL = 1, /* "GLOBAL" */ + DCAMPROP_SHUTTER_MODE__ROLLING = 2, /* "ROLLING" */ + + /* DCAM_IDPROP_READOUTSPEED */ + DCAMPROP_READOUTSPEED__SLOWEST = 1, /* no text */ + DCAMPROP_READOUTSPEED__FASTEST = 0x7FFFFFFF, /* no text,w/o */ + + /* DCAM_IDPROP_READOUT_DIRECTION */ + DCAMPROP_READOUT_DIRECTION__FORWARD = 1, /* "FORWARD" */ + DCAMPROP_READOUT_DIRECTION__BACKWARD = 2, /* "BACKWARD" */ + DCAMPROP_READOUT_DIRECTION__BYTRIGGER = 3, /* "BY TRIGGER" */ + DCAMPROP_READOUT_DIRECTION__DIVERGE = 5, /* "DIVERGE" */ + + /* DCAM_IDPROP_READOUT_UNIT */ +/* DCAMPROP_READOUT_UNIT__LINE = 1, */ /* "LINE" */ /* reserved */ + DCAMPROP_READOUT_UNIT__FRAME = 2, /* "FRAME" */ + DCAMPROP_READOUT_UNIT__BUNDLEDLINE = 3, /* "BUNDLED LINE" */ + DCAMPROP_READOUT_UNIT__BUNDLEDFRAME = 4, /* "BUNDLED FRAME" */ + + /* DCAM_IDPROP_CCDMODE */ + DCAMPROP_CCDMODE__NORMALCCD = 1, /* "NORMAL CCD" */ + DCAMPROP_CCDMODE__EMCCD = 2, /* "EM CCD" */ + + /* DCAM_IDPROP_CMOSMODE */ + DCAMPROP_CMOSMODE__NORMAL = 1, /* "NORMAL" */ + DCAMPROP_CMOSMODE__NONDESTRUCTIVE = 2, /* "NON DESTRUCTIVE" */ + + /* DCAM_IDPROP_OUTPUT_INTENSITY */ + DCAMPROP_OUTPUT_INTENSITY__NORMAL = 1, /* "NORMAL" */ + DCAMPROP_OUTPUT_INTENSITY__TESTPATTERN = 2, /* "TEST PATTERN" */ + + /* DCAM_IDPROP_OUTPUTDATA_ORIENTATION */ /* reserved */ + DCAMPROP_OUTPUTDATA_ORIENTATION__NORMAL = 1, /* reserved */ + DCAMPROP_OUTPUTDATA_ORIENTATION__MIRROR = 2, /* reserved */ + DCAMPROP_OUTPUTDATA_ORIENTATION__FLIP = 3, /* reserved */ + + /* DCAM_IDPROP_OUTPUTDATA_OPERATION */ + DCAMPROP_OUTPUTDATA_OPERATION__RAW = 1, + DCAMPROP_OUTPUTDATA_OPERATION__ALIGNED = 2, + + /* DCAM_IDPROP_TESTPATTERN_KIND */ + DCAMPROP_TESTPATTERN_KIND__FLAT = 2, /* "FLAT" */ + DCAMPROP_TESTPATTERN_KIND__IFLAT = 3, /* "INVERT FLAT" */ + DCAMPROP_TESTPATTERN_KIND__HORZGRADATION = 4, /* "HORZGRADATION" */ + DCAMPROP_TESTPATTERN_KIND__IHORZGRADATION = 5, /* "INVERT HORZGRADATION" */ + DCAMPROP_TESTPATTERN_KIND__VERTGRADATION = 6, /* "VERTGRADATION" */ + DCAMPROP_TESTPATTERN_KIND__IVERTGRADATION = 7, /* "INVERT VERTGRADATION" */ + DCAMPROP_TESTPATTERN_KIND__LINE = 8, /* "LINE" */ + DCAMPROP_TESTPATTERN_KIND__ILINE = 9, /* "INVERT LINE" */ + DCAMPROP_TESTPATTERN_KIND__DIAGONAL = 10, /* "DIAGONAL" */ + DCAMPROP_TESTPATTERN_KIND__IDIAGONAL = 11, /* "INVERT DIAGONAL" */ + DCAMPROP_TESTPATTERN_KIND__FRAMECOUNT = 12, /* "FRAMECOUNT" */ + + /* DCAM_IDPROP_DIGITALBINNING_METHOD */ + DCAMPROP_DIGITALBINNING_METHOD__MINIMUM = 1, /* "MINIMUM" */ + DCAMPROP_DIGITALBINNING_METHOD__MAXIMUM = 2, /* "MAXIMUM" */ + DCAMPROP_DIGITALBINNING_METHOD__ODD = 3, /* "ODD" */ + DCAMPROP_DIGITALBINNING_METHOD__EVEN = 4, /* "EVEN" */ + DCAMPROP_DIGITALBINNING_METHOD__SUM = 5, /* "SUM" */ + DCAMPROP_DIGITALBINNING_METHOD__AVERAGE = 6, /* "AVERAGE" */ + + /* DCAM_IDPROP_TRIGGERSOURCE */ + DCAMPROP_TRIGGERSOURCE__INTERNAL = 1, /* "INTERNAL" */ + DCAMPROP_TRIGGERSOURCE__EXTERNAL = 2, /* "EXTERNAL" */ + DCAMPROP_TRIGGERSOURCE__SOFTWARE = 3, /* "SOFTWARE" */ + DCAMPROP_TRIGGERSOURCE__MASTERPULSE = 4, /* "MASTER PULSE" */ + + /* DCAM_IDPROP_TRIGGERACTIVE */ + DCAMPROP_TRIGGERACTIVE__EDGE = 1, /* "EDGE" */ + DCAMPROP_TRIGGERACTIVE__LEVEL = 2, /* "LEVEL" */ + DCAMPROP_TRIGGERACTIVE__SYNCREADOUT = 3, /* "SYNCREADOUT" */ + DCAMPROP_TRIGGERACTIVE__POINT = 4, /* "POINT" */ + + /* DCAM_IDPROP_BUS_SPEED */ + DCAMPROP_BUS_SPEED__SLOWEST = 1, /* no text */ + DCAMPROP_BUS_SPEED__FASTEST = 0x7FFFFFFF, /* no text,w/o */ + + /* DCAM_IDPROP_TRIGGER_MODE */ + DCAMPROP_TRIGGER_MODE__NORMAL = 1, /* "NORMAL" */ + /* = 2, */ + DCAMPROP_TRIGGER_MODE__PIV = 3, /* "PIV" */ + DCAMPROP_TRIGGER_MODE__START = 6, /* "START" */ + DCAMPROP_TRIGGER_MODE__MULTIGATE = 7, /* "MULTIGATE" */ /* reserved */ + DCAMPROP_TRIGGER_MODE__MULTIFRAME = 8, /* "MULTIFRAME" */ /* reserved */ + + /* DCAM_IDPROP_TRIGGERPOLARITY */ + DCAMPROP_TRIGGERPOLARITY__NEGATIVE = 1, /* "NEGATIVE" */ + DCAMPROP_TRIGGERPOLARITY__POSITIVE = 2, /* "POSITIVE" */ + + /* DCAM_IDPROP_TRIGGER_CONNECTOR */ + DCAMPROP_TRIGGER_CONNECTOR__INTERFACE = 1, /* "INTERFACE" */ + DCAMPROP_TRIGGER_CONNECTOR__BNC = 2, /* "BNC" */ + DCAMPROP_TRIGGER_CONNECTOR__MULTI = 3, /* "MULTI" */ + + /* DCAM_IDPROP_INTERNALTRIGGER_HANDLING */ + DCAMPROP_INTERNALTRIGGER_HANDLING__SHORTEREXPOSURETIME = 1, /* "SHORTER EXPOSURE TIME" */ + DCAMPROP_INTERNALTRIGGER_HANDLING__FASTERFRAMERATE = 2, /* "FASTER FRAME RATE" */ + DCAMPROP_INTERNALTRIGGER_HANDLING__ABANDONWRONGFRAME = 3, /* "ABANDON WRONG FRAME" */ + DCAMPROP_INTERNALTRIGGER_HANDLING__BURSTMODE = 4, /* "BURST MODE" */ + DCAMPROP_INTERNALTRIGGER_HANDLING__INDIVIDUALEXPOSURE = 7, /* "INDIVIDUAL EXPOSURE TIME" */ + + /* DCAM_IDPROP_SYNCREADOUT_SYSTEMBLANK */ + DCAMPROP_SYNCREADOUT_SYSTEMBLANK__STANDARD = 1, /* "STANDARD" */ + DCAMPROP_SYNCREADOUT_SYSTEMBLANK__MINIMUM = 2, /* "MINIMUM" */ + + /* DCAM_IDPROP_TRIGGERENABLE_ACTIVE */ + DCAMPROP_TRIGGERENABLE_ACTIVE__DENY = 1, /* "DENY" */ + DCAMPROP_TRIGGERENABLE_ACTIVE__ALWAYS = 2, /* "ALWAYS" */ + DCAMPROP_TRIGGERENABLE_ACTIVE__LEVEL = 3, /* "LEVEL" */ + DCAMPROP_TRIGGERENABLE_ACTIVE__START = 4, /* "START" */ + + /* DCAM_IDPROP_TRIGGERENABLE_POLARITY */ + DCAMPROP_TRIGGERENABLE_POLARITY__NEGATIVE = 1, /* "NEGATIVE" */ + DCAMPROP_TRIGGERENABLE_POLARITY__POSITIVE = 2, /* "POSITIVE" */ + DCAMPROP_TRIGGERENABLE_POLARITY__INTERLOCK = 3, /* "INTERLOCK" */ + + /* DCAM_IDPROP_OUTPUTTRIGGER_CHANNELSYNC */ /* numeric headletter options */ + DCAMPROP_OUTPUTTRIGGER_CHANNELSYNC__1CHANNEL = 1, /* "1 Channel" */ + DCAMPROP_OUTPUTTRIGGER_CHANNELSYNC__2CHANNELS = 2, /* "2 Channels" */ + DCAMPROP_OUTPUTTRIGGER_CHANNELSYNC__3CHANNELS = 3, /* "3 Channels" */ + + /* DCAM_IDPROP_OUTPUTTRIGGER_PROGRAMABLESTART */ + DCAMPROP_OUTPUTTRIGGER_PROGRAMABLESTART__FIRSTEXPOSURE = 1, /* "FIRST EXPOSURE" */ + DCAMPROP_OUTPUTTRIGGER_PROGRAMABLESTART__FIRSTREADOUT = 2, /* "FIRST READOUT" */ + + /* DCAM_IDPROP_OUTPUTTRIGGER_SOURCE */ + DCAMPROP_OUTPUTTRIGGER_SOURCE__EXPOSURE = 1, /* "EXPOSURE" */ + DCAMPROP_OUTPUTTRIGGER_SOURCE__READOUTEND = 2, /* "READOUT END" */ + DCAMPROP_OUTPUTTRIGGER_SOURCE__VSYNC = 3, /* "VSYNC" */ + DCAMPROP_OUTPUTTRIGGER_SOURCE__HSYNC = 4, /* "HSYNC" */ + DCAMPROP_OUTPUTTRIGGER_SOURCE__TRIGGER = 6, /* "TRIGGER" */ + + /* DCAM_IDPROP_OUTPUTTRIGGER_POLARITY */ + DCAMPROP_OUTPUTTRIGGER_POLARITY__NEGATIVE = 1, /* "NEGATIVE" */ + DCAMPROP_OUTPUTTRIGGER_POLARITY__POSITIVE = 2, /* "POSITIVE" */ + + /* DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE */ + DCAMPROP_OUTPUTTRIGGER_ACTIVE__EDGE = 1, /* "EDGE" */ + DCAMPROP_OUTPUTTRIGGER_ACTIVE__LEVEL = 2, /* "LEVEL" */ +/* DCAMPROP_OUTPUTTRIGGER_ACTIVE__PULSE = 3, */ /* "PULSE" */ /* reserved */ + + /* DCAM_IDPROP_OUTPUTTRIGGER_KIND */ + DCAMPROP_OUTPUTTRIGGER_KIND__LOW = 1, /* "LOW" */ + DCAMPROP_OUTPUTTRIGGER_KIND__GLOBALEXPOSURE = 2, /* "EXPOSURE" */ + DCAMPROP_OUTPUTTRIGGER_KIND__PROGRAMABLE = 3, /* "PROGRAMABLE" */ + DCAMPROP_OUTPUTTRIGGER_KIND__TRIGGERREADY = 4, /* "TRIGGER READY" */ + DCAMPROP_OUTPUTTRIGGER_KIND__HIGH = 5, /* "HIGH" */ + DCAMPROP_OUTPUTTRIGGER_KIND__ANYROWEXPOSURE = 6, /* "ANYROW EXPOSURE" */ + + /* DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR */ + DCAMPROP_OUTPUTTRIGGER_BASESENSOR__VIEW1 = 1, /* "VIEW 1" */ + DCAMPROP_OUTPUTTRIGGER_BASESENSOR__VIEW2 = 2, /* "VIEW 2" */ + DCAMPROP_OUTPUTTRIGGER_BASESENSOR__ANYVIEW = 15, /* "ANY VIEW" */ + DCAMPROP_OUTPUTTRIGGER_BASESENSOR__ALLVIEWS = 16, /* "ALL VIEWS" */ + + /* DCAM_IDPROP_EXPOSURETIME_CONTROL */ + DCAMPROP_EXPOSURETIME_CONTROL__OFF = 1, /* "OFF" */ + DCAMPROP_EXPOSURETIME_CONTROL__NORMAL = 2, /* "NORMAL" */ + + /* DCAM_IDPROP_TRIGGER_FIRSTEXPOSURE */ + DCAMPROP_TRIGGER_FIRSTEXPOSURE__NEW = 1, /* "NEW" */ + DCAMPROP_TRIGGER_FIRSTEXPOSURE__CURRENT = 2, /* "CURRENT" */ + + /* DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE */ + DCAMPROP_TRIGGER_GLOBALEXPOSURE__NONE = 1, /* "NONE" */ + DCAMPROP_TRIGGER_GLOBALEXPOSURE__ALWAYS = 2, /* "ALWAYS" */ + DCAMPROP_TRIGGER_GLOBALEXPOSURE__DELAYED = 3, /* "DELAYED" */ + DCAMPROP_TRIGGER_GLOBALEXPOSURE__EMULATE = 4, /* "EMULATE" */ + DCAMPROP_TRIGGER_GLOBALEXPOSURE__GLOBALRESET = 5, /* "GLOBAL RESET" */ + + /* DCAM_IDPROP_FIRSTTRIGGER_BEHAVIOR */ + DCAMPROP_FIRSTTRIGGER_BEHAVIOR__STARTEXPOSURE = 1, /* "START EXPOSURE" */ + DCAMPROP_FIRSTTRIGGER_BEHAVIOR__STARTREADOUT = 2, /* "START READOUT" */ + + /* DCAM_IDPROP_MASTERPULSE_MODE */ + DCAMPROP_MASTERPULSE_MODE__CONTINUOUS = 1, /* "CONTINUOUS" */ + DCAMPROP_MASTERPULSE_MODE__START = 2, /* "START" */ + DCAMPROP_MASTERPULSE_MODE__BURST = 3, /* "BURST" */ + + /* DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE */ + DCAMPROP_MASTERPULSE_TRIGGERSOURCE__EXTERNAL = 1, /* "EXTERNAL" */ + DCAMPROP_MASTERPULSE_TRIGGERSOURCE__SOFTWARE = 2, /* "SOFTWARE" */ + + /* DCAM_IDPROP_MECHANICALSHUTTER */ + DCAMPROP_MECHANICALSHUTTER__AUTO = 1, /* "AUTO" */ + DCAMPROP_MECHANICALSHUTTER__CLOSE = 2, /* "CLOSE" */ + DCAMPROP_MECHANICALSHUTTER__OPEN = 3, /* "OPEN" */ + + /* DCAM_IDPROP_MECHANICALSHUTTER_AUTOMODE */ /* reserved */ +/* DCAMPROP_MECHANICALSHUTTER_AUTOMODE__OPEN_WHEN_EXPOSURE = 1,*/ /* "OPEN WHEN EXPOSURE" */ /* reserved */ +/* DCAMPROP_MECHANICALSHUTTER_AUTOMODE__CLOSE_WHEN_READOUT = 2,*/ /* "CLOSE WHEN READOUT" */ /* reserved */ + + /* DCAM_IDPROP_LIGHTMODE */ + DCAMPROP_LIGHTMODE__LOWLIGHT = 1, /* "LOW LIGHT" */ + DCAMPROP_LIGHTMODE__HIGHLIGHT = 2, /* "HIGH LIGHT" */ + + /* DCAM_IDPROP_SENSITIVITYMODE */ + DCAMPROP_SENSITIVITYMODE__OFF = 1, /* "OFF" */ + DCAMPROP_SENSITIVITYMODE__ON = 2, /* "ON" */ + DCAMPROP_SENSITIVITY2_MODE__INTERLOCK = 3, /* "INTERLOCK" */ + + /* DCAM_IDPROP_EMGAINWARNING_STATUS */ + DCAMPROP_EMGAINWARNING_STATUS__NORMAL = 1, /* "NORMAL" */ + DCAMPROP_EMGAINWARNING_STATUS__WARNING = 2, /* "WARNING" */ + DCAMPROP_EMGAINWARNING_STATUS__PROTECTED = 3, /* "PROTECTED" */ + + /* DCAM_IDPROP_PHOTONIMAGINGMODE */ /* numeric headletter options */ + DCAMPROP_PHOTONIMAGINGMODE__0 = 0, /* "0" */ + DCAMPROP_PHOTONIMAGINGMODE__1 = 1, /* "1" */ + DCAMPROP_PHOTONIMAGINGMODE__2 = 2, /* "2" */ + DCAMPROP_PHOTONIMAGINGMODE__3 = 3, /* "2" */ + + /* DCAM_IDPROP_SENSORCOOLER */ + DCAMPROP_SENSORCOOLER__OFF = 1, /* "OFF" */ + DCAMPROP_SENSORCOOLER__ON = 2, /* "ON" */ +/* DCAMPROP_SENSORCOOLER__BEST = 3, */ /* "BEST" */ /* reserved */ + DCAMPROP_SENSORCOOLER__MAX = 4, /* "MAX" */ + + /* DCAM_IDPROP_SENSORTEMPERATURE_STATUS */ + DCAMPROP_SENSORTEMPERATURE_STATUS__NORMAL = 0, /* "NORMAL" */ + DCAMPROP_SENSORTEMPERATURE_STATUS__WARNING = 1, /* "WARNING" */ + DCAMPROP_SENSORTEMPERATURE_STATUS__PROTECTION = 2, /* "PROTECTION" */ + + /* DCAM_IDPROP_SENSORCOOLERSTATUS */ + DCAMPROP_SENSORCOOLERSTATUS__ERROR4 = -4, /* "ERROR4" */ + DCAMPROP_SENSORCOOLERSTATUS__ERROR3 = -3, /* "ERROR3" */ + DCAMPROP_SENSORCOOLERSTATUS__ERROR2 = -2, /* "ERROR2" */ + DCAMPROP_SENSORCOOLERSTATUS__ERROR1 = -1, /* "ERROR1" */ + DCAMPROP_SENSORCOOLERSTATUS__NONE = 0, /* "NONE" */ + DCAMPROP_SENSORCOOLERSTATUS__OFF = 1, /* "OFF" */ + DCAMPROP_SENSORCOOLERSTATUS__READY = 2, /* "READY" */ + DCAMPROP_SENSORCOOLERSTATUS__BUSY = 3, /* "BUSY" */ + DCAMPROP_SENSORCOOLERSTATUS__ALWAYS = 4, /* "ALWAYS" */ + DCAMPROP_SENSORCOOLERSTATUS__WARNING = 5, /* "WARNING" */ + + /* DCAM_IDPROP_CONTRAST_CONTROL */ /* reserved */ +/* DCAMPROP_CONTRAST_CONTROL__OFF = 1, */ /* "OFF" */ /* reserved */ +/* DCAMPROP_CONTRAST_CONTROL__ON = 2, */ /* "ON" */ /* reserved */ +/* DCAMPROP_CONTRAST_CONTROL__FRONTPANEL = 3, */ /* "FRONT PANEL" */ /* reserved */ + + /* DCAM_IDPROP_REALTIMEGAINCORRECT_LEVEL */ + DCAMPROP_REALTIMEGAINCORRECT_LEVEL__1 = 1, /* "1" */ + DCAMPROP_REALTIMEGAINCORRECT_LEVEL__2 = 2, /* "2" */ + DCAMPROP_REALTIMEGAINCORRECT_LEVEL__3 = 3, /* "3" */ + DCAMPROP_REALTIMEGAINCORRECT_LEVEL__4 = 4, /* "4" */ + DCAMPROP_REALTIMEGAINCORRECT_LEVEL__5 = 5, /* "5" */ + + /* DCAM_IDPROP_WHITEBALANCEMODE */ + DCAMPROP_WHITEBALANCEMODE__FLAT = 1, /* "FLAT" */ + DCAMPROP_WHITEBALANCEMODE__AUTO = 2, /* "AUTO" */ + DCAMPROP_WHITEBALANCEMODE__TEMPERATURE = 3, /* "TEMPERATURE" */ + DCAMPROP_WHITEBALANCEMODE__USERPRESET = 4, /* "USER PRESET" */ + + /* DCAM_IDPROP_DARKCALIB_TARGET */ + DCAMPROP_DARKCALIB_TARGET__ALL = 1, /* "ALL" */ + DCAMPROP_DARKCALIB_TARGET__ANALOG = 2, /* "ANALOG" */ + + /* DCAM_IDPROP_SHADINGCALIB_METHOD */ + DCAMPROP_SHADINGCALIB_METHOD__AVERAGE = 1, /* "AVERAGE" */ + DCAMPROP_SHADINGCALIB_METHOD__MAXIMUM = 2, /* "MAXIMUM" */ + DCAMPROP_SHADINGCALIB_METHOD__USETARGET = 3, /* "USE TARGET" */ + + /* DCAM_IDPROP_CAPTUREMODE */ + DCAMPROP_CAPTUREMODE__NORMAL = 1, /* "NORMAL" */ + DCAMPROP_CAPTUREMODE__DARKCALIB = 2, /* "DARK CALIBRATION" */ + DCAMPROP_CAPTUREMODE__SHADINGCALIB = 3, /* "SHADING CALIBRATION" */ + DCAMPROP_CAPTUREMODE__TAPGAINCALIB = 4, /* "TAP GAIN CALIBRATION" */ + DCAMPROP_CAPTUREMODE__BACKFOCUSCALIB = 5, /* "BACK FOCUS CALIBRATION" */ /*[ ORCA-D2 ]*/ + + /* DCAM_IDPROP_INTERFRAMEALU_ENABLE */ + DCAMPROP_INTERFRAMEALU_ENABLE__OFF = 1, /* "OFF" */ + DCAMPROP_INTERFRAMEALU_ENABLE__TRIGGERSOURCE_ALL = 2, /* "TRIGGER SOURCE ALL" */ + DCAMPROP_INTERFRAMEALU_ENABLE__TRIGGERSOURCE_INTERNAL=3, /* "TRIGGER SOURCE INTERNAL ONLY" */ + + /* DCAM_IDPROP_SUBTRACT_DATASTATUS/DCAM_IDPROP_SHADINGCALIB_DATASTATUS */ + DCAMPROP_CALIBDATASTATUS__NONE = 1, /* "NONE" */ + DCAMPROP_CALIBDATASTATUS__FORWARD = 2, /* "FORWARD" */ + DCAMPROP_CALIBDATASTATUS__BACKWARD = 3, /* "BACKWARD" */ + DCAMPROP_CALIBDATASTATUS__BOTH = 4, /* "BOTH" */ + + /* DCAM_IDPROP_TAPGAINCALIB_METHOD */ + DCAMPROP_TAPGAINCALIB_METHOD__AVE = 1, /* "AVERAGE" */ + DCAMPROP_TAPGAINCALIB_METHOD__MAX = 2, /* "MAXIMUM" */ + DCAMPROP_TAPGAINCALIB_METHOD__MIN = 3, /* "MINIMUM" */ + + /* DCAM_IDPROP_RECURSIVEFILTERFRAMES */ /* numeric headletter options */ + DCAMPROP_RECURSIVEFILTERFRAMES__2 = 2, /* "2 FRAMES" */ + DCAMPROP_RECURSIVEFILTERFRAMES__4 = 4, /* "4 FRAMES" */ + DCAMPROP_RECURSIVEFILTERFRAMES__8 = 8, /* "8 FRAMES" */ + DCAMPROP_RECURSIVEFILTERFRAMES__16 = 16, /* "16 FRAMES" */ + DCAMPROP_RECURSIVEFILTERFRAMES__32 = 32, /* "32 FRAMES" */ + DCAMPROP_RECURSIVEFILTERFRAMES__64 = 64, /* "64 FRAMES" */ + + /* DCAM_IDPROP_INTENSITYLUT_MODE */ + DCAMPROP_INTENSITYLUT_MODE__THROUGH = 1, /* "THROUGH" */ + DCAMPROP_INTENSITYLUT_MODE__PAGE = 2, /* "PAGE" */ + DCAMPROP_INTENSITYLUT_MODE__CLIP = 3, /* "CLIP" */ + + /* DCAM_IDPROP_BINNING */ + DCAMPROP_BINNING__1 = 1, /* "1X1" */ + DCAMPROP_BINNING__2 = 2, /* "2X2" */ + DCAMPROP_BINNING__4 = 4, /* "4X4" */ + DCAMPROP_BINNING__8 = 8, /* "8X8" */ + DCAMPROP_BINNING__16 = 16, /* "16X16" */ + DCAMPROP_BINNING__1_2 = 102, /* "1X2" */ + DCAMPROP_BINNING__2_4 = 204, /* "2X4" */ + + /* DCAM_IDPROP_COLORTYPE */ + DCAMPROP_COLORTYPE__BW = 0x00000001, /* "BW" */ + DCAMPROP_COLORTYPE__RGB = 0x00000002, /* "RGB" */ + DCAMPROP_COLORTYPE__BGR = 0x00000003, /* "BGR" */ + /* other values are resereved */ + + /* DCAM_IDPROP_BITSPERCHANNEL */ /* numeric headletter options */ + DCAMPROP_BITSPERCHANNEL__8 = 8, /* "8BIT" */ + DCAMPROP_BITSPERCHANNEL__10 = 10, /* "10BIT" */ + DCAMPROP_BITSPERCHANNEL__12 = 12, /* "12BIT" */ + DCAMPROP_BITSPERCHANNEL__14 = 14, /* "14BIT" */ + DCAMPROP_BITSPERCHANNEL__16 = 16, /* "16BIT" */ + + /* DCAM_IDPROP_DEFECTCORRECT_MODE */ + DCAMPROP_DEFECTCORRECT_MODE__OFF = 1, /* "OFF" */ + DCAMPROP_DEFECTCORRECT_MODE__ON = 2, /* "ON" */ + + /* DCAM_IDPROP_DEFECTCORRECT_METHOD */ + DCAMPROP_DEFECTCORRECT_METHOD__CEILING = 3, /* "CEILING" */ + DCAMPROP_DEFECTCORRECT_METHOD__PREVIOUS = 4, /* "PREVIOUS" */ + + /* DCAM_IDPROP_HOTPIXELCORRECT_LEVEL */ + DCAMPROP_HOTPIXELCORRECT_LEVEL__STANDARD = 1, /* "STANDARD" */ + DCAMPROP_HOTPIXELCORRECT_LEVEL__MINIMUM = 2, /* "MINIMUM" */ + DCAMPROP_HOTPIXELCORRECT_LEVEL__AGGRESSIVE = 3, /* "AGGRESSIVE" */ + + /* DCAM_IDPROP_DEVICEBUFFER_MODE */ + DCAMPROP_DEVICEBUFFER_MODE__THRU = 1, /* "THRU" */ + DCAMPROP_DEVICEBUFFER_MODE__SNAPSHOT = 2, /* "SNAPSHOT" */ + + /* DCAM_IDPROP_SYSTEM_ALIVE */ + DCAMPROP_SYSTEM_ALIVE__OFFLINE = 1, /* "OFFLINE" */ + DCAMPROP_SYSTEM_ALIVE__ONLINE = 2, /* "ONLINE" */ + DCAMPROP_SYSTEM_ALIVE__ERROR = 3, /* "ERROR" */ + + /* DCAM_IDPROP_TIMESTAMP_MODE */ + DCAMPROP_TIMESTAMP_MODE__NONE = 1, /* "NONE" */ + DCAMPROP_TIMESTAMP_MODE__LINEBEFORELEFT = 2, /* "LINE BEFORE LEFT" */ + DCAMPROP_TIMESTAMP_MODE__LINEOVERWRITELEFT = 3, /* "LINE OVERWRITE LEFT" */ + DCAMPROP_TIMESTAMP_MODE__AREABEFORELEFT = 4, /* "AREA BEFORE LEFT" */ + DCAMPROP_TIMESTAMP_MODE__AREAOVERWRITELEFT = 5, /* "AREA OVERWRITE LEFT" */ + + /* DCAM_IDPROP_TIMING_EXPOSURE */ + DCAMPROP_TIMING_EXPOSURE__AFTERREADOUT = 1, /* "AFTER READOUT" */ + DCAMPROP_TIMING_EXPOSURE__OVERLAPREADOUT = 2, /* "OVERLAP READOUT" */ + DCAMPROP_TIMING_EXPOSURE__ROLLING = 3, /* "ROLLING" */ + DCAMPROP_TIMING_EXPOSURE__ALWAYS = 4, /* "ALWAYS" */ + DCAMPROP_TIMING_EXPOSURE__TDI = 5, /* "TDI" */ + + /* DCAM_IDPROP_TIMESTAMP_PRODUCER */ + DCAMPROP_TIMESTAMP_PRODUCER__NONE = 1, /* "NONE" */ + DCAMPROP_TIMESTAMP_PRODUCER__DCAMMODULE = 2, /* "DCAM MODULE" */ + DCAMPROP_TIMESTAMP_PRODUCER__KERNELDRIVER = 3, /* "KERNEL DRIVER" */ + DCAMPROP_TIMESTAMP_PRODUCER__CAPTUREDEVICE = 4, /* "CAPTURE DEVICE" */ + DCAMPROP_TIMESTAMP_PRODUCER__IMAGINGDEVICE = 5, /* "IMAGING DEVICE" */ + + /* DCAM_IDPROP_FRAMESTAMP_PRODUCER */ + DCAMPROP_FRAMESTAMP_PRODUCER__NONE = 1, /* "NONE" */ + DCAMPROP_FRAMESTAMP_PRODUCER__DCAMMODULE = 2, /* "DCAM MODULE" */ + DCAMPROP_FRAMESTAMP_PRODUCER__KERNELDRIVER = 3, /* "KERNEL DRIVER" */ + DCAMPROP_FRAMESTAMP_PRODUCER__CAPTUREDEVICE = 4, /* "CAPTURE DEVICE" */ + DCAMPROP_FRAMESTAMP_PRODUCER__IMAGINGDEVICE = 5, /* "IMAGING DEVICE" */ + + /* DCAM_IDPROP_CAMERASTATUS_INTENSITY */ + DCAMPROP_CAMERASTATUS_INTENSITY__GOOD = 1, /* "GOOD" */ + DCAMPROP_CAMERASTATUS_INTENSITY__TOODARK = 2, /* "TOO DRAK" */ + DCAMPROP_CAMERASTATUS_INTENSITY__TOOBRIGHT = 3, /* "TOO BRIGHT" */ + DCAMPROP_CAMERASTATUS_INTENSITY__UNCARE = 4, /* "UNCARE" */ + DCAMPROP_CAMERASTATUS_INTENSITY__EMGAIN_PROTECTION = 5, /* "EMGAIN PROTECTION" */ + DCAMPROP_CAMERASTATUS_INTENSITY__INCONSISTENT_OPTICS= 6, /* "INCONSISTENT OPTICS" */ + DCAMPROP_CAMERASTATUS_INTENSITY__NODATA = 7, /* "NO DATA" */ + + /* DCAM_IDPROP_CAMERASTATUS_INPUTTRIGGER */ + DCAMPROP_CAMERASTATUS_INPUTTRIGGER__GOOD = 1, /* "GOOD" */ + DCAMPROP_CAMERASTATUS_INPUTTRIGGER__NONE = 2, /* "NONE" */ + DCAMPROP_CAMERASTATUS_INPUTTRIGGER__TOOFREQUENT = 3, /* "TOO FREQUENT" */ + + /* DCAM_IDPROP_CAMERASTATUS_CALIBRATION */ + DCAMPROP_CAMERASTATUS_CALIBRATION__DONE = 1,/* "DONE" */ + DCAMPROP_CAMERASTATUS_CALIBRATION__NOTYET = 2,/* "NOT YET" */ + DCAMPROP_CAMERASTATUS_CALIBRATION__NOTRIGGER = 3,/* "NO TRIGGER" */ + DCAMPROP_CAMERASTATUS_CALIBRATION__TOOFREQUENTTRIGGER = 4,/* "TOO FREQUENT TRIGGER" */ + DCAMPROP_CAMERASTATUS_CALIBRATION__OUTOFADJUSTABLERANGE = 5,/* "OUT OF ADJUSTABLE RANGE"*/ + DCAMPROP_CAMERASTATUS_CALIBRATION__UNSUITABLETABLE = 6,/* "UNSUITABLE TABLE" */ + DCAMPROP_CAMERASTATUS_CALIBRATION__TOODARK = 7,/* "TOO DARK" */ + DCAMPROP_CAMERASTATUS_CALIBRATION__TOOBRIGHT = 8,/* "TOO BRIGHT" */ + DCAMPROP_CAMERASTATUS_CALIBRATION__NOTDETECTOBJECT = 9,/* "NOT DETECT OBJECT" */ + + /* DCAM_IDPROP_CONFOCAL_SCANMODE */ + DCAMPROP_CONFOCAL_SCANMODE__SIMULTANEOUS = 1, /* "SIMULTANEOUS" */ + DCAMPROP_CONFOCAL_SCANMODE__SEQUENTIAL = 2, /* "SEQUENTIAL" */ + + /* DCAM_IDPROP_SUBUNIT_CONTROL */ + DCAMPROP_SUBUNIT_CONTROL__NOTINSTALLED = 0, /* "NOT INSTALLED" */ + DCAMPROP_SUBUNIT_CONTROL__OFF = 1, /* "OFF" */ + DCAMPROP_SUBUNIT_CONTROL__ON = 2, /* "ON" */ + + /* DCAM_IDPROP_SUBUNIT_PINHOLESIZE */ + DCAMPROP_SUBUNIT_PINHOLESIZE__ERROR = 1, /* "ERROR" */ + DCAMPROP_SUBUNIT_PINHOLESIZE__SMALL = 2, /* "SMALL" */ + DCAMPROP_SUBUNIT_PINHOLESIZE__MEDIUM = 3, /* "MEDIUM" */ + DCAMPROP_SUBUNIT_PINHOLESIZE__LARGE = 4, /* "LARGE" */ + + /*-- for general purpose --*/ + DCAMPROP_MODE__OFF = 1, /* "OFF" */ + DCAMPROP_MODE__ON = 2, /* "ON" */ + + /*-- options --*/ + + /* for backward compativilities */ + + DCAMPROP_SCAN_MODE__NORMAL = DCAMPROP_SENSORMODE__AREA, + DCAMPROP_SCAN_MODE__SLIT = DCAMPROP_SENSORMODE__SLIT, + + DCAMPROP_SWITCHMODE_OFF = DCAMPROP_MODE__OFF, /* "OFF" */ + DCAMPROP_SWITCHMODE_ON = DCAMPROP_MODE__ON, /* "ON" */ + + DCAMPROP_TRIGGERACTIVE__PULSE = DCAMPROP_TRIGGERACTIVE__SYNCREADOUT, /* was "PULSE" */ + + DCAMPROP_READOUT_DIRECTION__NORMAL = DCAMPROP_READOUT_DIRECTION__FORWARD, /* VALUETEXT was "NORMAL" */ + DCAMPROP_READOUT_DIRECTION__REVERSE = DCAMPROP_READOUT_DIRECTION__BACKWARD, /* VALUETEXT was "REVERSE" */ + + DCAMPROP_OUTPUTTRIGGER_KIND__EXPOSURE = DCAMPROP_OUTPUTTRIGGER_KIND__GLOBALEXPOSURE, + + /*-- miss spelling --*/ + DCAMPROP_TRIGGERSOURCE__EXERNAL = DCAMPROP_TRIGGERSOURCE__EXTERNAL +} DCAMPROPMODEVALUE; + +/* **************************************************************** * + + property ids + + **************************************************************** */ + +typedef enum _DCAMIDPROP +{ + /* 0x00000000 - 0x00100000, reserved */ + +/* Group: TIMING */ + DCAM_IDPROP_TRIGGERSOURCE = 0x00100110, /* R/W, mode, "TRIGGER SOURCE" */ + DCAM_IDPROP_TRIGGERACTIVE = 0x00100120, /* R/W, mode, "TRIGGER ACTIVE" */ + DCAM_IDPROP_TRIGGER_MODE = 0x00100210, /* R/W, mode, "TRIGGER MODE" */ + DCAM_IDPROP_TRIGGERPOLARITY = 0x00100220, /* R/W, mode, "TRIGGER POLARITY" */ + DCAM_IDPROP_TRIGGER_CONNECTOR = 0x00100230, /* R/W, mode, "TRIGGER CONNECTOR" */ + DCAM_IDPROP_TRIGGERTIMES = 0x00100240, /* R/W, long, "TRIGGER TIMES" */ + /* 0x00100250 is reserved */ + DCAM_IDPROP_TRIGGERDELAY = 0x00100260, /* R/W, sec, "TRIGGER DELAY" */ + DCAM_IDPROP_INTERNALTRIGGER_HANDLING = 0x00100270, /* R/W, mode, "INTERNAL TRIGGER HANDLING"*/ + DCAM_IDPROP_TRIGGERMULTIFRAME_COUNT = 0x00100280, /* R/W, long, "TRIGGER MULTI FRAME COUNT"*/ + DCAM_IDPROP_SYNCREADOUT_SYSTEMBLANK = 0x00100290, /* R/W, mode, "SYNC READOUT SYSTEM BLANK" */ + + DCAM_IDPROP_TRIGGERENABLE_ACTIVE = 0x00100410, /* R/W, mode, "TRIGGER ENABLE ACTIVE" */ + DCAM_IDPROP_TRIGGERENABLE_POLARITY = 0x00100420, /* R/W, mode, "TRIGGER ENABLE POLARITY"*/ + + DCAM_IDPROP_TRIGGERNUMBER_FORFIRSTIMAGE = 0x00100810, /* R/O, long, "TRIGGER NUMBER FOR FIRST IMAGE" */ + DCAM_IDPROP_TRIGGERNUMBER_FORNEXTIMAGE = 0x00100820, /* R/O, long, "TRIGGER NUMBER FOR NEXT IMAGE" */ + + DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR = 0x001C0010, /* R/O, long, "NUMBER OF OUTPUT TRIGGER CONNECTOR"*/ + DCAM_IDPROP_OUTPUTTRIGGER_CHANNELSYNC = 0x001C0030, /* R/W, mode, "OUTPUT TRIGGER CHANNEL SYNC" */ + DCAM_IDPROP_OUTPUTTRIGGER_PROGRAMABLESTART = 0x001C0050, /* R/W, mode, "OUTPUT TRIGGER PROGRAMABLE START" */ + DCAM_IDPROP_OUTPUTTRIGGER_SOURCE = 0x001C0110, /* R/W, mode, "OUTPUT TRIGGER SOURCE" */ + DCAM_IDPROP_OUTPUTTRIGGER_POLARITY = 0x001C0120, /* R/W, mode, "OUTPUT TRIGGER POLARITY" */ + DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE = 0x001C0130, /* R/W, mode, "OUTPUT TRIGGER ACTIVE" */ + DCAM_IDPROP_OUTPUTTRIGGER_DELAY = 0x001C0140, /* R/W, sec, "OUTPUT TRIGGER DELAY" */ + DCAM_IDPROP_OUTPUTTRIGGER_PERIOD = 0x001C0150, /* R/W, sec, "OUTPUT TRIGGER PERIOD" */ + DCAM_IDPROP_OUTPUTTRIGGER_KIND = 0x001C0160, /* R/W, mode, "OUTPUT TRIGGER KIND" */ + DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR = 0x001C0170, /* R/W, mode, "OUTPUT TRIGGER BASE SENSOR" */ + DCAM_IDPROP_OUTPUTTRIGGER_PREHSYNCCOUNT = 0x001C0190, /* R/W, mode, "OUTPUT TRIGGER PRE HSYNC COUNT" */ + /* - 0x001C10FF for 16 output trigger connector, reserved */ + DCAM_IDPROP__OUTPUTTRIGGER = 0x00000100, /* the offset of ID for Nth OUTPUT TRIGGER parameter */ + + DCAM_IDPROP_MASTERPULSE_MODE = 0x001E0020, /* R/W, mode, "MASTER PULSE MODE" */ + DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE = 0x001E0030, /* R/W, mode, "MASTER PULSE TRIGGER SOURCE" */ + DCAM_IDPROP_MASTERPULSE_INTERVAL = 0x001E0040, /* R/W, sec, "MASTER PULSE INTERVAL" */ + DCAM_IDPROP_MASTERPULSE_BURSTTIMES = 0x001E0050, /* R/W, long, "MASTER PULSE BURST TIMES" */ + +/* Group: FEATURE */ + /* exposure period */ + DCAM_IDPROP_EXPOSURETIME = 0x001F0110, /* R/W, sec, "EXPOSURE TIME" */ + DCAM_IDPROP_EXPOSURETIME_CONTROL = 0x001F0130, /* R/W, mode, "EXPOSURE TIME CONTROL" */ + DCAM_IDPROP_TRIGGER_FIRSTEXPOSURE = 0x001F0200, /* R/W, mode, "TRIGGER FIRST EXPOSURE" */ + DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE = 0x001F0300, /* R/W, mode, "TRIGGER GLOBAL EXPOSURE" */ + DCAM_IDPROP_FIRSTTRIGGER_BEHAVIOR = 0x001F0310, /* R/W, mode, "FIRST TRIGGER BEHAVIOR" */ + DCAM_IDPROP_MULTIFRAME_EXPOSURE = 0x001F1000, /* R/W, sec, "MULTI FRAME EXPOSURE TIME" */ + /* - 0x001F1FFF for 256 MULTI FRAME */ + DCAM_IDPROP__MULTIFRAME = 0x00000010, /* the offset of ID for Nth MULTIFRAME */ + + /* anti-blooming */ + DCAM_IDPROP_LIGHTMODE = 0x00200110, /* R/W, mode, "LIGHT MODE" */ + /* 0x00200120 is reserved */ + + /* sensitivity */ + DCAM_IDPROP_SENSITIVITYMODE = 0x00200210, /* R/W, mode, "SENSITIVITY MODE" */ + DCAM_IDPROP_SENSITIVITY = 0x00200220, /* R/W, long, "SENSITIVITY" */ + + DCAM_IDPROP_DIRECTEMGAIN_MODE = 0x00200250, /* R/W, mode, "DIRECT EM GAIN MODE" */ + DCAM_IDPROP_EMGAINWARNING_STATUS = 0x00200260, /* R/O, mode, "EM GAIN WARNING STATUS"*/ + DCAM_IDPROP_EMGAINWARNING_LEVEL = 0x00200270, /* R/W, long, "EM GAIN WARNING LEVEL" */ + DCAM_IDPROP_EMGAINWARNING_ALARM = 0x00200280, /* R/W, mode, "EM GAIN WARNING ALARM" */ + DCAM_IDPROP_EMGAINPROTECT_MODE = 0x00200290, /* R/W, mode, "EM GAIN PROTECT MODE" */ + DCAM_IDPROP_EMGAINPROTECT_AFTERFRAMES = 0x002002A0, /* R/W, long, "EM GAIN PROTECT AFTER FRAMES" */ + + DCAM_IDPROP_MEASURED_SENSITIVITY = 0x002002B0, /* R/O, real, "MEASURED SENSITIVITY" */ + + DCAM_IDPROP_PHOTONIMAGINGMODE = 0x002002F0, /* R/W, mode, "PHOTON IMAGING MODE" */ + + /* sensor cooler */ + DCAM_IDPROP_SENSORTEMPERATURE = 0x00200310, /* R/O, celsius,"SENSOR TEMPERATURE" */ + DCAM_IDPROP_SENSORCOOLER = 0x00200320, /* R/W, mode, "SENSOR COOLER" */ + DCAM_IDPROP_SENSORTEMPERATURETARGET = 0x00200330, /* R/W, celsius,"SENSOR TEMPERATURE TARGET" */ + DCAM_IDPROP_SENSORCOOLERSTATUS = 0x00200340, /* R/O, mode, "SENSOR COOLER STATUS" */ + DCAM_IDPROP_SENSORCOOLERFAN = 0x00200350, /* R/W, mode, "SENSOR COOLER FAN" */ + DCAM_IDPROP_SENSORTEMPERATURE_AVE = 0x00200360, /* R/O, celsius,"SENSOR TEMPERATURE AVE" */ + DCAM_IDPROP_SENSORTEMPERATURE_MIN = 0x00200370, /* R/O, celsius,"SENSOR TEMPERATURE MIN" */ + DCAM_IDPROP_SENSORTEMPERATURE_MAX = 0x00200380, /* R/O, celsius,"SENSOR TEMPERATURE MAX" */ + DCAM_IDPROP_SENSORTEMPERATURE_STATUS = 0x00200390, /* R/O, mode, "SENSOR TEMPERATURE STATUS" */ + DCAM_IDPROP_SENSORTEMPERATURE_PROTECT = 0x00200400, /* R/W, mode, "SENSOR TEMPERATURE MODE" */ + + /* mechanical shutter */ + DCAM_IDPROP_MECHANICALSHUTTER = 0x00200410, /* R/W, mode, "MECHANICAL SHUTTER" */ +/* DCAM_IDPROP_MECHANICALSHUTTER_AUTOMODE = 0x00200420,*/ /* R/W, mode, "MECHANICAL SHUTTER AUTOMODE" */ /* reserved */ + + /* contrast enhance */ + DCAM_IDPROP_CONTRASTGAIN = 0x00300120, /* R/W, long, "CONTRAST GAIN" */ + DCAM_IDPROP_CONTRASTOFFSET = 0x00300130, /* R/W, long, "CONTRAST OFFSET" */ + /* 0x00300140 is reserved */ + DCAM_IDPROP_HIGHDYNAMICRANGE_MODE = 0x00300150, /* R/W, mode, "HIGH DYNAMIC RANGE MODE" */ + DCAM_IDPROP_DIRECTGAIN_MODE = 0x00300160, /* R/W, mode, "DIRECT GAIN MODE" */ + + DCAM_IDPROP_REALTIMEGAINCORRECT_MODE = 0x00300170, /* R/W, mode, "REALTIME GAIN CORRECT MODE" */ + DCAM_IDPROP_REALTIMEGAINCORRECT_LEVEL = 0x00300180, /* R/W, mode, "REALTIME GAIN CORRECT LEVEL" */ + DCAM_IDPROP_REALTIMEGAINCORRECT_INTERVAL = 0x00300190, /* R/W, mode, "REALTIME GAIN CORRECT INTERVAL" */ + DCAM_IDPROP_NUMBEROF_REALTIMEGAINCORRECTREGION=0x003001A0, /* R/W, long, "NUMBER OF REALTIME GAIN CORRECT REGION"*/ + + /* color features */ + DCAM_IDPROP_VIVIDCOLOR = 0x00300200, /* R/W, mode, "VIVID COLOR" */ /*[C7780]*/ + DCAM_IDPROP_WHITEBALANCEMODE = 0x00300210, /* R/W, mode, "WHITEBALANCE MODE" */ + DCAM_IDPROP_WHITEBALANCETEMPERATURE = 0x00300220, /* R/W, color-temp., "WHITEBALANCE TEMPERATURE" */ + DCAM_IDPROP_WHITEBALANCEUSERPRESET = 0x00300230, /* R/W, long, "WHITEBALANCE USER PRESET" */ + /* 0x00300310 is reserved */ + + DCAM_IDPROP_REALTIMEGAINCORRECTREGION_HPOS = 0x00301000, /* R/W, long, "REALTIME GAIN CORRECT REGION HPOS" */ + DCAM_IDPROP_REALTIMEGAINCORRECTREGION_HSIZE = 0x00302000, /* R/W, long, "REALTIME GAIN CORRECT REGION HSIZE" */ + + DCAM_IDPROP__REALTIMEGAINCORRECTIONREGION = 0x00000010, /* the offset of ID for Nth REALTIME GAIN CORRECT REGION parameter */ + +/* Group: ALU */ + /* ALU */ + DCAM_IDPROP_INTERFRAMEALU_ENABLE = 0x00380010, /* R/W, mode, "INTERFRAME ALU ENABLE" */ + DCAM_IDPROP_RECURSIVEFILTER = 0x00380110, /* R/W, mode, "RECURSIVE FILTER" */ + DCAM_IDPROP_RECURSIVEFILTERFRAMES = 0x00380120, /* R/W, long, "RECURSIVE FILTER FRAMES"*/ + DCAM_IDPROP_SPOTNOISEREDUCER = 0x00380130, /* R/W, mode, "SPOT NOISE REDUCER" */ + DCAM_IDPROP_SUBTRACT = 0x00380210, /* R/W, mode, "SUBTRACT" */ + DCAM_IDPROP_SUBTRACTIMAGEMEMORY = 0x00380220, /* R/W, mode, "SUBTRACT IMAGE MEMORY" */ + DCAM_IDPROP_STORESUBTRACTIMAGETOMEMORY = 0x00380230, /* W/O, mode, "STORE SUBTRACT IMAGE TO MEMORY" */ + DCAM_IDPROP_SUBTRACTOFFSET = 0x00380240, /* R/W, long "SUBTRACT OFFSET" */ + DCAM_IDPROP_DARKCALIB_STABLEMAXINTENSITY = 0x00380250, /* R/W, long, "DARKCALIB STABLE MAX INTENSITY" */ + DCAM_IDPROP_SUBTRACT_DATASTATUS = 0x003802F0, /* R/W mode, "SUBTRACT DATA STATUS" */ + DCAM_IDPROP_SHADINGCALIB_DATASTATUS = 0x00380300, /* R/W mode, "SHADING CALIB DATA STATUS" */ + DCAM_IDPROP_SHADINGCORRECTION = 0x00380310, /* R/W, mode, "SHADING CORRECTION" */ + DCAM_IDPROP_SHADINGCALIBDATAMEMORY = 0x00380320, /* R/W, mode, "SHADING CALIB DATA MEMORY" */ + DCAM_IDPROP_STORESHADINGCALIBDATATOMEMORY = 0x00380330, /* W/O, mode, "STORE SHADING DATA TO MEMORY" */ + DCAM_IDPROP_SHADINGCALIB_METHOD = 0x00380340, /* R/W, mode, "SHADING CALIB METHOD" */ + DCAM_IDPROP_SHADINGCALIB_TARGET = 0x00380350, /* R/W, long, "SHADING CALIB TARGET" */ + DCAM_IDPROP_SHADINGCALIB_STABLEMININTENSITY = 0x00380360, /* R/W, long, "SHADING CALIB STABLE MIN INTENSITY" */ + DCAM_IDPROP_SHADINGCALIB_SAMPLES = 0x00380370, /* R/W, long, "SHADING CALIB SAMPLES" */ + DCAM_IDPROP_SHADINGCALIB_STABLESAMPLES = 0x00380380, /* R/W, long, "SHADING CALIB STABLE SAMPLES" */ + DCAM_IDPROP_SHADINGCALIB_STABLEMAXERRORPERCENT=0x00380390, /* R/W, long, "SHADING CALIB STABLE MAX ERROR PERCENT" */ + DCAM_IDPROP_FRAMEAVERAGINGMODE = 0x003803A0, /* R/W, mode, "FRAME AVERAGING MODE" */ + DCAM_IDPROP_FRAMEAVERAGINGFRAMES = 0x003803B0, /* R/W, long, "FRAME AVERAGING FRAMES"*/ + DCAM_IDPROP_DARKCALIB_STABLESAMPLES = 0x003803C0, /* R/W, long, "DARKCALIB STABLE SAMPLES" */ + DCAM_IDPROP_DARKCALIB_SAMPLES = 0x003803D0, /* R/W, long, "DARKCALIB SAMPLES" */ + DCAM_IDPROP_DARKCALIB_TARGET = 0x003803E0, /* R/W, long, "DARKCALIB TARGET" */ + DCAM_IDPROP_CAPTUREMODE = 0x00380410, /* R/W, mode, "CAPTURE MODE" */ + DCAM_IDPROP_LINEAVERAGING = 0x00380450, /* R/W, long, "LINE AVERAGING" */ + DCAM_IDPROP_INTENSITYLUT_MODE = 0x00380510, /* R/W, mode, "INTENSITY LUT MODE" */ + DCAM_IDPROP_INTENSITYLUT_PAGE = 0x00380520, /* R/W, long, "INTENSITY LUT PAGE" */ + DCAM_IDPROP_INTENSITYLUT_WHITECLIP = 0x00380530, /* R/W, long, "INTENSITY LUT WHITE CLIP" */ + DCAM_IDPROP_INTENSITYLUT_BLACKCLIP = 0x00380540, /* R/W, long, "INTENSITY LUT BLACK CLIP" */ + DCAM_IDPROP_INTENSITY_GAMMA = 0x00380560, /* R/W, real, "INTENSITY GAMMA" */ + DCAM_IDPROP_SENSORGAPCORRECT_MODE = 0x00380620, /* R/W, long, "SENSOR GAP CORRECT MODE" */ + DCAM_IDPROP_ADVANCEDEDGEENHANCEMENT_MODE = 0x00380630, /* R/W, mode, "ADVANCED EDGE ENHANCEMENT MODE" */ + DCAM_IDPROP_ADVANCEDEDGEENHANCEMENT_LEVEL = 0x00380640, /* R/W, long, "ADVANCED EDGE ENHANCEMENT LEVEL" */ + + /* TAP CALIBRATION */ + DCAM_IDPROP_TAPGAINCALIB_METHOD = 0x00380F10, /* R/W, mode, "TAP GAIN CALIB METHOD" */ + DCAM_IDPROP_TAPCALIB_BASEDATAMEMORY = 0x00380F20, /* R/W, mode, "TAP CALIB BASE DATA MEMORY"*/ + DCAM_IDPROP_STORETAPCALIBDATATOMEMORY = 0x00380F30, /* W/O, mode, "STORE TAP CALIB DATA TO MEMORY"*/ + DCAM_IDPROP_TAPCALIBDATAMEMORY = 0x00380F40, /* W/O, mode, "TAP CALIB DATA MEMORY" */ + DCAM_IDPROP_NUMBEROF_TAPCALIB = 0x00380FF0, /* R/W, long, "NUMBER OF TAP CALIB" */ + DCAM_IDPROP_TAPCALIB_GAIN = 0x00381000, /* R/W, mode, "TAP CALIB GAIN" */ + DCAM_IDPROP_TAPCALIB_OFFSET = 0x00382000, /* R/W, mode, "TAP CALIB OFFSET" */ + DCAM_IDPROP__TAPCALIB = 0x00000010, /* the offset of ID for Nth TAPCALIB */ + +/* Group: READOUT */ + /* readout speed */ + DCAM_IDPROP_READOUTSPEED = 0x00400110, /* R/W, long, "READOUT SPEED" */ + /* 0x00400120 is reserved */ + DCAM_IDPROP_READOUT_DIRECTION = 0x00400130, /* R/W, mode, "READOUT DIRECTION" */ + DCAM_IDPROP_READOUT_UNIT = 0x00400140, /* R/O, mode, "READOUT UNIT" */ + + DCAM_IDPROP_SHUTTER_MODE = 0x00400150, /* R/W, mode, "SHUTTER MODE" */ + + /* sensor mode */ + DCAM_IDPROP_SENSORMODE = 0x00400210, /* R/W, mode, "SENSOR MODE" */ + DCAM_IDPROP_SENSORMODE_SLITHEIGHT = 0x00400220, /* R/W, long, "SENSOR MODE SLIT HEIGHT" */ /* reserved */ + DCAM_IDPROP_SENSORMODE_LINEBUNDLEHEIGHT = 0x00400250, /* R/W, long, "SENSOR MODE LINE BUNDLEHEIGHT" */ + DCAM_IDPROP_SENSORMODE_PANORAMICSTARTV = 0x00400280, /* R/W, long, "SENSOR MODE PANORAMIC START V" */ + + /* other readout mode */ + DCAM_IDPROP_CCDMODE = 0x00400310, /* R/W, mode, "CCD MODE" */ + DCAM_IDPROP_EMCCD_CALIBRATIONMODE = 0x00400320, /* R/W, mode, "EM CCD CALIBRATION MODE" */ + DCAM_IDPROP_CMOSMODE = 0x00400350, /* R/W, mode, "CMOS MODE" */ + + /* output mode */ + DCAM_IDPROP_OUTPUT_INTENSITY = 0x00400410, /* R/W, mode, "OUTPUT INTENSITY" */ + DCAM_IDPROP_OUTPUTDATA_ORIENTATION = 0x00400420, /* R/W, mode, "OUTPUT DATA ORIENTATION" */ /* reserved */ + DCAM_IDPROP_OUTPUTDATA_ROTATION = 0x00400430, /* R/W, degree, "OUTPUT DATA ROTATION" */ /* reserved */ + DCAM_IDPROP_OUTPUTDATA_OPERATION = 0x00400440, /* R/W, mode, "OUTPUT DATA OPERATION" */ + + DCAM_IDPROP_TESTPATTERN_KIND = 0x00400510, /* R/W, mode, "TEST PATTERN KIND" */ + DCAM_IDPROP_TESTPATTERN_OPTION = 0x00400520, /* R/W, long, "TEST PATTERN OPTION" */ + + DCAM_IDPROP_EXTRACTION_MODE = 0x00400620, /* R/W mode, "EXTRACTION MODE "*/ + +/* Group: ROI */ + /* binning and subarray */ + DCAM_IDPROP_BINNING = 0x00401110, /* R/W, mode, "BINNING" */ + DCAM_IDPROP_BINNING_INDEPENDENT = 0x00401120, /* R/W, mode, "BINNING INDEPENDENT" */ + DCAM_IDPROP_BINNING_HORZ = 0x00401130, /* R/W, long, "BINNING HORZ" */ + DCAM_IDPROP_BINNING_VERT = 0x00401140, /* R/W, long, "BINNING VERT" */ + DCAM_IDPROP_SUBARRAYHPOS = 0x00402110, /* R/W, long, "SUBARRAY HPOS" */ + DCAM_IDPROP_SUBARRAYHSIZE = 0x00402120, /* R/W, long, "SUBARRAY HSIZE" */ + DCAM_IDPROP_SUBARRAYVPOS = 0x00402130, /* R/W, long, "SUBARRAY VPOS" */ + DCAM_IDPROP_SUBARRAYVSIZE = 0x00402140, /* R/W, long, "SUBARRAY VSIZE" */ + DCAM_IDPROP_SUBARRAYMODE = 0x00402150, /* R/W, mode, "SUBARRAY MODE" */ + DCAM_IDPROP_DIGITALBINNING_METHOD = 0x00402160, /* R/W, mode, "DIGITALBINNING METHOD" */ + DCAM_IDPROP_DIGITALBINNING_HORZ = 0x00402170, /* R/W, long, "DIGITALBINNING HORZ" */ + DCAM_IDPROP_DIGITALBINNING_VERT = 0x00402180, /* R/W, long, "DIGITALBINNING VERT" */ + +/* Group: TIMING */ + /* synchronous timing */ + DCAM_IDPROP_TIMING_READOUTTIME = 0x00403010, /* R/O, sec, "TIMING READOUT TIME" */ + DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD = 0x00403020, /* R/O, sec, "TIMING CYCLIC TRIGGER PERIOD" */ + DCAM_IDPROP_TIMING_MINTRIGGERBLANKING = 0x00403030, /* R/O, sec, "TIMING MINIMUM TRIGGER BLANKING" */ + /* 0x00403040 is reserved */ + DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL = 0x00403050, /* R/O, sec, "TIMING MINIMUM TRIGGER INTERVAL" */ + DCAM_IDPROP_TIMING_EXPOSURE = 0x00403060, /* R/O, mode, "TIMING EXPOSURE" */ + DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD = 0x00403070, /* R/O, sec, "INVALID EXPOSURE PERIOD" */ + DCAM_IDPROP_TIMING_FRAMESKIPNUMBER = 0x00403080, /* R/W, long, "TIMING FRAME SKIP NUMBER" */ + DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY = 0x00403090, /* R/O, sec, "TIMING GLOBAL EXPOSURE DELAY" */ + + DCAM_IDPROP_INTERNALFRAMERATE = 0x00403810, /* R/W, 1/sec, "INTERNAL FRAME RATE" */ + DCAM_IDPROP_INTERNAL_FRAMEINTERVAL = 0x00403820, /* R/W, sec, "INTERNAL FRAME INTERVAL" */ + DCAM_IDPROP_INTERNALLINERATE = 0x00403830, /* R/W, 1/sec, "INTERNAL LINE RATE" */ + DCAM_IDPROP_INTERNALLINESPEED = 0x00403840, /* R/W, m/sec, "INTERNAL LINE SPEEED" */ + DCAM_IDPROP_INTERNAL_LINEINTERVAL = 0x00403850, /* R/W, sec, "INTERNAL LINE INTERVAL" */ + + /* system information */ + + DCAM_IDPROP_TIMESTAMP_PRODUCER = 0x00410A10, /* R/O, mode, "TIME STAMP PRODUCER" */ + DCAM_IDPROP_FRAMESTAMP_PRODUCER = 0x00410A20, /* R/O, mode, "FRAME STAMP PRODUCER" */ + + DCAM_IDPROP_TRANSFERINFO_FRAMECOUNT = 0x00410B10, /* R/O, long, "TRANSFER INFO FRAME COUNT" */ + DCAM_IDPROP_TRANSFERINFO_LOSTCOUNT = 0x00410B11, /* R/O, long, "TRANSFER INFO LOST COUNT" */ + +/* Group: READOUT */ + + /* image information */ + /* 0x00420110 is reserved */ + DCAM_IDPROP_COLORTYPE = 0x00420120, /* R/W, mode, "COLORTYPE" */ + DCAM_IDPROP_BITSPERCHANNEL = 0x00420130, /* R/W, long, "BIT PER CHANNEL" */ + /* 0x00420140 is reserved */ + /* 0x00420150 is reserved */ + + DCAM_IDPROP_NUMBEROF_CHANNEL = 0x00420180, /* R/O, long, "NUMBER OF CHANNEL" */ + DCAM_IDPROP_ACTIVE_CHANNELINDEX = 0x00420190, /* R/W, mode, "ACTIVE CHANNEL INDEX" */ + DCAM_IDPROP_NUMBEROF_VIEW = 0x004201C0, /* R/O, long, "NUMBER OF VIEW" */ + DCAM_IDPROP_ACTIVE_VIEWINDEX = 0x004201D0, /* R/W, mode, "ACTIVE VIEW INDEX" */ + + DCAM_IDPROP_IMAGE_WIDTH = 0x00420210, /* R/O, long, "IMAGE WIDTH" */ + DCAM_IDPROP_IMAGE_HEIGHT = 0x00420220, /* R/O, long, "IMAGE HEIGHT" */ + DCAM_IDPROP_IMAGE_ROWBYTES = 0x00420230, /* R/O, long, "IMAGE ROWBYTES" */ + DCAM_IDPROP_IMAGE_FRAMEBYTES = 0x00420240, /* R/O, long, "IMAGE FRAMEBYTES" */ + DCAM_IDPROP_IMAGE_TOPOFFSETBYTES = 0x00420250, /* R/O, long, "IMAGE TOP OFFSET BYTES"*/ + DCAM_IDPROP_IMAGE_PIXELTYPE = 0x00420270, /* R/W, DCAM_PIXELTYPE, "IMAGE PIXEL TYPE" */ + DCAM_IDPROP_IMAGE_CAMERASTAMP = 0x00420300, /* R/W, long, "IMAGE CAMERA STAMP" */ + + DCAM_IDPROP_BUFFER_ROWBYTES = 0x00420330, /* R/O, long, "BUFFER ROWBYTES" */ /* dcambuf_attach() */ + DCAM_IDPROP_BUFFER_FRAMEBYTES = 0x00420340, /* R/O, long, "BUFFER FRAME BYTES" */ /* dcambuf_attach() */ + DCAM_IDPROP_BUFFER_TOPOFFSETBYTES = 0x00420350, /* R/O, long, "BUFFER TOP OFFSET BYTES" */ /* dcambuf_attach() */ + DCAM_IDPROP_BUFFER_PIXELTYPE = 0x00420360, /* R/O, DCAM_PIXELTYPE, "BUFFER PIXEL TYPE" */ /* dcambuf_attach() */ + + DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE = 0x00420410, /* R/O, long "RECORD FIXED BYTES PER FILE" */ + DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION = 0x00420420, /* R/O, long "RECORD FIXED BYTES PER SESSION"*/ + DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME = 0x00420430, /* R/O, long "RECORD FIXED BYTES PER FRAME" */ + + DCAM_IDPROP_IMAGEDETECTOR_PIXELWIDTH = 0x00420810, /* R/O, micro-meter, "IMAGE DETECTOR PIXEL WIDTH" */ /* reserved */ + DCAM_IDPROP_IMAGEDETECTOR_PIXELHEIGHT = 0x00420820, /* R/O, micro-meter, "IMAGE DETECTOR PIXEL HEIGHT" */ /* reserved */ + + /* frame bundle */ + DCAM_IDPROP_FRAMEBUNDLE_MODE = 0x00421010, /* R/W, mode, "FRAMEBUNDLE MODE" */ + DCAM_IDPROP_FRAMEBUNDLE_NUMBER = 0x00421020, /* R/W, long, "FRAMEBUNDLE NUMBER" */ + DCAM_IDPROP_FRAMEBUNDLE_ROWBYTES = 0x00421030, /* R/O, long, "FRAMEBUNDLE ROWBYTES" */ + DCAM_IDPROP_FRAMEBUNDLE_FRAMESTEPBYTES = 0x00421040, /* R/O, long, "FRAMEBUNDLE FRAME STEP BYTES" */ + + /* partial area */ + DCAM_IDPROP_NUMBEROF_PARTIALAREA = 0x00430010, /* R/W, long, "NUMBER OF PARTIAL AREA"*/ + DCAM_IDPROP_PARTIALAREA_HPOS = 0x00431000, /* R/W, long, "PARTIAL AREA HPOS" */ + DCAM_IDPROP_PARTIALAREA_HSIZE = 0x00432000, /* R/W, long, "PARTIAL AREA HSIZE" */ + DCAM_IDPROP_PARTIALAREA_VPOS = 0x00433000, /* R/W, long, "PARTIAL AREA VPOS" */ + DCAM_IDPROP_PARTIALAREA_VSIZE = 0x00434000, /* R/W, long, "PARTIAL AREA VSIZE" */ + DCAM_IDPROP__PARTIALAREA = 0x00000010, /* the offset of ID for Nth PARTIAL AREA */ + + /* multi line */ + DCAM_IDPROP_NUMBEROF_MULTILINE = 0x0044F010, /* R/W, long, "NUMBER OF MULTI LINE" */ + DCAM_IDPROP_MULTILINE_VPOS = 0x00450000, /* R/W, long, "MULTI LINE VPOS" */ + DCAM_IDPROP_MULTILINE_VSIZE = 0x00460000, /* R/W, long, "MULTI LINE VSIZE" */ + /* - 0x0046FFFF for 4096 MULTI LINEs */ /* reserved */ + DCAM_IDPROP__MULTILINE = 0x00000010, /* the offset of ID for Nth MULTI LINE */ + + /* defect */ + DCAM_IDPROP_DEFECTCORRECT_MODE = 0x00470010, /* R/W, mode, "DEFECT CORRECT MODE" */ + DCAM_IDPROP_NUMBEROF_DEFECTCORRECT = 0x00470020, /* R/W, long, "NUMBER OF DEFECT CORRECT" */ + DCAM_IDPROP_HOTPIXELCORRECT_LEVEL = 0x00470030, /* R/W, mode, "HOT PIXEL CORRECT LEVEL" */ + DCAM_IDPROP_DEFECTCORRECT_HPOS = 0x00471000, /* R/W, long, "DEFECT CORRECT HPOS" */ + DCAM_IDPROP_DEFECTCORRECT_METHOD = 0x00473000, /* R/W, mode, "DEFECT CORRECT METHOD" */ + /* - 0x0047FFFF for 256 DEFECT */ + DCAM_IDPROP__DEFECTCORRECT = 0x00000010, /* the offset of ID for Nth DEFECT */ + +/* Group: device buffer countrol */ + DCAM_IDPROP_DEVICEBUFFER_MODE = 0x00490000, /* R/W, mode, "DEVICE BUFFER MODE" */ + DCAM_IDPROP_DEVICEBUFFER_FRAMECOUNTMAX = 0x00490020, /* R/O, long, "DEVICE BUFFER FRAME COUNT MAX" */ + +/* Group: CALIBREGION */ + DCAM_IDPROP_CALIBREGION_MODE = 0x00402410, /* R/W, mode, "CALIBRATE REGION MODE" */ + DCAM_IDPROP_NUMBEROF_CALIBREGION = 0x00402420, /* R/W, long, "NUMBER OF CALIBRATE REGION"*/ + DCAM_IDPROP_CALIBREGION_HPOS = 0x004B0000, /* R/W, long, "CALIBRATE REGION HPOS" */ + DCAM_IDPROP_CALIBREGION_HSIZE = 0x004B1000, /* R/W, long, "CALIBRATE REGION HSIZE" */ + /* - 0x0048FFFF for 256 REGIONs at least */ + DCAM_IDPROP__CALIBREGION = 0x00000010, /* the offset of ID for Nth REGION */ + +/* Group: MASKREGION */ + DCAM_IDPROP_MASKREGION_MODE = 0x00402510, /* R/W, mode, "MASK REGION MODE" */ + DCAM_IDPROP_NUMBEROF_MASKREGION = 0x00402520, /* R/W, long, "NUMBER OF MASK REGION" */ + DCAM_IDPROP_MASKREGION_HPOS = 0x004C0000, /* R/W, long, "MASK REGION HPOS" */ + DCAM_IDPROP_MASKREGION_HSIZE = 0x004C1000, /* R/W, long, "MASK REGION HSIZE" */ + /* - 0x0048FFFF for 256 REGIONs at least */ + DCAM_IDPROP__MASKREGION = 0x00000010, /* the offset of ID for Nth REGION */ + +/* Group: Camera Status */ + DCAM_IDPROP_CAMERASTATUS_INTENSITY = 0x004D1110, /* R/O, mode, "CAMERASTATUS INTENSITY" */ + DCAM_IDPROP_CAMERASTATUS_INPUTTRIGGER = 0x004D1120, /* R/O, mode, "CAMERASTATUS INPUT TRIGGER"*/ + DCAM_IDPROP_CAMERASTATUS_CALIBRATION = 0x004D1130, /* R/O, mode, "CAMERASTATUS CALIBRATION" */ + +/* Group: Back Focus Position */ + DCAM_IDPROP_BACKFOCUSPOS_TARGET = 0x00804010, /* R/W, micro-meter,"BACK FOCUS POSITION TARGET" */ + DCAM_IDPROP_BACKFOCUSPOS_CURRENT = 0x00804020, /* R/O, micro-meter,"BACK FOCUS POSITION CURRENT" */ + DCAM_IDPROP_BACKFOCUSPOS_LOADFROMMEMORY = 0x00804050, /* R/W, long, "BACK FOCUS POSITION LOAD FROM MEMORY"*/ + DCAM_IDPROP_BACKFOCUSPOS_STORETOMEMORY = 0x00804060, /* W/O, long, "BACK FOCUS POSITION STORE TO MEMORY" */ + +/* Group: MAICO */ + DCAM_IDPROP_CONFOCAL_SCANMODE = 0x00910010, /* R/W, mode, "CONFOCAL SCAN MODE" */ + DCAM_IDPROP_CONFOCAL_SCANLINES = 0x00910020, /* R/W, long, "CONFOCAL SCANLINES" */ + DCAM_IDPROP_CONFOCAL_ZOOM = 0x00910030, /* R/W, long, "CONFOCAL ZOOM" */ + DCAM_IDPROP_SUBUNIT_IMAGEWIDTH = 0x009100e0, /* R/O, long, "SUBUNIT IMAGE WIDTH */ + + DCAM_IDPROP_NUMBEROF_SUBUNIT = 0x009100f0, /* R/O, long, "NUMBER OF SUBUNIT" */ + DCAM_IDPROP_SUBUNIT_CONTROL = 0x00910100, /* R/W, mode, "SUBUNIT CONTROL" */ + DCAM_IDPROP_SUBUNIT_LASERPOWER = 0x00910200, /* R/W, long, "SUBUNIT LASERPOWER" */ + DCAM_IDPROP_SUBUNIT_PMTGAIN = 0x00910300, /* R/W, real, "SUBUNIT PMTGAIN" */ + DCAM_IDPROP_SUBUNIT_PINHOLESIZE = 0x00910400, /* R/O, long, "SUBUNIT PINHOLE SIZE" */ + DCAM_IDPROP_SUBUNIT_WAVELENGTH = 0x00910500, /* R/O, long, "SUBUNIT WAVELENGTH" */ + DCAM_IDPROP_SUBUNIT_TOPOFFSETBYTES = 0x00910600, /* R/O, long, "SUBUNIT TOP OFFSET BYTES" */ + + DCAM_IDPROP__SUBUNIT = 0x00000010, /* the offset of ID for Nth Subunit parameter */ + +/* Group: SYSTEM */ + /* system property */ + + DCAM_IDPROP_SYSTEM_ALIVE = 0x00FF0010, /* R/O, mode, "SYSTEM ALIVE" */ + + DCAM_IDPROP_CONVERSIONFACTOR_COEFF = 0x00FFE010, /* R/O, double, "CONVERSION FACTOR COEFF" */ + DCAM_IDPROP_CONVERSIONFACTOR_OFFSET = 0x00FFE020, /* R/O, double, "CONVERSION FACTOR OFFSET" */ + + /*-- options --*/ + + /* option */ + DCAM_IDPROP__RATIO = 0x80000000, + DCAM_IDPROP_EXPOSURETIME_RATIO = DCAM_IDPROP__RATIO | DCAM_IDPROP_EXPOSURETIME, /* reserved */ + /* R/W, real, "EXPOSURE TIME RATIO" */ /* reserved */ + DCAM_IDPROP_CONTRASTGAIN_RATIO = DCAM_IDPROP__RATIO | DCAM_IDPROP_CONTRASTGAIN, /* reserved */ + /* R/W, real, "CONTRAST GAIN RATIO" */ /* reserved */ + + DCAM_IDPROP__CHANNEL = 0x00000001, + DCAM_IDPROP__VIEW = 0x01000000, + + DCAM_IDPROP__MASK_CHANNEL = 0x0000000F, + DCAM_IDPROP__MASK_VIEW = 0x0F000000, + DCAM_IDPROP__MASK_BODY = 0x00FFFFF0, + + /* for backward compativilities */ + DCAMPROP_ATTR_REMOTE_VALUE = DCAMPROP_ATTR_VOLATILE, + + DCAMPROP_PHOTONIMAGING_MODE__0 = DCAMPROP_PHOTONIMAGINGMODE__0, + DCAMPROP_PHOTONIMAGING_MODE__1 = DCAMPROP_PHOTONIMAGINGMODE__1, + DCAMPROP_PHOTONIMAGING_MODE__2 = DCAMPROP_PHOTONIMAGINGMODE__2, + + DCAM_IDPROP_SCAN_MODE = DCAM_IDPROP_SENSORMODE, + DCAM_IDPROP_SLITSCAN_HEIGHT = DCAM_IDPROP_SENSORMODE_SLITHEIGHT, + + DCAM_IDPROP_FRAME_BUNDLEMODE = DCAM_IDPROP_FRAMEBUNDLE_MODE, + DCAM_IDPROP_FRAME_BUNDLENUMBER = DCAM_IDPROP_FRAMEBUNDLE_NUMBER, + DCAM_IDPROP_FRAME_BUNDLEROWBYTES= DCAM_IDPROP_FRAMEBUNDLE_ROWBYTES, + + DCAM_IDPROP_ACTIVE_VIEW = DCAM_IDPROP_ACTIVE_VIEWINDEX, /* reserved */ + DCAM_IDPROP_ACTIVE_VIEWINDEXES = DCAM_IDPROP_ACTIVE_VIEWINDEX, /* reserved */ +/* DCAM_IDPROP_SYNC_FRAMEREADOUTTIME=DCAM_IDPROP_TIMING_READOUTTIME, */ /* reserved */ +/* DCAM_IDPROP_SYNC_CYCLICTRIGGERPERIOD = DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD, */ /* reserved */ + DCAM_IDPROP_SYNC_MINTRIGGERBLANKING = DCAM_IDPROP_TIMING_MINTRIGGERBLANKING, + DCAM_IDPROP_SYNC_FRAMEINTERVAL = DCAM_IDPROP_INTERNAL_FRAMEINTERVAL, + DCAM_IDPROP_LOWLIGHTSENSITIVITY = DCAM_IDPROP_PHOTONIMAGINGMODE, + + DCAM_IDPROP_DARKCALIB_MAXIMUMINTENSITY = DCAM_IDPROP_DARKCALIB_STABLEMAXINTENSITY, + DCAM_IDPROP_SUBTRACT_SAMPLINGCOUNT = DCAM_IDPROP_DARKCALIB_SAMPLES, + + DCAM_IDPROP_SHADINGCALIB_MINIMUMINTENSITY = DCAM_IDPROP_SHADINGCALIB_STABLEMININTENSITY, + DCAM_IDPROP_SHADINGCALIB_STABLEFRAMECOUNT = DCAM_IDPROP_SHADINGCALIB_STABLESAMPLES, + DCAM_IDPROP_SHADINGCALIB_INTENSITYMAXIMUMERRORPERCENTAGE = DCAM_IDPROP_SHADINGCALIB_STABLEMAXERRORPERCENT, + DCAM_IDPROP_SHADINGCALIB_AVERAGEFRAMECOUNT = DCAM_IDPROP_SHADINGCALIB_SAMPLES, + + _end_of_dcam_idprop = 0 +} DCAMIDPROP; + +#define DCAM_IDPROP_CHANNEL_(ch,id) ((DCAMIDPROP)( ch * DCAM_IDPROP__CHANNEL + (int32)id )) +#define DCAM_IDPROP_CHANNEL_R_(id) DCAM_IDPROP_CHANNEL_(1,id) +#define DCAM_IDPROP_CHANNEL_G_(id) DCAM_IDPROP_CHANNEL_(2,id) +#define DCAM_IDPROP_CHANNEL_B_(id) DCAM_IDPROP_CHANNEL_(3,id) + +#define DCAM_IDPROP_VIEW_(view,id) ((DCAMIDPROP)( view * DCAM_IDPROP__VIEW + (int32)id )) + +/* **************************************************************** */ + +#ifdef __cplusplus +/* end of extern "C" */ +}; + +#endif + +#define _INCLUDE_DCAMPROP_H_ +#endif diff --git a/support/dcamsdk4/lib/.DS_Store b/support/dcamsdk4/lib/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..1be736b778fd282d1bac81f6d5932664c14decd7 GIT binary patch literal 6148 zcmeHKJ5EC}5S%4JibRu=(pTUkYAXsS-~tHJAVs7=DDA5_7e~wNhvMl86bc$LE3L;~ z@7VGbZ{Gs2)%)fOSOQqk9r5AA)O_E4VrLa`v^e8>^Y*-b+U>Sn9%s%y#~v?u#SKRM zukamie|_w6mn%yONC7Dz1*E_UDo{mwadCog*OR4y6!=*I|2{OjV=o*MQsA!@H~^7v8883< literal 0 HcmV?d00001 diff --git a/support/dcamsdk4/lib/win32/dcamapi.lib b/support/dcamsdk4/lib/win32/dcamapi.lib new file mode 100644 index 0000000000000000000000000000000000000000..824b5dcd675e195eadb8b813ade1bd2e699b0c52 GIT binary patch literal 26828 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 + +#ifndef ASSERT +#define ASSERT(c) +#endif + +// ---------------------------------------------------------------- + +inline const int my_dcamdev_string( DCAMERR& err, HDCAM hdcam, int32 idStr, char* text, int32 textbytes ) +{ + DCAMDEV_STRING param; + memset( ¶m, 0, sizeof(param) ); + param.size = sizeof(param); + param.text = text; + param.textbytes = textbytes; + param.iString = idStr; + + err = dcamdev_getstring( hdcam, ¶m ); + return ! failed( err ); +} + +// ---------------------------------------------------------------- + +void dcamcon_show_dcamerr( HDCAM hdcam, DCAMERR errid, const char* apiname, const char* fmt, ... ) +{ + char errtext[ 256 ]; + + DCAMERR err; + my_dcamdev_string( err, hdcam, errid, errtext, sizeof(errtext) ); + + printf( "FAILED: (DCAMERR)0x%08X %s @ %s", errid, errtext, apiname ); + + if( fmt != NULL ) + { + printf( " : " ); + + va_list arg; + va_start(arg,fmt); + vprintf( fmt, arg ); + va_end(arg); + } + + printf( "\n" ); +} + +// ---------------------------------------------------------------- + +void dcamcon_show_dcamdev_info( HDCAM hdcam ) +{ + char model[ 256 ]; + char cameraid[ 64 ]; + char bus[ 64 ]; + + DCAMERR err; + if( ! my_dcamdev_string( err, hdcam, DCAM_IDSTR_MODEL, model, sizeof(model) ) ) + { + dcamcon_show_dcamerr( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_MODEL)\n" ); + } + else + if( ! my_dcamdev_string( err, hdcam, DCAM_IDSTR_CAMERAID, cameraid, sizeof(cameraid)) ) + { + dcamcon_show_dcamerr( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_CAMERAID)\n" ); + } + else + if( ! my_dcamdev_string( err, hdcam, DCAM_IDSTR_BUS, bus, sizeof(bus) ) ) + { + dcamcon_show_dcamerr( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_BUS)\n" ); + } + else + { + printf( "%s (%s) on %s\n", model, cameraid, bus ); + } +} + +// show HDCAM camera information by text. +void dcamcon_show_dcamdev_info_detail( HDCAM hdcam ) +{ + char buf[ 256 ]; + + DCAMERR err; + if( ! my_dcamdev_string( err, hdcam, DCAM_IDSTR_VENDOR, buf, sizeof(buf) ) ) + dcamcon_show_dcamerr( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_VENDOR)\n" ); + else + printf( "DCAM_IDSTR_VENDOR = %s\n", buf ); + + if( ! my_dcamdev_string( err, hdcam, DCAM_IDSTR_MODEL, buf, sizeof(buf) ) ) + dcamcon_show_dcamerr( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_MODEL)\n" ); + else + printf( "DCAM_IDSTR_MODEL = %s\n", buf ); + + if( ! my_dcamdev_string( err, hdcam, DCAM_IDSTR_CAMERAID, buf, sizeof(buf) ) ) + dcamcon_show_dcamerr( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_CAMERAID)\n" ); + else + printf( "DCAM_IDSTR_CAMERAID = %s\n", buf ); + + if( ! my_dcamdev_string( err, hdcam, DCAM_IDSTR_BUS, buf, sizeof(buf) ) ) + dcamcon_show_dcamerr( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_BUS)\n" ); + else + printf( "DCAM_IDSTR_BUS = %s\n", buf ); + + + if( ! my_dcamdev_string( err, hdcam, DCAM_IDSTR_CAMERAVERSION, buf, sizeof(buf) ) ) + dcamcon_show_dcamerr( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_CAMERAVERSION)\n" ); + else + printf( "DCAM_IDSTR_CAMERAVERSION = %s\n", buf ); + + if( ! my_dcamdev_string( err, hdcam, DCAM_IDSTR_DRIVERVERSION, buf, sizeof(buf) ) ) + dcamcon_show_dcamerr( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_DRIVERVERSION)\n" ); + else + printf( "DCAM_IDSTR_DRIVERVERSION = %s\n", buf ); + + if( ! my_dcamdev_string( err, hdcam, DCAM_IDSTR_MODULEVERSION, buf, sizeof(buf) ) ) + dcamcon_show_dcamerr( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_MODULEVERSION)\n" ); + else + printf( "DCAM_IDSTR_MODULEVERSION = %s\n", buf ); + + if( ! my_dcamdev_string( err, hdcam, DCAM_IDSTR_DCAMAPIVERSION, buf, sizeof(buf) ) ) + dcamcon_show_dcamerr( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_DCAMAPIVERSION)\n" ); + else + printf( "DCAM_IDSTR_DCAMAPIVERSION = %s\n", buf ); +} + +// ---------------------------------------------------------------- +// initialize DCAM-API and get HDCAM camera handle. + +HDCAM dcamcon_init_open() +{ + // Initialize DCAM-API ver 4.0 + DCAMAPI_INIT apiinit; + memset( &apiinit, 0, sizeof(apiinit) ); + apiinit.size = sizeof(apiinit); + + DCAMERR err; + err = dcamapi_init( &apiinit ); + if( failed( err ) ) + { + // failure + dcamcon_show_dcamerr( NULL, err, "dcamapi_init()" ); + return NULL; + } + + int32 nDevice = apiinit.iDeviceCount; + ASSERT( nDevice > 0 ); // nDevice must be larger than 0 + + int32 iDevice; + + // show all camera information by text + for( iDevice = 0; iDevice < nDevice; iDevice++ ) + { + dcamcon_show_dcamdev_info( (HDCAM)(intptr_t)iDevice ); + } + + if( nDevice > 1 ) + { + // choose one camera from the list if there are two or more cameras. + printf( "choose one of camera from above list by index (0-%d) >", nDevice-1 ); + + iDevice = -1; + + char buf[256]; + while( fgets( buf, sizeof(buf), stdin ) != NULL ) + { + if( _stricmp( buf, "exit" ) == 0 || _stricmp( buf, "exit\n" ) == 0 ) + { + iDevice = -1; + break; + } + + iDevice = atoi( buf ); + if( 0 <= iDevice && iDevice < nDevice ) + break; + } + } + else + { + iDevice = 0; + } + + if( 0 <= iDevice && iDevice < nDevice ) + { + // open specified camera + DCAMDEV_OPEN devopen; + memset( &devopen, 0, sizeof(devopen) ); + devopen.size = sizeof(devopen); + devopen.index = iDevice; + err = dcamdev_open( &devopen ); + if( ! failed(err) ) + { + HDCAM hdcam = devopen.hdcam; + + dcamcon_show_dcamdev_info_detail( hdcam ); + + // success + return hdcam; + } + + dcamcon_show_dcamerr( (HDCAM)(intptr_t)iDevice, err, "dcamdev_open()", "index is %d\n", iDevice ); + } + + // uninitialize DCAM-API + dcamapi_uninit(); + + // failure + return NULL; +} + +//--- + +BOOL console_prompt(const char* prompt, char* buf, int32 bufsize ) +{ + fputs( prompt, stdout ); + if( fgets( buf, bufsize, stdin ) == NULL ) + return FALSE; + + return TRUE; +} + +//--- +void output_data(const char* filename, char* buf, int32 bufsize ) +{ +#if defined( WIN32 ) + HANDLE hFile = CreateFileA( filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL ); + if( hFile != INVALID_HANDLE_VALUE ) + { + DWORD dw; + WriteFile( hFile, buf, bufsize, &dw, NULL ); + CloseHandle( hFile ); + } +#else + FILE *fp = fopen( filename, "w+b" ); + if( fp != NULL ) + { + fwrite( buf, bufsize, 1, fp ); + fclose( fp ); + } +#endif +} diff --git a/support/dcamsdk4/misc/common.h b/support/dcamsdk4/misc/common.h new file mode 100644 index 0000000..401e737 --- /dev/null +++ b/support/dcamsdk4/misc/common.h @@ -0,0 +1,12 @@ +// console/misc/common.h +// + +void dcamcon_show_dcamerr( HDCAM hdcam, DCAMERR errid, const char* apiname, const char* fmt=0, ... ); + +HDCAM dcamcon_init_open(); +void dcamcon_show_dcamdev_info( HDCAM hdcam ); + +//--- + +BOOL console_prompt(const char* prompt, char* buf, int32 bufsize ); +void output_data( const char* filename, char* buf, int32 bufsize ); diff --git a/support/dcamsdk4/misc/console4.h b/support/dcamsdk4/misc/console4.h new file mode 100644 index 0000000..331abd4 --- /dev/null +++ b/support/dcamsdk4/misc/console4.h @@ -0,0 +1,153 @@ +// console4.h + +// ---------------------------------------------------------------- + +#ifdef WIN32 + +// Windows + +#include + +#else // ! WIN32 + +#include +#include +#include + +#if defined( LINUX ) + +// Linux + +#include +#include + +#elif defined( MACOSX ) + +// Mac +// No carbon + +#include + +#endif +#endif // WIN32 + +// common headers + +#include + +// DCAM-API headers + +#ifndef _NO_DCAMAPI + +#ifndef DCAMAPI_VER +#define DCAMAPI_VER 4000 +#endif + +#ifndef DCAMAPI_VERMIN +#define DCAMAPI_VERMIN 4000 +#endif + +#if defined( LINUX ) +#include "dcamapi4.h" +#include "dcamprop.h" +#else +#include "../../../inc/dcamapi4.h" +#include "../../../inc/dcamprop.h" +#endif + +#if defined(_WIN64) +#pragma comment(lib,"../../../lib/win64/dcamapi.lib") +#elif defined(WIN32) +#pragma comment(lib,"../../../lib/win32/dcamapi.lib") +#endif + +#endif // _NO_DCAMAPI + +// ---------------------------------------------------------------- + +// define common macro + +#ifndef ASSERT +#define ASSERT(c) +#endif + +// absorb different function + +#ifdef WIN32 + +#if defined(UNICODE) || defined(_UNICODE) +#define _T(str) L##str +#else +#define _T(str) str +#endif + +#elif defined( MACOSX ) || __ppc64__ || __i386__ || __x86_64__ || defined( LINUX ) + +#define _T(str) str + +#endif + +// absorb Visual Studio 2005 and later + +#if ! defined(WIN32) || _MSC_VER < 1400 + +#define _stricmp(str1, str2) strncasecmp( str1, str2, strlen(str2) ) +#define sprintf_s snprintf + +#define BOOL int +#define BYTE uint8_t +#define WORD uint16_t +#define DWORD uint32_t +#define LONGLONG int64_t + +#define MAX_PATH 256 +#define TRUE 1 +#define FALSE 0 + +#define LARGE_INTEGER int64_t + +inline int fopen_s( FILE** fpp, const char* filename, const char* filemode ) +{ + *fpp = fopen( filename, filemode ); + if( fpp == NULL ) + return 1; + else + return 0; +} + +inline void Sleep( DWORD dwMillseconds ) +{ +#if defined( MACOSX ) + int usec = dwMillseconds * 1000; + usleep(usec); +#else // expect defined( LINUX ) + struct timespec t; + t.tv_sec = dwMillseconds / 1000; + t.tv_nsec = ( dwMillseconds % 1000 ) * 1000000; + nanosleep( &t, NULL ); +#endif +} + +inline void* memcpy_s( void* dst, size_t dstsize, const void* src, size_t srclen ) +{ + if( dstsize < srclen ) + return memcpy( dst, src, dstsize ); + else + return memcpy( dst, src, srclen ); +} + +inline char* strcpy_s( char* dst, size_t dstsize, const char* src ) +{ + return (char*)memcpy_s( dst, dstsize, src, strlen(src) ); +} + +inline char* strcat_s( char* dst, size_t dstsize, const char* src ) +{ + size_t dstused = strlen(dst); + strcpy_s( dst + dstused, dstsize - dstused, src ); + return dst; +} + +#endif + +// ---------------------------------------------------------------- diff --git a/support/dcamsdk4/misc/dcamapix.h b/support/dcamsdk4/misc/dcamapix.h new file mode 100644 index 0000000..7d22076 --- /dev/null +++ b/support/dcamsdk4/misc/dcamapix.h @@ -0,0 +1,5 @@ +// console/dcamapix.h + +#define DCAM_GUID_MYAPP { 0x12345678, 0xabcd, 0x01ef, { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef } } + +#define DCAMAPI_INITOPTION_A_SAMPLE 0x00000001 diff --git a/support/dcamsdk4/misc/dyndcam4.cpp b/support/dcamsdk4/misc/dyndcam4.cpp new file mode 100644 index 0000000..1f41f7b --- /dev/null +++ b/support/dcamsdk4/misc/dyndcam4.cpp @@ -0,0 +1,648 @@ +// dyndcam4.cpp + +#include "console4.h" + +/* ---------------------------------------------------------------- */ + +typedef DCAMERR DCAMAPI proc_api_init( DCAMAPI_INIT* param ); +typedef DCAMERR DCAMAPI proc_api_uninit(); +typedef DCAMERR DCAMAPI proc_dev_open( DCAMDEV_OPEN* param ); +typedef DCAMERR DCAMAPI proc_dev_close( HDCAM h ); +typedef DCAMERR DCAMAPI proc_dev_showpanel( HDCAM h, int32 iKind ); +typedef DCAMERR DCAMAPI proc_dev_getcapability( HDCAM h, DCAMDEV_CAPABILITY* param ); +typedef DCAMERR DCAMAPI proc_dev_getstring( HDCAM h, DCAMDEV_STRING* param ); +typedef DCAMERR DCAMAPI proc_dev_setdata( HDCAM h, DCAMDATA_HDR* param ); +typedef DCAMERR DCAMAPI proc_dev_getdata( HDCAM h, DCAMDATA_HDR* param ); +typedef DCAMERR DCAMAPI proc_prop_getattr( HDCAM h, DCAMPROP_ATTR* param ); +typedef DCAMERR DCAMAPI proc_prop_getvalue( HDCAM h, int32 iProp, double* pValue ); +typedef DCAMERR DCAMAPI proc_prop_setvalue( HDCAM h, int32 iProp, double fValue ); +typedef DCAMERR DCAMAPI proc_prop_setgetvalue( HDCAM h, int32 iProp, double* pValue, int32 option ); +typedef DCAMERR DCAMAPI proc_prop_queryvalue( HDCAM h, int32 iProp, double* pValue, int32 option ); +typedef DCAMERR DCAMAPI proc_prop_getnextid( HDCAM h, int32* pProp, int32 option ); +typedef DCAMERR DCAMAPI proc_prop_getname( HDCAM h, int32 iProp, char* text, int32 textbytes ); +typedef DCAMERR DCAMAPI proc_prop_getvaluetext( HDCAM h, DCAMPROP_VALUETEXT* param ); +typedef DCAMERR DCAMAPI proc_buf_alloc( HDCAM h, int32 framecount );// call dcambuf_release() to free. +typedef DCAMERR DCAMAPI proc_buf_attach( HDCAM h, const DCAMBUF_ATTACH* param ); +typedef DCAMERR DCAMAPI proc_buf_release( HDCAM h, int32 iKind ); +typedef DCAMERR DCAMAPI proc_buf_lockframe( HDCAM h, DCAMBUF_FRAME* pFrame ); +typedef DCAMERR DCAMAPI proc_buf_copyframe( HDCAM h, DCAMBUF_FRAME* pFrame ); +typedef DCAMERR DCAMAPI proc_buf_copymetadata( HDCAM h, DCAM_METADATAHDR* hdr ); +typedef DCAMERR DCAMAPI proc_cap_start( HDCAM h, int32 mode ); +typedef DCAMERR DCAMAPI proc_cap_stop( HDCAM h ); +typedef DCAMERR DCAMAPI proc_cap_status( HDCAM h, int32* pStatus ); +typedef DCAMERR DCAMAPI proc_cap_transferinfo( HDCAM h, DCAMCAP_TRANSFERINFO* param ); +typedef DCAMERR DCAMAPI proc_cap_firetrigger( HDCAM h, int32 iKind ); +typedef DCAMERR DCAMAPI proc_cap_record( HDCAM h, HDCAMREC hrec ); +typedef DCAMERR DCAMAPI proc_wait_open( DCAMWAIT_OPEN* param ); +typedef DCAMERR DCAMAPI proc_wait_close( HDCAMWAIT hWait ); +typedef DCAMERR DCAMAPI proc_wait_start( HDCAMWAIT hWait, DCAMWAIT_START* param ); +typedef DCAMERR DCAMAPI proc_wait_abort( HDCAMWAIT hWait ); +typedef DCAMERR DCAMAPI proc_rec_openA( DCAMREC_OPENA* param ); +typedef DCAMERR DCAMAPI proc_rec_openW( DCAMREC_OPENW* param ); +typedef DCAMERR DCAMAPI proc_rec_close( HDCAMREC hrec ); +typedef DCAMERR DCAMAPI proc_rec_lockframe( HDCAMREC hrec, DCAMREC_FRAME* pFrame ); +typedef DCAMERR DCAMAPI proc_rec_copyframe( HDCAMREC hrec, DCAMREC_FRAME* pFrame ); +typedef DCAMERR DCAMAPI proc_rec_writemetadata( HDCAMREC hrec, const DCAM_METADATAHDR* hdr ); +typedef DCAMERR DCAMAPI proc_rec_lockmetadata( HDCAMREC hrec, DCAM_METADATAHDR* hdr ); +typedef DCAMERR DCAMAPI proc_rec_copymetadata( HDCAMREC hrec, DCAM_METADATAHDR* hdr ); +typedef DCAMERR DCAMAPI proc_rec_lockmetadatablock( HDCAMREC hrec, DCAM_METADATABLOCKHDR* hdr ); +typedef DCAMERR DCAMAPI proc_rec_copymetadatablock( HDCAMREC hrec, DCAM_METADATABLOCKHDR* hdr ); +typedef DCAMERR DCAMAPI proc_rec_pause( HDCAMREC hrec ); +typedef DCAMERR DCAMAPI proc_rec_resume( HDCAMREC hrec ); +typedef DCAMERR DCAMAPI proc_rec_status( HDCAMREC hrec, DCAMREC_STATUS* pStatus ); + +/* ---------------------------------------------------------------- */ + +static HINSTANCE hInstDcamapi4; + +static struct { + proc_api_init* api_init; + proc_api_uninit* api_uninit; + proc_dev_open* dev_open; + proc_dev_close* dev_close; + proc_dev_showpanel* dev_showpanel; + proc_dev_getcapability* dev_getcapability; + proc_dev_getstring* dev_getstring; + proc_dev_setdata* dev_setdata; + proc_dev_getdata* dev_getdata; + proc_prop_getattr* prop_getattr; + proc_prop_getvalue* prop_getvalue; + proc_prop_setvalue* prop_setvalue; + proc_prop_setgetvalue* prop_setgetvalue; + proc_prop_queryvalue* prop_queryvalue; + proc_prop_getnextid* prop_getnextid; + proc_prop_getname* prop_getname; + proc_prop_getvaluetext* prop_getvaluetext; + proc_buf_alloc* buf_alloc; + proc_buf_attach* buf_attach; + proc_buf_release* buf_release; + proc_buf_lockframe* buf_lockframe; + proc_buf_copyframe* buf_copyframe; + proc_buf_copymetadata* buf_copymetadata; + proc_cap_start* cap_start; + proc_cap_stop* cap_stop; + proc_cap_status* cap_status; + proc_cap_transferinfo* cap_transferinfo; + proc_cap_firetrigger* cap_firetrigger; + proc_cap_record* cap_record; + proc_wait_open* wait_open; + proc_wait_close* wait_close; + proc_wait_start* wait_start; + proc_wait_abort* wait_abort; + proc_rec_openA* rec_openA; + proc_rec_openW* rec_openW; + proc_rec_close* rec_close; + proc_rec_lockframe* rec_lockframe; + proc_rec_copyframe* rec_copyframe; + proc_rec_writemetadata* rec_writemetadata; + proc_rec_lockmetadata* rec_lockmetadata; + proc_rec_copymetadata* rec_copymetadata; + proc_rec_lockmetadatablock* rec_lockmetadatablock; + proc_rec_copymetadatablock* rec_copymetadatablock; + proc_rec_pause* rec_pause; + proc_rec_resume* rec_resume; + proc_rec_status* rec_status; +} entry; + +static FARPROC getproc( const char* procname ) +{ + return GetProcAddress( hInstDcamapi4, procname ); +} + +static void load_dcamapi4() +{ + if( hInstDcamapi4 != NULL ) + return; // nothing to do. + + hInstDcamapi4 = LoadLibrary( _T("dcamapi.dll") ); + if( hInstDcamapi4 == NULL ) + return; // DLL is not found + + if( (entry.api_init = (proc_api_init*) getproc( "dcamapi_init" ) ) != NULL + && (entry.api_uninit = (proc_api_uninit*) getproc( "dcamapi_uninit" ) ) != NULL + && (entry.dev_open = (proc_dev_open*) getproc( "dcamdev_open" ) ) != NULL + && (entry.dev_close = (proc_dev_close*) getproc( "dcamdev_close" ) ) != NULL + && (entry.dev_showpanel = (proc_dev_showpanel*) getproc( "dcamdev_showpanel" ) ) != NULL + && (entry.dev_getcapability = (proc_dev_getcapability*) getproc( "dcamdev_getcapability" ) ) != NULL + && (entry.dev_getstring = (proc_dev_getstring*) getproc( "dcamdev_getstring" ) ) != NULL + && (entry.dev_setdata = (proc_dev_setdata*) getproc( "dcamdev_setdata" ) ) != NULL + && (entry.dev_getdata = (proc_dev_getdata*) getproc( "dcamdev_getdata" ) ) != NULL + && (entry.prop_getattr = (proc_prop_getattr*) getproc( "dcamprop_getattr" ) ) != NULL + && (entry.prop_getvalue = (proc_prop_getvalue*) getproc( "dcamprop_getvalue" ) ) != NULL + && (entry.prop_setvalue = (proc_prop_setvalue*) getproc( "dcamprop_setvalue" ) ) != NULL + && (entry.prop_setgetvalue = (proc_prop_setgetvalue*) getproc( "dcamprop_setgetvalue" ) ) != NULL + && (entry.prop_queryvalue = (proc_prop_queryvalue*) getproc( "dcamprop_queryvalue" ) ) != NULL + && (entry.prop_getnextid = (proc_prop_getnextid*) getproc( "dcamprop_getnextid" ) ) != NULL + && (entry.prop_getname = (proc_prop_getname*) getproc( "dcamprop_getname" ) ) != NULL + && (entry.prop_getvaluetext = (proc_prop_getvaluetext*) getproc( "dcamprop_getvaluetext" ) ) != NULL + && (entry.buf_alloc = (proc_buf_alloc*) getproc( "dcambuf_alloc" ) ) != NULL + && (entry.buf_attach = (proc_buf_attach*) getproc( "dcambuf_attach" ) ) != NULL + && (entry.buf_release = (proc_buf_release*) getproc( "dcambuf_release" ) ) != NULL + && (entry.buf_lockframe = (proc_buf_lockframe*) getproc( "dcambuf_lockframe" ) ) != NULL + && (entry.buf_copyframe = (proc_buf_copyframe*) getproc( "dcambuf_copyframe" ) ) != NULL + && (entry.buf_copymetadata = (proc_buf_copymetadata*) getproc( "dcambuf_copymetadata" ) ) != NULL + && (entry.cap_start = (proc_cap_start*) getproc( "dcamcap_start" ) ) != NULL + && (entry.cap_stop = (proc_cap_stop*) getproc( "dcamcap_stop" ) ) != NULL + && (entry.cap_status = (proc_cap_status*) getproc( "dcamcap_status" ) ) != NULL + && (entry.cap_transferinfo = (proc_cap_transferinfo*) getproc( "dcamcap_transferinfo" ) ) != NULL + && (entry.cap_firetrigger = (proc_cap_firetrigger*) getproc( "dcamcap_firetrigger" ) ) != NULL + && (entry.cap_record = (proc_cap_record*) getproc( "dcamcap_record" ) ) != NULL + && (entry.wait_open = (proc_wait_open*) getproc( "dcamwait_open" ) ) != NULL + && (entry.wait_close = (proc_wait_close*) getproc( "dcamwait_close" ) ) != NULL + && (entry.wait_start = (proc_wait_start*) getproc( "dcamwait_start" ) ) != NULL + && (entry.wait_abort = (proc_wait_abort*) getproc( "dcamwait_abort" ) ) != NULL + && (entry.rec_openA = (proc_rec_openA*) getproc( "dcamrec_openA" ) ) != NULL + && (entry.rec_openW = (proc_rec_openW*) getproc( "dcamrec_openW" ) ) != NULL + && (entry.rec_close = (proc_rec_close*) getproc( "dcamrec_close" ) ) != NULL + && (entry.rec_lockframe = (proc_rec_lockframe*) getproc( "dcamrec_lockframe" ) ) != NULL + && (entry.rec_copyframe = (proc_rec_copyframe*) getproc( "dcamrec_copyframe" ) ) != NULL + && (entry.rec_writemetadata = (proc_rec_writemetadata*) getproc( "dcamrec_writemetadata" ) ) != NULL + && (entry.rec_lockmetadata = (proc_rec_lockmetadata*) getproc( "dcamrec_lockmetadata" ) ) != NULL + && (entry.rec_copymetadata = (proc_rec_copymetadata*) getproc( "dcamrec_copymetadata" ) ) != NULL + && (entry.rec_lockmetadatablock= (proc_rec_lockmetadatablock*) getproc( "dcamrec_lockmetadatablock" ) ) != NULL + && (entry.rec_copymetadatablock= (proc_rec_copymetadatablock*) getproc( "dcamrec_copymetadatablock" ) ) != NULL + && (entry.rec_pause = (proc_rec_pause*) getproc( "dcamrec_pause" ) ) != NULL + && (entry.rec_resume = (proc_rec_resume*) getproc( "dcamrec_resume" ) ) != NULL + && (entry.rec_status = (proc_rec_status*) getproc( "dcamrec_status" ) ) != NULL ) + return; // success + + // DCAMAPI.DLL does not include all entry. + memset( &entry, 0, sizeof(entry) ); + + return; // failed +} + +static void unload_dcamapi4() +{ + if( hInstDcamapi4 != NULL ) + { + FreeLibrary( hInstDcamapi4 ); + } + + memset( &entry, 0, sizeof(entry) ); +} + +/* ---------------------------------------------------------------- */ + +DCAMERR DCAMAPI dcamapi_init( DCAMAPI_INIT* param ) +{ + load_dcamapi4(); + + if( entry.api_init == NULL ) + return DCAMERR_NOMODULE; + + return entry.api_init( param ); +} + +DCAMERR DCAMAPI dcamapi_uninit() +{ + DCAMERR err = DCAMERR_NOMODULE; + + if( entry.api_uninit != NULL ) + err = entry.api_uninit(); + + unload_dcamapi4(); + + return err; +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamdev_open( DCAMDEV_OPEN* param ) +{ + if( entry.dev_open == NULL ) + return DCAMERR_NOMODULE; + + return entry.dev_open( param ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamdev_close( HDCAM h ) +{ + if( entry.dev_close == NULL ) + return DCAMERR_NOMODULE; + + return entry.dev_close( h ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamdev_showpanel( HDCAM h, int32 iKind ) +{ + if( entry.dev_showpanel == NULL ) + return DCAMERR_NOMODULE; + + return entry.dev_showpanel( h, iKind ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamdev_getcapability( HDCAM h, DCAMDEV_CAPABILITY* param ) +{ + if( entry.dev_getcapability == NULL ) + return DCAMERR_NOMODULE; + + return entry.dev_getcapability( h, param ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamdev_getstring( HDCAM h, DCAMDEV_STRING* param ) +{ + if( entry.dev_getstring == NULL ) + return DCAMERR_NOMODULE; + + return entry.dev_getstring( h, param ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamdev_setdata( HDCAM h, DCAMDATA_HDR* param ) +{ + if( entry.dev_setdata == NULL ) + return DCAMERR_NOMODULE; + + return entry.dev_setdata( h, param ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamdev_getdata( HDCAM h, DCAMDATA_HDR* param ) +{ + if( entry.dev_getdata == NULL ) + return DCAMERR_NOMODULE; + + return entry.dev_getdata( h, param ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamprop_getattr( HDCAM h, DCAMPROP_ATTR* param ) +{ + if( entry.prop_getattr == NULL ) + return DCAMERR_NOMODULE; + + return entry.prop_getattr( h, param ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamprop_getvalue( HDCAM h, int32 iProp, double* pValue ) +{ + if( entry.prop_getvalue == NULL ) + return DCAMERR_NOMODULE; + + return entry.prop_getvalue( h, iProp, pValue ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamprop_setvalue( HDCAM h, int32 iProp, double fValue ) +{ + if( entry.prop_setvalue == NULL ) + return DCAMERR_NOMODULE; + + return entry.prop_setvalue( h, iProp, fValue ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamprop_setgetvalue( HDCAM h, int32 iProp, double* pValue, int32 option ) +{ + if( entry.prop_setgetvalue == NULL ) + return DCAMERR_NOMODULE; + + return entry.prop_setgetvalue( h, iProp, pValue, option ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamprop_queryvalue( HDCAM h, int32 iProp, double* pValue, int32 option ) +{ + if( entry.prop_queryvalue == NULL ) + return DCAMERR_NOMODULE; + + return entry.prop_queryvalue( h, iProp, pValue, option ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamprop_getnextid( HDCAM h, int32* pProp, int32 option ) +{ + if( entry.prop_getnextid == NULL ) + return DCAMERR_NOMODULE; + + return entry.prop_getnextid( h, pProp, option ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamprop_getname( HDCAM h, int32 iProp, char* text, int32 textbytes ) +{ + if( entry.prop_getname == NULL ) + return DCAMERR_NOMODULE; + + return entry.prop_getname( h, iProp, text, textbytes ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamprop_getvaluetext( HDCAM h, DCAMPROP_VALUETEXT* param ) +{ + if( entry.prop_getvaluetext == NULL ) + return DCAMERR_NOMODULE; + + return entry.prop_getvaluetext( h, param ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcambuf_alloc( HDCAM h, int32 framecount ) +{ + if( entry.buf_alloc == NULL ) + return DCAMERR_NOMODULE; + + return entry.buf_alloc( h, framecount ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcambuf_attach( HDCAM h, const DCAMBUF_ATTACH* param ) +{ + if( entry.buf_attach == NULL ) + return DCAMERR_NOMODULE; + + return entry.buf_attach( h, param ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcambuf_release( HDCAM h, int32 iKind ) +{ + if( entry.buf_release == NULL ) + return DCAMERR_NOMODULE; + + return entry.buf_release( h, iKind ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcambuf_lockframe( HDCAM h, DCAMBUF_FRAME* pFrame ) +{ + if( entry.buf_lockframe == NULL ) + return DCAMERR_NOMODULE; + + return entry.buf_lockframe( h, pFrame ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcambuf_copyframe( HDCAM h, DCAMBUF_FRAME* pFrame ) +{ + if( entry.buf_copyframe == NULL ) + return DCAMERR_NOMODULE; + + return entry.buf_copyframe( h, pFrame ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcambuf_copymetadata( HDCAM h, DCAM_METADATAHDR* hdr ) +{ + if( entry.buf_copymetadata == NULL ) + return DCAMERR_NOMODULE; + + return entry.buf_copymetadata( h, hdr ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamcap_start( HDCAM h, int32 mode ) +{ + if( entry.cap_start == NULL ) + return DCAMERR_NOMODULE; + + return entry.cap_start( h, mode ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamcap_stop( HDCAM h ) +{ + if( entry.cap_stop == NULL ) + return DCAMERR_NOMODULE; + + return entry.cap_stop( h ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamcap_status( HDCAM h, int32* pStatus ) +{ + if( entry.cap_status == NULL ) + return DCAMERR_NOMODULE; + + return entry.cap_status( h, pStatus ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamcap_transferinfo( HDCAM h, DCAMCAP_TRANSFERINFO* param ) +{ + if( entry.cap_transferinfo == NULL ) + return DCAMERR_NOMODULE; + + return entry.cap_transferinfo( h, param ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamcap_firetrigger( HDCAM h, int32 iKind ) +{ + if( entry.cap_firetrigger == NULL ) + return DCAMERR_NOMODULE; + + return entry.cap_firetrigger( h, iKind ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamcap_record( HDCAM h, HDCAMREC hrec ) +{ + if( entry.cap_record == NULL ) + return DCAMERR_NOMODULE; + + return entry.cap_record( h, hrec ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamwait_open( DCAMWAIT_OPEN* param ) +{ + if( entry.wait_open == NULL ) + return DCAMERR_NOMODULE; + + return entry.wait_open( param ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamwait_close( HDCAMWAIT hWait ) +{ + if( entry.wait_close == NULL ) + return DCAMERR_NOMODULE; + + return entry.wait_close( hWait ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamwait_start( HDCAMWAIT hWait, DCAMWAIT_START* param ) +{ + if( entry.wait_start == NULL ) + return DCAMERR_NOMODULE; + + return entry.wait_start( hWait, param ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamwait_abort( HDCAMWAIT hWait ) +{ + if( entry.wait_abort == NULL ) + return DCAMERR_NOMODULE; + + return entry.wait_abort( hWait ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamrec_openA( DCAMREC_OPENA* param ) +{ + if( entry.rec_openA == NULL ) + return DCAMERR_NOMODULE; + + return entry.rec_openA( param ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamrec_openW( DCAMREC_OPENW* param ) +{ + if( entry.rec_openW == NULL ) + return DCAMERR_NOMODULE; + + return entry.rec_openW( param ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamrec_close( HDCAMREC hrec ) +{ + if( entry.rec_close == NULL ) + return DCAMERR_NOMODULE; + + return entry.rec_close( hrec ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamrec_lockframe( HDCAMREC hrec, DCAMREC_FRAME* pFrame ) +{ + if( entry.rec_lockframe == NULL ) + return DCAMERR_NOMODULE; + + return entry.rec_lockframe( hrec, pFrame ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamrec_copyframe( HDCAMREC hrec, DCAMREC_FRAME* pFrame ) +{ + if( entry.rec_copyframe == NULL ) + return DCAMERR_NOMODULE; + + return entry.rec_copyframe( hrec, pFrame ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamrec_writemetadata( HDCAMREC hrec, const DCAM_METADATAHDR* hdr ) +{ + if( entry.rec_writemetadata == NULL ) + return DCAMERR_NOMODULE; + + return entry.rec_writemetadata( hrec, hdr ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamrec_lockmetadata( HDCAMREC hrec, DCAM_METADATAHDR* hdr ) +{ + if( entry.rec_lockmetadata == NULL ) + return DCAMERR_NOMODULE; + + return entry.rec_lockmetadata( hrec, hdr ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamrec_copymetadata( HDCAMREC hrec, DCAM_METADATAHDR* hdr ) +{ + if( entry.rec_copymetadata == NULL ) + return DCAMERR_NOMODULE; + + return entry.rec_copymetadata( hrec, hdr ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamrec_lockmetadatablock( HDCAMREC hrec, DCAM_METADATABLOCKHDR* hdr ) +{ + if( entry.rec_lockmetadatablock == NULL ) + return DCAMERR_NOMODULE; + + return entry.rec_lockmetadatablock( hrec, hdr ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamrec_copymetadatablock( HDCAMREC hrec, DCAM_METADATABLOCKHDR* hdr ) +{ + if( entry.rec_copymetadatablock == NULL ) + return DCAMERR_NOMODULE; + + return entry.rec_copymetadatablock( hrec, hdr ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamrec_pause( HDCAMREC hrec ) +{ + if( entry.rec_pause == NULL ) + return DCAMERR_NOMODULE; + + return entry.rec_pause( hrec ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamrec_resume( HDCAMREC hrec ) +{ + if( entry.rec_resume == NULL ) + return DCAMERR_NOMODULE; + + return entry.rec_resume( hrec ); +} + +/* ---------------- */ + +DCAMERR DCAMAPI dcamrec_status( HDCAMREC hrec, DCAMREC_STATUS* pStatus ) +{ + if( entry.rec_status == NULL ) + return DCAMERR_NOMODULE; + + return entry.rec_status( hrec, pStatus ); +} + diff --git a/support/dcamsdk4/misc/qthread.cpp b/support/dcamsdk4/misc/qthread.cpp new file mode 100644 index 0000000..4a42e29 --- /dev/null +++ b/support/dcamsdk4/misc/qthread.cpp @@ -0,0 +1,85 @@ +// qthread.cpp : +// + +#include "console4.h" +#include "qthread.h" + +#if defined( WIN32 ) + +qthread::~qthread() +{ + if( m_thread != NULL ) + { + CloseHandle( m_thread ); + } +} + +qthread::qthread() +{ + m_thread = NULL; + m_exitcode = 0; +} + +int32 qthread::start() +{ + DWORD dwThreadID; + m_thread = CreateThread( NULL, 0, threadentry, this, NULL, &dwThreadID ); + return m_thread != NULL; +} + +int32 qthread::wait_terminate() +{ + WaitForSingleObject( m_thread, INFINITE ); + return m_exitcode; +} + +DWORD WINAPI qthread::threadentry( LPVOID pparam ) +{ + qthread* pThis = (qthread*)pparam; + + pThis->m_exitcode = pThis->main(); + + return 0; +} + +#elif defined( MACOSX ) || __ppc64__ || __i386__ || __x86_64__ + +#include + +qthread::~qthread() +{ +} + +qthread::qthread() +{ + m_thread = NULL; + m_exitcode = 0; +} + +int32 qthread::start() +{ + pthread_create( (pthread_t*)&m_thread, NULL, threadentry, this ); + return m_thread != NULL; +} + +int32 qthread::wait_terminate() +{ + void* ret; + if( pthread_join( (pthread_t)m_thread, &ret ) == 0 ) + pthread_detach( (pthread_t)m_thread ); + + return m_exitcode; +} + +void* qthread::threadentry(void* pparam ) +{ + qthread* pThis = (qthread*)pparam; + + pThis->main(); + + return NULL; +} + +#else +#error unknown operating system: qthread.cpp +#endif diff --git a/support/dcamsdk4/misc/qthread.h b/support/dcamsdk4/misc/qthread.h new file mode 100644 index 0000000..b875ce6 --- /dev/null +++ b/support/dcamsdk4/misc/qthread.h @@ -0,0 +1,34 @@ +// qthread.h +// + +class qthread +{ +protected: + virtual ~qthread(); + qthread(); + +public: + int32 start(); + int32 wait_terminate(); + +protected: + virtual int32 main() = 0; + +protected: + void* m_thread; + int32 m_exitcode; + +#if defined(WIN32) + + static DWORD WINAPI threadentry( LPVOID pparam ); + +#elif defined( MACOSX ) || __ppc64__ || __i386__ || __x86_64__ || __aarch64__ || __arm__ + + static void* threadentry(void* pparam ); + +#else +#error unknown operating system: class qthread +#endif + +}; +