razzaline/tahoma2d
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity

Remove Scan Stuff (#79)

Browse source 
* Remove Scan Stuff

* Fix Travis?

* Travis 2
This commit is contained in:
Jeremy Bullock 2020-07-08 00:31:12 -06:00 committed by GitHub
parent 67af2862b0
commit 5957d4d678
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
58 changed files with 36 additions and 10961 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
ci-scripts/osx/travis-install.sh
View file

@ -6,6 +6,8 @@ brew install clang-format
# from Homebrew 1.6.0 the old formula for obtaining Qt5.9.2 becomes invalid.
# so we start to use the latest version of Qt. (#1910)
brew install qt
# delete older qt versions and make sure to have only the latest
brew cleanup qt
# temp workaround to brew installed glew cmake info overriding glew lib detection
# which causes compiling issues later
if [ -L /usr/local/lib/cmake/glew ]

25
stuff/profiles/layouts/rooms/Default/menubar_template.xml
View file

@ -76,22 +76,6 @@
<command>MI_SendBackward</command>
</menu>
</menu>
<menu title="Scan &amp;&amp; Cleanup">
<command>MI_DefineScanner</command>
<command>MI_ScanSettings</command>
<command>MI_Scan</command>
<command>MI_SetScanCropbox</command>
<command>MI_ResetScanCropbox</command>
<separator/>
<command>MI_CleanupSettings</command>
<command>MI_CleanupPreview</command>
<command>MI_OpacityCheck</command>
<command>MI_CameraTest</command>
<command>MI_Cleanup</command>
<separator/>
<command>MI_PencilTest</command>
<command>MI_Autocenter</command>
</menu>
<menu title="Level">
<menu title="New">
<command>MI_NewLevel</command>
@ -241,6 +225,15 @@
<separator/>
<command>MI_Link</command>
</menu>
<menu title="Cleanup">
<command>MI_CleanupSettings</command>
<command>MI_CleanupPreview</command>
<command>MI_OpacityCheck</command>
<command>MI_CameraTest</command>
<command>MI_Cleanup</command>
<separator/>
<command>MI_PencilTest</command>
</menu>
<menu title="Render">
<command>MI_PreviewSettings</command>
<command>MI_Preview</command>

116
toonz/sources/common/twain/ttwain.h
View file

@ -1,116 +0,0 @@
#pragma once
#ifndef __TTWAIN_H__
#define __TTWAIN_H__
#ifdef _WIN32
#include <windows.h>
#else
#ifndef _UNIX_
#define _UNIX_
#endif
#endif
#include "twain.h"
#include "tnztypes.h"
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
#ifndef UCHAR
#define UCHAR unsigned char
#endif
#ifndef USHORT
#define USHORT unsigned short
#endif
#ifdef __cplusplus
extern "C" {
#endif
typedef enum TTWAIN_PIXTYPE {
TTWAIN_BW, /* 1-bit per pixel, B&W */
TTWAIN_WB, /* 1-bit per pixel, W&B */
TTWAIN_GRAY8, /* 1,4, or 8-bit grayscale */
TTWAIN_RGB24, /* 24-bit RGB color */
TTWAIN_PIXTYPE_HOWMANY,
TTWAIN_PIXUNKNOWN = -1,
} TTWAIN_PIXTYPE;
typedef enum TTWAIN_BITORDER {
TTWAIN_LSBFIRST = TWBO_LSBFIRST,
TTWAIN_MSBFIRST = TWBO_MSBFIRST
} TTWAIN_BITORDER;
typedef enum TWAINAVAILABLE {
AVAIABLE_DONTKNOW = -1,
AVAIABLE_YES,
AVAIABLE_NO
} TWAINAVAILABLE;
typedef enum TTWAIN_TRANSFER_MECH {
TTWAIN_TRANSFERMODE_NATIVE = TWSX_NATIVE,
TTWAIN_TRANSFERMODE_MEMORY = TWSX_MEMORY,
TTWAIN_TRANSFERMODE_FILE = TWSX_FILE
} TTWAIN_TRANSFER_MECH;
typedef enum TTWAIN_USAGE_MODE {
TTWAIN_MODE_LEASHED,
TTWAIN_MODE_UNLEASHED
} TTWAIN_USAGE_MODE;
/* application should return 0 to stop the scanning process, any other value
* elsewhere */
typedef int TTWAIN_ONDONE_CB(UCHAR *buffer, TTWAIN_PIXTYPE pixelType, int lx,
int ly, int wrap, float xdpi, float ydpi,
void *usrData);
typedef void TTWAIN_ONERROR_CB(void *usrData, void *alwaysZero);
int TTWAIN_IsAvailable(void);
void TTWAIN_RegisterApp(
int majorNum, int minorNum, /* app. revision*/
int nLanguage, /* (human) language (use TWLG_xxx from TWAIN.H) */
int nCountry, /* country (use TWCY_xxx from TWAIN.H) */
char *version, /* version info string */
char *manufacter, /* name of manufacter */
char *family, /* product family */
char *product); /* specific product */
int TTWAIN_SelectImageSource(void *hwnd);
/*---------------------------------------------------------------------------*/
void *TTWAIN_AcquireNative(void *hwnd);
int TTWAIN_AcquireMemory(void *hwnd);
void TTWAIN_StopAcquire(void);
/*
nb. AcquireMemory returns: an upside-down bitmap :)
nb. AcquireNative returns:
under Windows an HBITMAP
under Mac a PICT
*/
/*---------------------------------------------------------------------------*/
void TTWAIN_SetTwainUsage(TTWAIN_USAGE_MODE um);
void TTWAIN_FreeMemory(void *hMem);
int TTWAIN_CloseAll(void *hwnd);
int TTWAIN_OpenSourceManager(void *hwnd);
int TTWAIN_OpenDefaultSource(void);
int TTWAIN_GetHideUI(void);
void TTWAIN_SetHideUI(int flag);
void TTWAIN_SetOnDoneCallback(TTWAIN_ONDONE_CB *proc, void *arg);
void TTWAIN_SetOnErrorCallback(TTWAIN_ONERROR_CB *proc, void *arg);
#ifdef __cplusplus
}
#endif
#endif

102
toonz/sources/common/twain/ttwainP.h
View file

@ -1,102 +0,0 @@
#pragma once
#ifndef __TTWAINP_H__
#define __TTWAINP_H__
#include "ttwain.h"
#ifdef TTWAINLIB_MAIN
#define EXTERN
#else
#define EXTERN extern
#endif
#ifdef __cplusplus
extern "C" {
#endif
typedef enum TWAINSTATE {
TWAIN_PRESESSION = 1, /* source manager not loaded */
TWAIN_SM_LOADED, /* source manager loaded */
TWAIN_SM_OPEN, /* source manager open */
TWAIN_SOURCE_OPEN, /* source open but not enabled*/
TWAIN_SOURCE_ENABLED, /* source enabled to acquire */
TWAIN_TRANSFER_READY, /* image ready to transfer */
TWAIN_TRANSFERRING /* image in transit */
} TWAINSTATE;
#ifdef _WIN32
#ifdef x64
#define DSM_FILENAME "TWAINDSM.DLL"
#else
#define DSM_FILENAME "TWAIN_32.DLL"
#endif
#define DSM_ENTRYPOINT "DSM_Entry"
#else
#define DSM_FILENAME ""
#define DSM_ENTRYPOINT ""
#endif
struct TRANSFER_INFO {
TTWAIN_TRANSFER_MECH transferMech; /*current transfer mechanism */
TTWAIN_USAGE_MODE usageMode;
/*used by buffered memory tranfer */
unsigned char *memoryBuffer;
unsigned long memorySize;
/*used by native tranfer */
void *hDib;
/*common to all the transfer mode */
int preferredLx;
int preferredLy;
int multiTransfer;
int nextImageNeedsToBeInverted;
int lastTransferWasOk;
TW_PENDINGXFERS pendingXfers;
int oneAtLeast;
};
struct CALLBACKS {
TTWAIN_ONDONE_CB *onDoneCb;
void *onDoneArg;
TTWAIN_ONERROR_CB *onErrorCb;
void *onErrorArg;
};
struct _TTWAIN_DATA__ {
/*HANDLE*/
DSMENTRYPROC DSM_Entry; /* entry point of Data Source Manager(TWAIN.DLL)*/
TW_INT32 hwnd32SM; /* window handle */
/*IDENTITY*/
TW_IDENTITY sourceId; /* source identity structure */
TW_IDENTITY appId; /* Application Ident. for DS */
TW_USERINTERFACE twainUI; /* */
int initDone;
TWAINAVAILABLE twainAvailable;
TWAINSTATE twainState; /* the current twain state */
struct TRANSFER_INFO transferInfo;
struct CALLBACKS callback;
TW_ARRAY *supportedCaps; /* all the (exported)supported capabilities */
int isSupportedCapsSupported;
int breakModalLoop;
int UIStatus; /* Hide or Show UserInterface */
int modalStatus;
TW_INT16 resultCode; /* result code for LAST error */
TUINT32 ErrRC; /* result & condition code */
TUINT32 ErrCC; /* for LAST RECORDED error */
};
EXTERN struct _TTWAIN_DATA__ TTwainData;
EXTERN int TTWAIN_InitVar(void);
#ifdef __cplusplus
}
#endif
#endif

341
toonz/sources/common/twain/ttwain_capability.c
View file

@ -1,341 +0,0 @@
/*max@home*/
#ifdef __cplusplus
extern "C" {
#endif
#ifdef NOTE
ConvertOneValue2Enum() potrebbe essere fonte di errore se
DCItemSize[one_value.ItemType] >
DCItemSize[TW_INT8] e si utilizzano i bit piu significativi di one_value
.Item
ConvertEnumeration2Range() potrebbe restituire valori di StepSize non
appropriati se enumeration.ItemType e TW_FIX32 potrebbe
restituire valori MinValue non corretti se DCItemSize[xxx.ItemType] >
DCItemSize[TW_INT8] e si utilizzano i bit piu significativi di xxx.Item
ConvertEnum2OneValue ritorna(ovviamente) solo il valore corrente
#endif
#include <assert.h>
#include <string.h>
#include "ttwain_capability.h"
#include "ttwain_conversion.h"
#include "ttwain_error.h"
#include "ttwain_state.h"
#include "ttwain_global_def.h"
/*---------------------------------------------------------------------------*/
static const size_t DCItemSize[13] = {
sizeof(TW_INT8), sizeof(TW_INT16), sizeof(TW_INT32), sizeof(TW_UINT8),
sizeof(TW_UINT16), sizeof(TW_UINT32), sizeof(TW_BOOL), sizeof(TW_FIX32),
sizeof(TW_FRAME), sizeof(TW_STR32), sizeof(TW_STR64), sizeof(TW_STR128),
sizeof(TW_STR255),
}; /* see twain.h */
/*---------------------------------------------------------------------------*/
#define TWON_TWON(TYPE1, TYPE2) (((TYPE1) << 8) | (TYPE2))
/*---------------------------------------------------------------------------*/
static int ConvertOneValue2Range(TW_ONEVALUE one_value, TW_RANGE *range);
static int ConvertEnumeration2Range(TW_ENUMERATION enumeration,
TW_RANGE *range);
static int ConvertOneValue2Enum(TW_ONEVALUE one_value, TW_ENUMERATION *tw_enum);
static int ConvertEnum2OneValue(TW_ENUMERATION tw_enum, TW_ONEVALUE *one_value);
static int ConvertEnum2Array(TW_ENUMERATION tw_enum, TW_ARRAY *array);
static TUINT32 GetContainerSize(int nFormat, unsigned twty, TW_UINT32 nItems);
static int TTWAIN_GetCapability(TW_INT16 msgType, TW_UINT16 cap_id,
TW_UINT16 conType, void *data,
TUINT32 *cont_size);
/*------------------------------------------------------------------------*/
int TTWAIN_GetCap(TW_UINT16 cap_id, TW_UINT16 conType, void *data,
TUINT32 *cont_size) {
return TTWAIN_GetCapability(MSG_GET, cap_id, conType, data, cont_size);
}
/*------------------------------------------------------------------------*/
int TTWAIN_GetCapCurrent(TW_UINT16 cap_id, TW_UINT16 conType, void *data,
TUINT32 *cont_size) {
return TTWAIN_GetCapability(MSG_GETCURRENT, cap_id, conType, data, cont_size);
}
/*------------------------------------------------------------------------*/
int TTWAIN_GetCapQuery(TW_UINT16 cap_id, TW_UINT16 *pattern) {
int rc;
/* GCC9 during compilation shows that this code possible call
* TTWAIN_GetCapability() with case TWON_TWON(TWON_RANGE, TWON_RANGE)
* whitch cause stack corruption, so make 'data' big enough to store
* TW_ONEVALUE. */
TW_ONEVALUE data[1 + (sizeof(TW_RANGE) / sizeof(TW_ONEVALUE))];
rc = TTWAIN_GetCapability(MSG_QUERYSUPPORT, cap_id, TWON_ONEVALUE, &data, 0);
if (!rc) return FALSE;
*pattern = (TW_UINT16)data[0].Item;
return TRUE;
}
/*------------------------------------------------------------------------*/
static int TTWAIN_GetCapability(TW_INT16 msgType, TW_UINT16 cap_id,
TW_UINT16 conType, void *data,
TUINT32 *cont_size) {
TW_CAPABILITY cap;
void *pv;
TW_ENUMERATION *my_enum;
TW_ARRAY *my_array;
TW_ONEVALUE *my_one;
TW_RANGE *my_range;
TUINT32 size = 0;
if (!data && !cont_size) return FALSE;
if (TTWAIN_GetState() < TWAIN_SOURCE_OPEN) {
TTWAIN_ErrorBox("Attempt to get capability value below State 4.");
return FALSE;
}
/* Fill in capability structure */
cap.Cap = cap_id; /* capability id */
cap.ConType =
TWON_DONTCARE16; /* favorite type of container (should be ignored...) */
cap.hContainer = NULL;
if (TTWAIN_DS(DG_CONTROL, DAT_CAPABILITY, msgType, (TW_MEMREF)&cap) !=
TWRC_SUCCESS)
return FALSE;
if (!cap.hContainer) return FALSE;
if (msgType == MSG_QUERYSUPPORT) {
}
pv = GLOBAL_LOCK(cap.hContainer);
my_enum = (TW_ENUMERATION *)pv;
my_array = (TW_ARRAY *)pv;
my_one = (TW_ONEVALUE *)pv;
my_range = (TW_RANGE *)pv;
if (cont_size) {
switch (TWON_TWON(cap.ConType, conType)) {
case TWON_TWON(TWON_ENUMERATION, TWON_ENUMERATION):
*cont_size = GetContainerSize(TWON_ENUMERATION, my_enum->ItemType,
my_enum->NumItems);
break;
case TWON_TWON(TWON_ONEVALUE, TWON_ENUMERATION):
*cont_size = GetContainerSize(TWON_ENUMERATION, my_one->ItemType, 1);
break;
case TWON_TWON(TWON_ARRAY, TWON_ARRAY):
*cont_size =
GetContainerSize(TWON_ARRAY, my_array->ItemType, my_array->NumItems);
break;
case TWON_TWON(TWON_ONEVALUE, TWON_ONEVALUE):
*cont_size = GetContainerSize(TWON_ONEVALUE, my_one->ItemType, 1);
break;
case TWON_TWON(TWON_ENUMERATION, TWON_ARRAY):
*cont_size =
GetContainerSize(TWON_ARRAY, my_enum->ItemType, my_enum->NumItems);
break;
default:
/* tmsg_error("Unable to convert type %d to %d (cap 0x%x)\n",
* cap.ConType, conType,cap_id);*/
assert(0);
GLOBAL_UNLOCK(cap.hContainer);
GLOBAL_FREE(cap.hContainer);
return FALSE;
}
GLOBAL_UNLOCK(cap.hContainer);
GLOBAL_FREE(cap.hContainer);
return TRUE;
}
switch (TWON_TWON(cap.ConType, conType)) {
case TWON_TWON(TWON_ENUMERATION, TWON_ENUMERATION):
size = GetContainerSize(cap.ConType, my_enum->ItemType, my_enum->NumItems);
memcpy(data, my_enum, size);
break;
case TWON_TWON(TWON_ENUMERATION, TWON_RANGE):
ConvertEnumeration2Range(*my_enum, (TW_RANGE *)data);
break;
case TWON_TWON(TWON_ENUMERATION, TWON_ONEVALUE):
ConvertEnum2OneValue(*my_enum, (TW_ONEVALUE *)data);
break;
case TWON_TWON(TWON_ARRAY, TWON_ARRAY):
size =
GetContainerSize(cap.ConType, my_array->ItemType, my_array->NumItems);
memcpy(data, my_array, size);
break;
case TWON_TWON(TWON_ONEVALUE, TWON_ONEVALUE):
memcpy(data, my_one, sizeof(TW_ONEVALUE));
break;
case TWON_TWON(TWON_ONEVALUE, TWON_RANGE):
ConvertOneValue2Range(*my_one, (TW_RANGE *)data);
break;
case TWON_TWON(TWON_ONEVALUE, TWON_ENUMERATION):
ConvertOneValue2Enum(*my_one, (TW_ENUMERATION *)data);
break;
case TWON_TWON(TWON_RANGE, TWON_RANGE):
memcpy(data, my_range, sizeof(TW_RANGE));
break;
case TWON_TWON(TWON_ENUMERATION, TWON_ARRAY):
ConvertEnum2Array(*my_enum, (TW_ARRAY *)data);
break;
default:
assert(0);
GLOBAL_UNLOCK(cap.hContainer);
GLOBAL_FREE(cap.hContainer);
return FALSE;
}
GLOBAL_UNLOCK(cap.hContainer);
GLOBAL_FREE(cap.hContainer);
return TRUE;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int ConvertOneValue2Range(TW_ONEVALUE one_value, TW_RANGE *range) {
range->ItemType = one_value.ItemType;
range->MinValue = one_value.Item;
range->MaxValue = one_value.Item;
range->StepSize = 0;
range->DefaultValue = one_value.Item;
range->CurrentValue = one_value.Item;
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int ConvertEnumeration2Range(TW_ENUMERATION enumeration,
TW_RANGE *range) {
range->ItemType = enumeration.ItemType;
range->MinValue = enumeration.ItemList[0];
range->MaxValue = enumeration.ItemList[enumeration.NumItems - 1];
range->StepSize = (range->MaxValue - range->MinValue) / enumeration.NumItems;
if (range->MaxValue < range->MinValue) {
range->MaxValue = range->MinValue;
range->StepSize = 0;
}
range->DefaultValue = enumeration.ItemList[enumeration.DefaultIndex];
range->CurrentValue = enumeration.ItemList[enumeration.CurrentIndex];
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int ConvertOneValue2Enum(TW_ONEVALUE one_value,
TW_ENUMERATION *tw_enum) {
tw_enum->ItemType = one_value.ItemType;
tw_enum->NumItems = 1;
tw_enum->CurrentIndex = 0; /* Current value is in ItemList[CurrentIndex] */
tw_enum->DefaultIndex = 0; /* Powerup value is in ItemList[DefaultIndex] */
tw_enum->ItemList[0] = (TW_UINT8)one_value.Item;
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int ConvertEnum2OneValue(TW_ENUMERATION tw_enum,
TW_ONEVALUE *one_value) {
unsigned char *base;
TW_UINT32 ofs;
TW_UINT32 itemSize;
itemSize = DCItemSize[tw_enum.ItemType];
base = tw_enum.ItemList;
ofs = tw_enum.CurrentIndex * itemSize;
one_value->ItemType = tw_enum.ItemType;
one_value->Item = 0;
memcpy(&(one_value->Item), &(base[ofs]), itemSize);
return TRUE;
}
/*---------------------------------------------------------------------------*/
static int ConvertEnum2Array(TW_ENUMERATION tw_enum, TW_ARRAY *array) {
TW_UINT32 itemSize;
TW_UINT32 listSize;
itemSize = DCItemSize[tw_enum.ItemType];
listSize = itemSize * tw_enum.NumItems;
array->ItemType = tw_enum.ItemType;
array->NumItems = tw_enum.NumItems;
memcpy(&(array->ItemList), &(tw_enum.ItemList), listSize);
return TRUE;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/* SET CAP */
/*---------------------------------------------------------------------------*/
int TTWAIN_SetCap(TW_UINT16 cap_id, TW_UINT16 conType, TW_UINT16 itemType,
TW_UINT32 *value) {
int rc = FALSE;
TUINT32 size;
TW_CAPABILITY *capability = 0;
TW_HANDLE capabilityH = 0;
TW_ONEVALUE *container = 0;
TW_HANDLE containerH = 0;
size = GetContainerSize(conType, itemType, 1);
containerH = GLOBAL_ALLOC(GMEM_FIXED, size);
if (!containerH) goto done;
container = (TW_ONEVALUE *)GLOBAL_LOCK(containerH);
container->ItemType = itemType;
container->Item = *value;
capabilityH = GLOBAL_ALLOC(GMEM_FIXED, sizeof(TW_CAPABILITY));
if (!capabilityH) {
GLOBAL_UNLOCK(containerH);
GLOBAL_FREE(containerH);
containerH = NULL;
goto done;
}
capability = (TW_CAPABILITY *)GLOBAL_LOCK(capabilityH);
capability->ConType = conType;
capability->hContainer = containerH;
if (TTWAIN_GetState() < TWAIN_SOURCE_OPEN) {
/*TTWAIN_ErrorBox("Setting capability in State < 4.");*/
TTWAIN_OpenSourceManager(0); /* Bring up to state 4 */
/*goto done;*/
}
capability->Cap = cap_id; /* capability id */
rc = (TTWAIN_DS(DG_CONTROL, DAT_CAPABILITY, MSG_SET, (TW_MEMREF)capability) ==
TWRC_SUCCESS);
done:
if (containerH) {
GLOBAL_UNLOCK(containerH);
GLOBAL_FREE(containerH);
}
if (capabilityH) {
GLOBAL_UNLOCK(capabilityH);
GLOBAL_FREE(capabilityH);
}
return rc;
}
/*---------------------------------------------------------------------------*/
static TUINT32 GetContainerSize(int nFormat, unsigned twty, TW_UINT32 nItems) {
TUINT32 size;
switch (nFormat) {
case TWON_ONEVALUE:
size = sizeof(TW_ONEVALUE);
if (DCItemSize[twty] > sizeof(TW_UINT32)) {
size += DCItemSize[twty] - sizeof(TW_UINT32);
}
break;
case TWON_RANGE:
size = sizeof(TW_RANGE);
break;
case TWON_ENUMERATION:
size =
sizeof(TW_ENUMERATION) + DCItemSize[twty] * nItems - sizeof(TW_UINT8);
break;
case TWON_ARRAY:
size = sizeof(TW_ARRAY) + DCItemSize[twty] * nItems - sizeof(TW_UINT8);
break;
default:
size = 0;
break;
} /* switch */
return size;
}
/*---------------------------------------------------------------------------*/
#ifdef __cplusplus
}
#endif

27
toonz/sources/common/twain/ttwain_capability.h
View file

@ -1,27 +0,0 @@
#pragma once
#ifndef __TTWAIN_CAP_H__
#define __TTWAIN_CAP_H__
#include "ttwain.h"
#ifdef __cplusplus
extern "C" {
#endif
/*---------------------------------------------------------------------------*/
/* GET CAP */
/*---------------------------------------------------------------------------*/
int TTWAIN_GetCap(TW_UINT16 cap_id, TW_UINT16 conType, void *data,
TUINT32 *cont_size);
int TTWAIN_GetCapCurrent(TW_UINT16 cap_id, TW_UINT16 conType, void *data,
TUINT32 *cont_size);
int TTWAIN_GetCapQuery(TW_UINT16 cap_id, TW_UINT16 *pattern);
int TTWAIN_SetCap(TW_UINT16 cap_id, TW_UINT16 conType, TW_UINT16 itemType,
TW_UINT32 *value);
#ifdef __cplusplus
}
#endif
#endif

59
toonz/sources/common/twain/ttwain_conversion.c
View file

@ -1,59 +0,0 @@
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include "ttwain_conversion.h"
#ifdef __cplusplus
extern "C" {
#endif
float TTWAIN_Fix32ToFloat(TW_FIX32 fix) {
TW_INT32 val;
val = ((TW_INT32)fix.Whole << 16) | ((TW_UINT32)fix.Frac & 0xffff);
return (float)(val / 65536.0);
}
/*---------------------------------------------------------------------------*/
TW_FIX32 TTWAIN_FloatToFix32(float fl) {
TW_FIX32 fix;
TW_INT32 val;
assert(sizeof(TW_FIX32) == sizeof(float));
assert(sizeof(TW_FIX32) == sizeof(long));
/* Note 1: This round-away-from-0 is new in TWAIN 1.7
Note 2: ANSI C converts float to int by truncating toward 0.*/
val = (TW_INT32)(fl * 65536.0 + (fl < 0 ? -0.5 : +0.5));
fix.Whole = (TW_INT16)(val >> 16); /* most significant 16 bits */
fix.Frac = (TW_UINT16)(val & 0xffff); /* least */
return fix;
}
/*---------------------------------------------------------------------------*/
void TTWAIN_ConvertRevStrToRevNum(const char *rev_str, TW_UINT16 *maj_num,
TW_UINT16 *min_num) {
char *maj_str;
char *min_str;
size_t maj_size;
size_t min_size;
*maj_num = *min_num = 0;
maj_size = strcspn(rev_str, ".");
maj_str = (char *)calloc(sizeof(char), maj_size + 1);
if (!maj_str) return;
memcpy(maj_str, rev_str, maj_size); /*already 0term*/
*maj_num = (TW_UINT16)atoi(maj_str);
min_size = strlen(rev_str) - maj_size + 1;
min_str = (char *)calloc(sizeof(char), min_size + 1);
if (!min_str) return;
memcpy(min_str, &(rev_str[maj_size + 1]), min_size); /*already 0term*/
*min_num = (TW_UINT16)atoi(min_str);
if (maj_str) free(maj_str);
if (min_str) free(min_str);
}
/*---------------------------------------------------------------------------*/
#ifdef __cplusplus
}
#endif

21
toonz/sources/common/twain/ttwain_conversion.h
View file

@ -1,21 +0,0 @@
#pragma once
#ifndef __TTWAIN_CONV_H__
#define __TTWAIN_CONV_H__
#include "twain.h"
#ifdef __cplusplus
extern "C" {
#endif
float TTWAIN_Fix32ToFloat(TW_FIX32 fix);
TW_FIX32 TTWAIN_FloatToFix32(float fl);
void TTWAIN_ConvertRevStrToRevNum(const char *rev_str, TW_UINT16 *maj_num,
TW_UINT16 *min_num);
#ifdef __cplusplus
}
#endif
#endif

142
toonz/sources/common/twain/ttwain_error.c
View file

@ -1,142 +0,0 @@
#ifdef _MSC_VER
#pragma warning(disable : 4996)
#endif
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "ttwain_state.h"
#include "ttwain_error.h"
#include "ttwain_util.h"
#ifdef __cplusplus
extern "C" {
#endif
static char Msg_out[1024];
#define HUMAN_MESSAGES
#ifdef HUMAN_MESSAGES
const char *RC_msg[] = {"SUCCESS",
"FAILURE",
"CHECK STATUS ('tried hard')",
"CANCEL",
"DS EVENT",
"NOT DSEVENT",
"TRANSFER DONE",
"END OF LIST",
"INFO NOT SUPPORTED",
"DATA NOT AVAILABLE"};
const char *CC_msg[] = {
"SUCCESS",
"FAILURE DUE TO UNKNOWN CAUSES",
"LOW MEMORY",
"NO DATA SOURCE",
"DS IS CONNECTED TO MAX POSSIBLE APPS",
"OPERATION ERROR, DS/DSM REPORTED ERROR",
"UNKNOWN CAPABILITY",
"undefined",
"undefined",
"UNRECOGNIZED TRIPLET",
"DATA PARAMETER OUT OF RANGE",
"TRIPLET OUT OF SEQUENCE",
"UNKNOWN DESTINATION APP/SRC IN DSM_ESNTRY",
"CAP NOT SUPPORTED BY SOURCE",
"OPERATION NOT SUPPORTED BY CAP",
"CAP HAS DEPENDANCY ON OTHER CAP",
"FILE SYSTEM OPERATION IS DENIED (FILE IS PROTECTED)",
"OPERATION FAILED BECAUSE FILE ALREADY EXISTS",
"FILE NOT FOUND",
"OPERATION FAILED BECAUSE DIRECTORY IS NOT EMPTY",
"THE FEEDER IS JAMMED",
"THE FEEDER DETECTED MULTIPLE PAGES",
"ERROR WRITING THE FILE (MEANT FOR THINGS LIKE DISK FULL CONDITIONS)",
"THE DEVICE WENT OFFLINE PRIOR TO OR DURING THIS OPERATION"};
#else
const char *RC_msg[] = {
"TWRC_SUCCESS", "TWRC_FAILURE", "TWRC_CHECKSTATUS ('tried hard')",
"TWRC_CANCEL", "TWRC_DSEVENT", "TWRC_NOTDSEVENT",
"TWRC_XFERDONE", "TWRC_ENDOFLIST", "TWRC_INFONOTSUPPORTED",
"TWRC_DATANOTAVAILABLE"};
const char *CC_msg[] = {
"TWCC_SUCCESS", "TWCC_BUMMER (Failure due to unknown causes)",
"TWCC_LOWMEMORY", "TWCC_NODS (No Data Source)",
"TWCC_MAXCONNECTIONS (DS is connected to max possible apps)",
"TWCC_OPERATIONERROR (DS/DSM reported error, app shouldn't)",
"TWCC_BADCAP (Unknown capability)", "7 (undefined)", "8 (undefined)",
"TWCC_BADPROTOCOL (Unrecognized triplet)",
"TWCC_BADVALUE (Data parameter out of range)",
"TWCC_SEQERROR (Triplet out of sequence)",
"TWCC_BADDEST (Unknown dest. App/Src in DSM_Esntry)",
"TWCC_CAPUNSUPPORTED (Cap not supported by source)",
"TWCC_CAPBADOPERATION (Operation not supported by cap)",
"TWCC_CAPSEQERROR (Cap has dependancy on other cap)",
"TWCC_DENIED (File System operation is denied (file is protected))",
"TWCC_FILEEXISTS (Operation failed because file already exists)",
"TWCC_FILENOTFOUND (File not found)",
"TWCC_NOTEMPTY (Operation failed because directory is not empty)",
"TWCC_PAPERJAM (The feeder is jammed)",
"TWCC_PAPERDOUBLEFEED (The feeder detected multiple pages)",
"TWCC_FILEWRITEERROR (Error writing the file (meant for things like disk "
"full conditions))",
"TWCC_CHECKDEVICEONLINE (The device went offline prior to or during this "
"operation)"};
#endif
/*---------------------------------------------------------------------------*/
void TTWAIN_RecordError(void) {
char tmp[1024];
TTwainData.ErrRC = TTWAIN_GetResultCode();
if ((TTwainData.ErrRC == TWRC_FAILURE) ||
(TTwainData.ErrRC == TWRC_CHECKSTATUS))
TTwainData.ErrCC = TTWAIN_GetConditionCode();
else
TTwainData.ErrCC = -1;
if (TTwainData.ErrRC < (sizeof(RC_msg) / sizeof(RC_msg[0]))) {
snprintf(Msg_out, sizeof(Msg_out), "RC: %s(%d)",
RC_msg[TTwainData.ErrRC], (int)TTwainData.ErrRC);
} else {
snprintf(Msg_out, sizeof(Msg_out), "RC: %s(%d)", "unknown",
(int)TTwainData.ErrRC);
}
if (TTwainData.ErrCC < (sizeof(CC_msg) / sizeof(CC_msg[0]))) {
snprintf(tmp, sizeof(tmp), "CC: %s(%d)", CC_msg[TTwainData.ErrCC],
(int)TTwainData.ErrCC);
strcat(Msg_out, tmp);
} else {
snprintf(tmp, sizeof(tmp), "CC: %s(%d)", "unknown",
(int)TTwainData.ErrCC);
strcat(Msg_out, tmp);
}
if (TTwainData.ErrRC == TWRC_FAILURE &&
TTwainData.ErrCC == TWCC_OPERATIONERROR) {
#ifdef _WIN32
OutputDebugString(Msg_out);
#else
#ifdef TOONZDEBUG
printf("%s\n", Msg_out);
#endif
#endif
}
return;
}
/*---------------------------------------------------------------------------*/
char *TTWAIN_GetLastError(TUINT32 *rc, TUINT32 *cc) {
assert(rc && cc);
*rc = TTwainData.ErrRC;
*cc = TTwainData.ErrCC;
return Msg_out;
}
/*---------------------------------------------------------------------------*/
#ifdef __cplusplus
}
#endif

16
toonz/sources/common/twain/ttwain_error.h
View file

@ -1,16 +0,0 @@
#pragma once
#ifndef __TTWAIN_ERROR_H__
#define __TTWAIN_ERROR_H__
#ifdef __cplusplus
extern "C" {
#endif
void TTWAIN_RecordError(void);
#ifdef __cplusplus
}
#endif
#endif

61
toonz/sources/common/twain/ttwain_global_def.h
View file

@ -1,61 +0,0 @@
#pragma once
/*max@home*/
#ifndef __GLOBAL_DEF_H__
#define __GLOBAL_DEF_H__
#ifdef _WIN32
#define GLOBAL_LOCK(P) GlobalLock(P)
#define GLOBAL_ALLOC(T, S) GlobalAlloc(T, S)
#define GLOBAL_FREE(P) GlobalFree(P)
#define GLOBAL_UNLOCK(P) GlobalUnlock(P)
#else
#ifdef __APPLE__
/*
#define GLOBAL_LOCK(P) *(P)
//#define GLOBAL_ALLOC(T, S) NewHandle(S)
//#define GLOBAL_FREE(P) DisposeHandle( (char**)P)
#define GLOBAL_ALLOC(T, S) (TW_HANDLE)NewPtr(S)
#define GLOBAL_FREE(S) DisposePtr(S)
#define GLOBAL_UNLOCK(P) {}
*/
#define GLOBAL_ALLOC(T, S) NewHandle(S)
#define GLOBAL_FREE(P) DisposeHandle(P)
//#define GLOBAL_ALLOC(T, S) (TW_HANDLE)NewPtr(S)
//#define GLOBAL_FREE(S) DisposePtr((char*)S)
#ifdef __cplusplus
extern "C" {
#endif
TW_HANDLE GLOBAL_LOCK(TW_HANDLE S);
#ifdef __cplusplus
}
#endif
#define GLOBAL_UNLOCK(P) HUnlock((TW_HANDLE)P)
#else /* UNIX */
#include <stdlib.h>
/* just some hack to get it built */
typedef void *TW_HANDLE;
#define GLOBAL_LOCK(P) (P)
#define GLOBAL_ALLOC(T, S) malloc(S)
#define GLOBAL_FREE(P) free(P)
#define GLOBAL_UNLOCK(P)
#endif
#endif
#endif /*__GLOBAL_DEF_H__*/
#ifdef __cplusplus
extern "C" {
#endif
void TTWAIN_ErrorBox(const char *msg);
#ifdef __cplusplus
}
#endif

1249
toonz/sources/common/twain/ttwain_state.c
View file

File diff suppressed because it is too large Load diff

25
toonz/sources/common/twain/ttwain_state.h
View file

@ -1,25 +0,0 @@
#pragma once
#ifndef __TTWAIN_STATE_H__
#define __TTWAIN_STATE_H__
#include "ttwain.h"
#include "ttwainP.h"
#ifdef __cplusplus
extern "C" {
#endif
int TTWAIN_LoadSourceManager(void);
int TTWAIN_UnloadSourceManager(void);
TUINT32 TTWAIN_GetResultCode(void);
TUINT32 TTWAIN_GetConditionCode(void);
int TTWAIN_DSM_HasEntryPoint(void);
TW_INT16 TTWAIN_DS(TUINT32 dg, TUINT32 dat, TUINT32 msg, void *pd);
TWAINSTATE TTWAIN_GetState(void);
#ifdef __cplusplus
}
#endif
#endif

41
toonz/sources/common/twain/ttwain_stateM.c
View file

@ -1,41 +0,0 @@
/*max@home*/
#include "twain.h"
#include "ttwain_state.h"
#include "ttwainP.h"
#include "ttwain_statePD.h"
#include "ttwain_util.h"
#ifdef __cplusplus
extern "C" {
#endif
extern void TTWAIN_SetState(TWAINSTATE status);
int TTWAIN_LoadSourceManagerPD(void) {
if (TTWAIN_GetState() >= TWAIN_SM_LOADED)
return TRUE; /* DSM already loaded */
TTwainData.DSM_Entry = DSM_Entry;
if (TTwainData.DSM_Entry != 0 /*kUnresolveCFragSymbolAddress*/) {
TTWAIN_SetAvailable(AVAIABLE_YES);
TTWAIN_SetState(TWAIN_SM_LOADED);
} else {
printf("DSM Entry NOT found !\n");
return FALSE;
}
return (TTWAIN_GetState() >= TWAIN_SM_LOADED);
}
int TTWAIN_UnloadSourceManagerPD(void) {
if (TTWAIN_GetState() == TWAIN_SM_LOADED) {
TTwainData.DSM_Entry = 0;
TTWAIN_SetState(TWAIN_PRESESSION);
}
return (TTWAIN_GetState() == TWAIN_PRESESSION);
}
/*-----------------------------------------------------------------------------*/
#ifdef __cplusplus
}
#endif

19
toonz/sources/common/twain/ttwain_statePD.h
View file

@ -1,19 +0,0 @@
#pragma once
#ifndef __TTWAIN_STATE_PD_H__
#define __TTWAIN_STATE_PD_H__
#ifdef __cplusplus
extern "C" {
#endif
int TTWAIN_LoadSourceManagerPD(void);
int TTWAIN_UnloadSourceManagerPD(void);
int TTWAIN_UnloadSourceManagerPD(void);
void TTWAIN_EmptyMessageQueuePD(void);
#ifdef __cplusplus
}
#endif
#endif

77
toonz/sources/common/twain/ttwain_stateW.c
View file

@ -1,77 +0,0 @@
#pragma warning(disable : 4996)
#include <windows.h>
#include <stdlib.h>
#include "ttwain_state.h"
#include "ttwainP.h"
#include "ttwain_statePD.h"
#include "ttwain_util.h"
#ifdef __cplusplus
extern "C" {
#endif
static void *hDSMLib; /* handle of DSM */
extern void TTWAIN_SetState(TWAINSTATE status);
int TTWAIN_LoadSourceManagerPD(void) {
char winDir[_MAX_PATH];
if (TTWAIN_GetState() >= TWAIN_SM_LOADED)
return TRUE; /* DSM already loaded */
GetWindowsDirectory(winDir, _MAX_PATH);
if (!winDir[0]) return FALSE;
strcat(winDir, "\\system32\\");
// strcat(winDir, "\\");
strcat(winDir, DSM_FILENAME);
hDSMLib = LoadLibrary(winDir);
/*
if (tnz_access(winDir, 0x00) != -1)
hDSMLib = LoadLibrary(winDir);
else
{
hDSMLib = 0;
return FALSE;
}
*/
if (hDSMLib) {
TTwainData.DSM_Entry =
(DSMENTRYPROC)GetProcAddress(hDSMLib, DSM_ENTRYPOINT);
if (TTwainData.DSM_Entry) {
TTWAIN_SetAvailable(AVAIABLE_YES);
TTWAIN_SetState(TWAIN_SM_LOADED);
} else {
FreeLibrary(hDSMLib);
hDSMLib = NULL;
}
} else {
DWORD err = GetLastError();
TTwainData.DSM_Entry = 0;
}
return (TTWAIN_GetState() >= TWAIN_SM_LOADED);
}
/*---------------------------------------------------------------------------*/
int TTWAIN_UnloadSourceManagerPD(void) {
if (TTWAIN_GetState() == TWAIN_SM_LOADED) {
if (hDSMLib) {
FreeLibrary(hDSMLib);
hDSMLib = NULL;
}
TTwainData.DSM_Entry = NULL;
TTWAIN_SetState(TWAIN_PRESESSION);
}
return (TTWAIN_GetState() == TWAIN_PRESESSION);
}
/*---------------------------------------------------------------------------*/
#ifdef __cplusplus
}
#endif

14
toonz/sources/common/twain/ttwain_stateX.c
View file

@ -1,14 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "ttwain_statePD.h"
int TTWAIN_LoadSourceManagerPD(void) { return 0; }
int TTWAIN_UnloadSourceManagerPD(void) { return 1; }
#ifdef __cplusplus
}
#endif

1302
toonz/sources/common/twain/ttwain_util.c
View file

File diff suppressed because it is too large Load diff

134
toonz/sources/common/twain/ttwain_util.h
View file

@ -1,134 +0,0 @@
#pragma once
#ifndef __TTWAIN_UTIL_H__
#define __TTWAIN_UTIL_H__
#include "ttwain.h"
#undef TNZAPI
#ifdef TNZ_IS_DEVICELIB
#define TNZ_EXPORT_API
#else
#define TNZ_IMPORT_API
#endif
#ifdef __cplusplus
extern "C" {
#endif
int TTWAIN_IsAvailable(void);
void TTWAIN_SetAvailable(TWAINAVAILABLE status);
char *TTWAIN_GetLastError(TUINT32 *rc, TUINT32 *cc);
int TTWAIN_GetResolution(float *min, float *max, float *step, float *def);
int TTWAIN_GetOpticalResolution(float *min, float *max, float *step,
float *def);
int TTWAIN_GetBrightness(float *min, float *max, float *step, float *def);
int TTWAIN_GetContrast(float *min, float *max, float *step, float *def);
int TTWAIN_GetThreshold(float *min, float *max, float *step, float *def);
int TTWAIN_GetPhysicalWidthWAdf(float *width);
int TTWAIN_GetPhysicalHeightWAdf(float *height);
int TTWAIN_GetMinimumWidthWAdf(float *width);
int TTWAIN_GetMinimumHeightWAdf(float *height);
int TTWAIN_GetPhysicalWidthWoAdf(float *width);
int TTWAIN_GetPhysicalHeightWoAdf(float *height);
int TTWAIN_GetMinimumWidthWoAdf(float *width);
int TTWAIN_GetMinimumHeightWoAdf(float *height);
int TTWAIN_SupportsPixelType(TTWAIN_PIXTYPE pix);
int TTWAIN_SupportsFeeder(void);
int TTWAIN_SupportsCompressionType(TW_UINT16 comprType);
int TTWAIN_GetSupportedCaps(void);
int TTWAIN_GetFeeder(void);
int TTWAIN_IsFeederLoaded(void);
/* this function should return the current value */
int TTWAIN_GetCurrentPixelType(TTWAIN_PIXTYPE *pixType);
/* */
int TTWAIN_IsCapResolutionSupported(void);
int TTWAIN_IsCapOpticalResolutionSupported(void);
int TTWAIN_IsCapBrightnessSupported(void);
int TTWAIN_IsCapContrastSupported(void);
int TTWAIN_IsCapThresholdSupported(void);
int TTWAIN_IsCapPhysicalWidthSupported(void);
int TTWAIN_IsCapPhysicalHeightSupported(void);
int TTWAIN_IsCapMinimumWidthSupported(void);
int TTWAIN_IsCapMinimumHeightSupported(void);
int TTWAIN_IsCapPixelTypeSupported(void);
int TTWAIN_IsCapFeederSupported(void);
int TTWAIN_IsCapImageLayoutSupported(void);
int TTWAIN_IsCapOrientationSupported(void);
int TTWAIN_IsCapDeviceOnLineSupported(void);
int TTWAIN_IsCapBitDepthSupported(void);
int TTWAIN_IsCapBitOrderSupported(void);
int TTWAIN_IsCapCompressionSupported(void);
int TTWAIN_SetResolution(float resolution);
int TTWAIN_SetContrast(float contrast);
int TTWAIN_SetBrightness(float brightness);
int TTWAIN_SetThreshold(float threshold);
int TTWAIN_SetXScaling(float scale);
int TTWAIN_SetYScaling(float scale);
int TTWAIN_SetPixelType(TTWAIN_PIXTYPE pixtype);
int TTWAIN_SetBitDepth(USHORT bitDepth);
int TTWAIN_SetBitOrder(TTWAIN_BITORDER bitOrder);
int TTWAIN_SetImageLayout(float L, float T, float R, float B);
int TTWAIN_SetOrientation(USHORT orientation);
int TTWAIN_SetFeeder(int status); /* TRUE->enabled */
int TTWAIN_SetPage(void);
void TTWAIN_DumpCapabilities(void (*trace_fun)(const char *fmt, ...));
/* USER INTERFACE */
int TTWAIN_HasControllableUI(void);
/* Return 1 if source claims UI can be hidden (see SetUIStatus above)
Return 0 if source says UI *cannot* be hidden
Return -1 if source (pre TWAIN 1.6) cannot answer the question. */
int TTWAIN_GetUIStatus(void);
void TTWAIN_SetUIStatus(int status);
int TTWAIN_IsDeviceOnLine(void); /* -1 unknown, 0 no, 1 yes */
/* info about the twain driver */
char *TTWAIN_GetManufacturer(void); /* */
char *TTWAIN_GetProductFamily(void); /* return an internal static var*/
char *TTWAIN_GetProductName(void); /* don't free ret. value */
char *TTWAIN_GetVersion(void); /* */
char *TTWAIN_GetTwainVersion(void); /* */
int TTWAIN_Native2Raster(void *handle, void *the_ras, int *lx, int *ly);
int TTWAIN_SetXferMech(TTWAIN_TRANSFER_MECH mech, void *ptr, TUINT32 size,
int preferredLx, int preferredLy,
TUINT32 numberOfImages);
/* NATIVE BUFFERED FILE
mech the transfer mechanism
ptr 0 memory buffer ?Not Impl. filename ?
size 0 size of the buffer ?Not Impl.?
preferredLx lx lx ?Not Impl.? lx?
preferredLy ly ly ?Not Impl.? ly?
numberOfImages 1,2,.... or -1 for all in the ADF
*/
#endif
#ifdef NOTES
here
/* The XScaling cap. should be negotiated before the YScaling, this is because
some Sources may set the YScaling capability whenever XScaling capability
is set, to maintain a square aspect ratio for Applications that do not
bother to negotiate YScaling capability. (note from Twain Spec 1.9 draft)
*/
#endif
#ifdef __cplusplus
}
#endif

21
toonz/sources/common/twain/ttwain_utilM.c
View file

@ -1,21 +0,0 @@
#include "ttwain_utilPD.h"
#include "ttwain.h"
#ifdef __cplusplus
extern "C" {
#endif
TW_HANDLE GLOBAL_LOCK(TW_HANDLE S) {
HLock(S);
return (TW_HANDLE)*S;
}
int TTWAIN_Native2RasterPD(void *handle, void *the_ras, int *lx, int *ly) {
return 0;
}
#ifdef __cplusplus
}
#endif

18
toonz/sources/common/twain/ttwain_utilP.h
View file

@ -1,18 +0,0 @@
#pragma once
#ifndef __TTWAIN_UTILP_H__
#define __TTWAIN_UTILP_H__
#ifdef __cplusplus
extern "C" {
#endif
int TTWAIN_NegotiateXferCount(TUINT32 nXfers);
int TTWAIN_InitSupportedCaps(void);
int TTWAIN_GetModalStatus(void);
#ifdef __cplusplus
}
#endif
#endif /*__TTWAIN_UTILP_H__*/

16
toonz/sources/common/twain/ttwain_utilPD.h
View file

@ -1,16 +0,0 @@
#pragma once
#ifndef __TTWAIN_UTIL_PD_H__
#define __TTWAIN_UTIL_PD_H__
#ifdef __cplusplus
extern "C" {
#endif
int TTWAIN_Native2RasterPD(void *handle, void *the_ras, int *lx, int *ly);
#ifdef __cplusplus
}
#endif
#endif /*__TTWAIN_UTIL_PD_H__*/

43
toonz/sources/common/twain/ttwain_utilW.c
View file

@ -1,43 +0,0 @@
#include <windows.h>
#include "assert.h"
#include "ttwainP.h"
#include "ttwain_utilPD.h"
#include "ttwain_global_def.h"
#ifdef __cplusplus
extern "C" {
#endif
static int getColorCount(LPBITMAPINFOHEADER pbi) {
if (pbi->biSize == sizeof(BITMAPCOREHEADER)) {
LPBITMAPCOREHEADER lpbc = ((LPBITMAPCOREHEADER)pbi);
return 1 << lpbc->bcBitCount;
} else if (pbi->biClrUsed == 0)
return 0xFFF & (1 << pbi->biBitCount);
else
return (int)pbi->biClrUsed;
}
/*---------------------------------------------------------------------------*/
static size_t BmiColorTableBytes(LPBITMAPINFOHEADER pbi) {
return getColorCount(pbi) * sizeof(RGBQUAD);
}
/*---------------------------------------------------------------------------*/
static LPBYTE get_buffer(LPBITMAPINFOHEADER lpbi, int *iud) {
LPBYTE buf = (LPBYTE)lpbi + lpbi->biSize + BmiColorTableBytes(lpbi);
*iud = (lpbi->biHeight > 0);
return buf;
}
/*---------------------------------------------------------------------------*/
#define PelsPerMeter2DPI(ppm) (((float)ppm * 2.54) / 100.0)
/*---------------------------------------------------------------------------*/
int TTWAIN_Native2RasterPD(void *handle, void *the_ras, int *lx, int *ly) {
assert(!"DAFARE");
return 1;
}
#ifdef __cplusplus
}
#endif

15
toonz/sources/common/twain/ttwain_utilX.c
View file

@ -1,15 +0,0 @@
#include "ttwain_utilPD.h"
#ifdef __cplusplus
extern "C" {
#endif
int TTWAIN_Native2RasterPD(void *handle, void *the_ras, int *lx, int *ly) {
return 0;
}
#ifdef __cplusplus
}
#endif

22
toonz/sources/common/twain/ttwain_win.c
View file

@ -1,22 +0,0 @@
#include "ttwain_win.h"
#include "ttwain_winPD.h"
#ifdef __cplusplus
extern "C" {
#endif
void *TTWAIN_GetValidHwnd(void *hwnd) { return TTWAIN_GetValidHwndPD(hwnd); }
int TTWAIN_EnableWindow(void *hwnd, int flag) {
return TTWAIN_EnableWindowPD(hwnd, flag);
}
// static void TTWAIN_EmptyMessageQueue(void) { TTWAIN_EmptyMessageQueuePD(); }
// static void TTWAIN_ModalEventLoop(void) { TTWAIN_ModalEventLoopPD(); }
#ifdef __cplusplus
}
#endif

17
toonz/sources/common/twain/ttwain_win.h
View file

@ -1,17 +0,0 @@
#pragma once
#ifndef __TTWAIN_WIN_H__
#define __TTWAIN_WIN_H__
#ifdef __cplusplus
extern "C" {
#endif
void *TTWAIN_GetValidHwnd(void *hwnd);
int TTWAIN_EnableWindow(void *hwnd, int flag);
#ifdef __cplusplus
}
#endif
#endif

225
toonz/sources/common/twain/ttwain_winM.c
View file

@ -1,225 +0,0 @@
/*max@home*/
#ifdef __cplusplus
extern "C" {
#endif
#include <Cocoa/Cocoa.h>
#include "ttwain_state.h"
#include "ttwainP.h"
//#define DEBUG
#ifndef _WIN32
#define PRINTF(args...)
#else
#define PRINTF
#endif
#if 1
extern int TTWAIN_MessageHook(void *lpmsg);
OSErr CPSSetProcessName(ProcessSerialNumber *psn, char *processname);
OSErr CPSEnableForegroundOperation(ProcessSerialNumber *psn, UInt32 _arg2,
UInt32 _arg3, UInt32 _arg4, UInt32 _arg5);
int ScanDone = 0;
void setupUI(void);
/*---------------------------------------------------------------------------*/
void *TTWAIN_GetValidHwndPD(void *hwnd) {
setupUI();
return 0;
}
/*---------------------------------------------------------------------------*/
int TTWAIN_EnableWindowPD(void *hwnd, int flag) {
printf("%s\n", __PRETTY_FUNCTION__);
return 1;
}
/*---------------------------------------------------------------------------*/
static int CallbackRegistered = false;
void unregisterTwainCallback(void) {
printf("unregistering\n");
CallbackRegistered = 0;
}
/*---------------------------------------------------------------------------*/
TW_UINT16 twainCallback(pTW_IDENTITY pOrigin, pTW_IDENTITY pDest, TW_UINT32 DG,
TW_UINT16 DAT, TW_UINT16 MSG, TW_MEMREF pData) {
PRINTF("%s msg=0x%x\n", __PRETTY_FUNCTION__, MSG);
TTWAIN_MessageHook((void *)MSG);
return TWRC_SUCCESS;
}
/*---------------------------------------------------------------------------*/
int exitTwainSession(void) {
/*
EventQueueRef q = GetCurrentEventQueue();
printf("flushing event queue\n");
FlushEventQueue(q);
*/
#ifdef __i386
/*At this time the HP Scan Pro DS (OSX on i386) need at least 1 sec to process
closeUI msg
If we are too fast exiting from the application loop, the msg stay in the
queue and it will be processed the next time we open the ui !!!
Flusing the queue (see above) doesn't work, because is possible that we are
too fast purging the queue.
1 sec seems to be ok
2 sec is safe :)
*/
sleep(2);
#endif
printf("calling QuitApplicationEventLoop\n");
// QuitApplicationEventLoop();
unregisterTwainCallback();
return 0;
}
/*---------------------------------------------------------------------------*/
static void myEventLoopTimer() {
printf("my event loop timer ScanDone = %d\n", ScanDone);
// if (ScanDone)
// QuitApplicationEventLoop ();
}
/*---------------------------------------------------------------------------*/
void setupUI(void) {
ProcessSerialNumber psn;
GetCurrentProcess(&psn);
/* Need to do some magic here to get the UI to work */
CPSEnableForegroundOperation(&psn, 0x03, 0x3C, 0x2C, 0x1103);
SetFrontProcess(&psn);
#ifndef HAVE_DOCK_TILE
/* We end up with the ugly console dock icon; let's override it */
/*char *iconfile = "/tmp/image.png";
CFURLRef url = CFURLCreateFromFileSystemRepresentation (kCFAllocatorDefault,
(UInt8 *)iconfile,
strlen (iconfile),
FALSE);
CGDataProviderRef png = CGDataProviderCreateWithURL (url);
CGImageRef icon = CGImageCreateWithPNGDataProvider (png, NULL, TRUE,
kCGRenderingIntentDefault);
/* Voodoo magic fix inspired by java_swt launcher */
/* Without this the icon setting doesn't work about half the time. */
// CGrafPtr p = BeginQDContextForApplicationDockTile();
// EndQDContextForApplicationDockTile(p);
// SetApplicationDockTileImage (icon);
#else
int numComponents = 4;
int bitsPerPixelChannel = 8;
int totalBitsPerPixel = bitsPerPixelChannel * numComponents;
int w = 32;
int h = 32;
char *buffer[w * h * numComponents];
CGContextRef context;
CGDataProviderRef provider;
CGColorSpaceRef colorSpace;
CGImageRef image;
int bytesPerRow = w * numComponents;
context = BeginCGContextForApplicationDockTile();
provider = CGDataProviderCreateWithData(0, buffer, (bytesPerRow * h), 0);
colorSpace = CGColorSpaceCreateDeviceRGB();
image = CGImageCreate(w, h, bitsPerPixelChannel, totalBitsPerPixel,
bytesPerRow, colorSpace, kCGImageAlphaFirst, provider,
0, 0, kCGRenderingIntentDefault);
CGDataProviderRelease(provider);
CGColorSpaceRelease(colorSpace);
SetApplicationDockTileImage(image);
CGContextFlush(context);
CGImageRelease(image);
EndCGContextForApplicationDockTile(context);
#endif
}
/*---------------------------------------------------------------------------*/
void registerTwainCallback(void) {
if (TTWAIN_GetState() < TWAIN_SOURCE_OPEN) {
PRINTF("%s too early!, don't register\n", __FUNCTION__);
CallbackRegistered = 0;
return;
}
if (TTWAIN_GetState() != 4) {
PRINTF("%s state != 4, don't register\n", __FUNCTION__);
CallbackRegistered = 0;
return;
}
if (!CallbackRegistered) {
int rc = 0;
TW_CALLBACK callback;
PRINTF("%s registering\n", __FUNCTION__);
/* We need to set up our callback to receive messages */
callback.CallBackProc = (TW_MEMREF)twainCallback;
callback.RefCon = 0; /* user data */
callback.Message = 0;
printf("registering\n");
/*
processed = TTWAIN_DS(DG_CONTROL, DAT_CALLBACK, MSG_REGISTER_CALLBACK,
(TW_MEMREF) &callback);
*/
rc = TTwainData.resultCode =
(*TTwainData.DSM_Entry)(&TTwainData.appId, 0, DG_CONTROL, DAT_CALLBACK,
MSG_REGISTER_CALLBACK, (TW_MEMREF)&callback);
// NSRunLoop* runLoop = [NSRunLoop currentRunLoop];
// EventLoopTimerRef timer;
/*OSStatus err;
// Set this up to run once the event loop is started
err = InstallEventLoopTimer (GetMainEventLoop (),
0, 0, // Immediately, once only
NewEventLoopTimerUPP (myEventLoopTimer),
0, &timer);*/
CallbackRegistered = 1;
} else {
PRINTF("%s already registered!, don't register\n", __FUNCTION__);
}
}
/*---------------------------------------------------------------------------*/
void TTWAIN_EmptyMessageQueuePD(void) {
ScanDone = 0;
registerTwainCallback();
}
/*---------------------------------------------------------------------------*/
void TTWAIN_ModalEventLoopPD(void) {
printf("%s\n", __PRETTY_FUNCTION__);
registerTwainCallback();
// RunApplicationEventLoop();
return;
TTwainData.breakModalLoop = FALSE;
}
#endif
#ifdef __cplusplus
}
#endif

19
toonz/sources/common/twain/ttwain_winPD.h
View file

@ -1,19 +0,0 @@
#pragma once
#ifndef __TTWAIN_WIN_PD_H__
#define __TTWAIN_WIN_PD_H__
#ifdef __cplusplus
extern "C" {
#endif
void *TTWAIN_GetValidHwndPD(void *hwnd);
int TTWAIN_EnableWindowPD(void *hwnd, int flag);
void TTWAIN_EmptyMessageQueuePD(void);
void TTWAIN_ModalEventLoopPD(void);
#ifdef __cplusplus
}
#endif
#endif

95
toonz/sources/common/twain/ttwain_winW.c
View file

@ -1,95 +0,0 @@
#include <windows.h>
#include <assert.h>
#include "ttwain_win.h"
#include "ttwain_winPD.h"
#include "ttwain_state.h"
#include "ttwain_error.h"
#define HINSTLIB0 0
static HWND Dummy = 0; /* proxy window */
extern int TTWAIN_MessageHook(void *lpmsg);
static HWND CreateDummyWindow(void) {
HWND hwnd;
hwnd = CreateWindow("STATIC", // class
"Acquire Dummy", // title
WS_POPUPWINDOW, // style
CW_USEDEFAULT, CW_USEDEFAULT, // x, y
CW_USEDEFAULT, CW_USEDEFAULT, // width, height
HWND_DESKTOP, // parent window
NULL, // hmenu
HINSTLIB0, // hinst
NULL); // lpvparam
return hwnd;
}
/*---------------------------------------------------------------------------*/
void *TTWAIN_GetValidHwndPD(void *_hwnd)
// Returns a valid window handle as follows:
// If hwnd is a valid window handle, hwnd is returned.
// Otherwise a proxy window handle is created and returned.
// Once created, a proxy window handle is destroyed when
// the source manager is unloaded.
// If hwnd is an invalid window handle (other than NULL)
// an error box is displayed.
{
HWND hwnd = (HWND)_hwnd;
if (!IsWindow(hwnd)) {
if (hwnd != NULL) {
assert(!"Window handle is invalid");
hwnd = NULL;
}
if (!Dummy) {
Dummy = CreateDummyWindow();
if (!IsWindow(Dummy)) {
assert(!"Unable to create Dummy window");
Dummy = NULL;
}
}
hwnd = Dummy;
}
return (void *)hwnd;
}
/*---------------------------------------------------------------------------*/
void TTWAIN_EmptyMessageQueuePD(void) {
MSG msg;
#ifdef _DEBUG
OutputDebugString("EmptyMsgQ<");
#endif
while (PeekMessage((LPMSG)&msg, NULL, 0, 0, PM_REMOVE)) {
if (!TTWAIN_MessageHook((LPMSG)&msg)) {
TranslateMessage((LPMSG)&msg);
DispatchMessage((LPMSG)&msg);
#ifdef _DEBUG
OutputDebugString("-");
#endif
} else {
#ifdef _DEBUG
OutputDebugString("T");
#endif
}
}
#ifdef _DEBUG
OutputDebugString(">\n");
#endif
}
void TTWAIN_ModalEventLoopPD(void) {
MSG msg;
// Clear global breakout flag
TTwainData.breakModalLoop = FALSE;
while ((TTWAIN_GetState() >= TWAIN_SOURCE_ENABLED) &&
!TTwainData.breakModalLoop && GetMessage((LPMSG)&msg, NULL, 0, 0)) {
if (!TTWAIN_MessageHook((LPMSG)&msg)) {
TranslateMessage((LPMSG)&msg);
DispatchMessage((LPMSG)&msg);
}
} // while
TTwainData.breakModalLoop = FALSE;
}
int TTWAIN_EnableWindowPD(void *hwnd, int flag) {
return EnableWindow(hwnd, flag);
}

12
toonz/sources/common/twain/ttwain_winX.c
View file

@ -1,12 +0,0 @@
#include "ttwain_winPD.h"
void *TTWAIN_GetValidHwndPD(void *hwnd) { return 0; }
/*---------------------------------------------------------------------------*/
int TTWAIN_EnableWindowPD(void *hwnd, int flag) { return 0; }
/*---------------------------------------------------------------------------*/
void TTWAIN_EmptyMessageQueuePD(void) { return; }
/*---------------------------------------------------------------------------*/
void TTWAIN_ModalEventLoopPD(void) { return; }
/*---------------------------------------------------------------------------*/

2223
toonz/sources/common/twain/twain.h
View file

File diff suppressed because it is too large Load diff

8
toonz/sources/include/toonz/sceneproperties.h
View file

@ -26,7 +26,6 @@ class TPropertyGroup;
class TPalette;
class TSceneProperties;
class CleanupParameters;
class TScannerParameters;
class TCamera;
class TOutputProperties;
class TStageObjectTree;
@ -60,7 +59,6 @@ private:
TOutputProperties *m_outputProp, *m_previewProp;
CleanupParameters *m_cleanupParameters;
TScannerParameters *m_scanParameters;
VectorizerParameters *m_vectorizerParameters;
CaptureParameters *m_captureParameters;
@ -85,7 +83,6 @@ public:
\li a new CleanupParameters object that sets to default some basic
attributes
as basic transformation, rotation angle, scale factor, x-y offsets etc...;
\li a new TScannerParameters object (parameters to manage the scanner);
\li a new TOutputProperties object for the output and one for the preview ;
Sets internal attributes to default as background color, guides size and
@ -151,11 +148,6 @@ Returns cleanup parameters \b CleanupParameters, i.e. basic colors.
CleanupParameters *getCleanupParameters() const {
return m_cleanupParameters;
}
/*!
Return scanner parameters as Black and white scanner , graytones
scanner or a color scanner.
*/
TScannerParameters *getScanParameters() const { return m_scanParameters; }
/*!
Return vectorizer parameters.

20
toonz/sources/include/toonz/stage2.h
View file

@ -116,24 +116,4 @@ private:
CleanupPreviewCheck();
};
//=============================================================================
class DVAPI SetScanCropboxCheck {
bool m_enabled;
QAction *m_toggle;
public:
static SetScanCropboxCheck *instance();
void setToggle(QAction *toggle);
bool isEnabled() const { return m_enabled; }
void setIsEnabled(bool on);
void uncheck();
private:
SetScanCropboxCheck();
};
#endif

244
toonz/sources/include/tscanner.h
View file

@ -1,244 +0,0 @@
#pragma once
#ifndef TSCANNER_H
#define TSCANNER_H
#include "trasterimage.h"
#include <set>
#include <QString>
#undef DVAPI
#undef DVVAR
#ifdef TNZBASE_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif
// forward declaration
class TOStream;
class TIStream;
class TFilePath;
struct DVAPI TScanParam {
TScanParam()
: m_supported(false)
, m_min(0)
, m_max(0)
, m_def(0)
, m_step(0)
, m_value(0) {}
TScanParam(float _min, float _max, float _def, float _step)
: m_supported(true)
, m_min(_min)
, m_max(_max)
, m_def(_def)
, m_step(1)
, m_value(_def) {}
bool m_supported;
float m_min, m_max, m_def, m_step,
m_value; // questi sono float per seguire lo standard TWAIN !
void update(const TScanParam &model);
// assegna min,max,def,step e supported da model a this
// mantiene value a patto che sia contenuto nel nuovo range, diversamente ne
// fa il crop
};
class DVAPI TScannerParameters {
public:
enum ScanType { None, BW, GR8, RGB24 };
private:
// Supported scan types: Black and white, graytones, color
bool m_bw, m_gray, m_rgb;
// Current scan type
ScanType m_scanType;
std::string m_paperFormat; // e.g. "A4 paper"
TRectD m_scanArea; // in mm /* TWAIN preferirebbe gli inch, ma uso i mm per
// seguire tnz4.x*/
TRectD m_cropBox; // in mm /* TWAIN preferirebbe gli inch, ma uso i mm per
// seguire tnz4.x*/
bool m_isPreview;
TDimensionD m_maxPaperSize; // in mm /* TWAIN preferirebbe gli inch, ma uso i
// mm per seguire tnz4.x*/
bool m_paperOverflow; // vale true se la scanArea e' stata tagliata rispetto
// alle dimensioni della carta
// per rispettare la maxPaperSize
bool m_validatedByCurrentScanner;
// vale false se bisogna ancora chiamare adaptToCurrentScanner()
// l'idea e' di chiamare questo metodo il meno possibile
public:
TScanParam m_brightness;
TScanParam m_contrast;
TScanParam m_threshold;
TScanParam m_dpi;
TScanParam m_paperFeeder; // value==1.0 => use paper feeder
private:
// other useful info ?!
std::string m_twainVersion;
std::string m_manufacturer;
std::string m_prodFamily;
std::string m_productName;
std::string m_version;
bool m_reverseOrder; // if true then scan levels starting from last frame
void cropScanArea(); // assicura che scanArea sia dentro maxPaperSize
public:
TScannerParameters();
~TScannerParameters();
void setSupportedTypes(bool bw, bool gray, bool rgb);
bool isSupported(ScanType) const;
void setMaxPaperSize(double maxWidth,
double maxHeight); // note: possibly update m_scanArea
std::string getPaperFormat() const { return m_paperFormat; }
void setPaperFormat(std::string paperFormat);
// assert(TPaperFormatManager::instance()->isValidFormat(paperFormat));
// updates scanArea (cropping with maxPaperSize)
void updatePaperFormat();
// if paperFormat=="" set default paper format; recompute (to be sure!)
// scanArea
bool getPaperOverflow() const {
return m_paperOverflow;
} // true iff paperSize > maxPaperSize
TRectD getScanArea() const { return m_scanArea; }
void setCropBox(const TRectD &cropBox) { m_cropBox = cropBox * m_scanArea; }
TRectD getCropBox() const { return m_cropBox; }
void setIsPreview(bool isPreview) { m_isPreview = isPreview; };
bool isPreview() const { return m_isPreview; }
bool isReverseOrder() const { return m_reverseOrder; }
void setReverseOrder(bool reverseOrder) { m_reverseOrder = reverseOrder; }
bool isPaperFeederEnabled() const { return m_paperFeeder.m_value == 1.0; }
void enablePaperFeeder(bool on) { m_paperFeeder.m_value = on ? 1.0f : 0.0f; }
void setScanType(ScanType scanType);
ScanType getScanType() const { return m_scanType; }
// se e' stato definito uno scanner aggiorna lo stato (enabled/disabled,
// range, etc.)
// dei parametri rispetto a quest'ultimo
void adaptToCurrentScanner();
void adaptToCurrentScannerIfNeeded() {
if (!m_validatedByCurrentScanner) adaptToCurrentScanner();
}
void assign(const TScannerParameters *params);
void saveData(TOStream &os) const;
void loadData(TIStream &is);
};
//----------------------------------------
class TScannerListener {
public:
virtual void onImage(const TRasterImageP &) = 0;
virtual void onError() = 0;
virtual void onNextPaper() = 0;
virtual void onAutomaticallyNextPaper() = 0;
virtual bool isCanceled() = 0;
virtual ~TScannerListener() {}
};
//----------------------------------------
class DVAPI TScanner {
std::set<TScannerListener *> m_listeners;
protected:
TScanParam m_brightness, m_contrast, m_threshold, m_dpi;
int m_paperLeft;
QString m_scannerName;
public:
TScanner();
virtual ~TScanner();
static bool m_isTwain; // brutto, brutto :(
static TScanner *instance();
virtual void selectDevice() = 0;
virtual bool isDeviceAvailable() = 0;
virtual bool isDeviceSelected() { return false; }
virtual void updateParameters(TScannerParameters &parameters) = 0;
// aggiorna i parametri 'parameters' in funzione del tipo di scanner
// selezionato
// se possibile non modifica i valori correnti, ma cambia solo quello che non
// e' piu' adatto
// abilita/disabilita i parametri "opzionali".
// n.b. i parametri opzionali che vengono disabilitati mantengono il loro
// valore
// (cosi' se fai save default settings dopo aver cambiato scanner non ti perdi
// i vecchi settaggi)
virtual void acquire(const TScannerParameters &param, int paperCount) = 0;
void addListener(TScannerListener *);
void removeListener(TScannerListener *);
void notifyImageDone(const TRasterImageP &image);
void notifyNextPaper();
void notifyAutomaticallyNextPaper();
void notifyError();
bool isScanningCanceled();
int getPaperLeftCount() const { return m_paperLeft; }
void setPaperLeftCount(int count) { m_paperLeft = count; }
void decrementPaperLeftCount() { --m_paperLeft; }
QString getName() const { return m_scannerName; }
void setName(const QString &name) { m_scannerName = name; }
};
//---------------------------------------------------------
class DVAPI TPaperFormatManager { // singleton
public:
class Format {
public:
TDimensionD m_size;
Format() : m_size(0, 0) {}
Format(const TDimensionD &size) : m_size(size) {}
};
private:
typedef std::map<std::string, Format> FormatTable;
FormatTable m_formats;
TPaperFormatManager();
void readPaperFormat(const TFilePath &fp);
void readPaperFormats();
public:
static TPaperFormatManager *instance();
// resitutisce la lista dei formati
void getFormats(std::vector<std::string> &names) const;
bool isValidFormat(std::string name) const;
std::string getDefaultFormat() const;
// nome formato --> dimensione
TDimensionD getSize(std::string name) const;
};
#endif

65
toonz/sources/tnzbase/CMakeLists.txt
View file

@ -4,27 +4,7 @@ set(MOC_HEADERS
)
set(HEADERS ${MOC_HEADERS}
../common/twain/ttwain.h
../common/twain/ttwain_capability.h
../common/twain/ttwain_conversion.h
../common/twain/ttwain_error.h
../common/twain/ttwain_global_def.h
../common/twain/ttwain_state.h
../common/twain/ttwain_statePD.h
../common/twain/ttwain_util.h
../common/twain/ttwain_utilP.h
../common/twain/ttwain_utilPD.h
../common/twain/ttwain_win.h
../common/twain/ttwain_winPD.h
../common/twain/ttwainP.h
../common/twain/twain.h
../include/permissionsmanager.h
../include/tscanner.h
tscanner/tscannerutil.h
tscanner/tscannerepson.h
tscanner/tscannertwain.h
tscanner/TScannerIO/TScannerIO.h
tscanner/TScannerIO/TUSBScannerIO.h
../include/tcubicbezier.h
../include/tdoublekeyframe.h
../include/tdoubleparam.h
@ -108,51 +88,8 @@ set(SOURCES
../common/expressions/tparser.cpp
../common/expressions/ttokenizer.cpp
../common/tunit/tunit.cpp
tscanner/tscannerutil.cpp
tscanner/tscannerepson.cpp
)
if(BUILD_TARGET_WIN)
set(SOURCES ${SOURCES}
tscanner/TScannerIO/TUSBScannerIO_W.cpp
)
else()
set(SOURCES ${SOURCES}
tscanner/TScannerIO/TUSBScannerIO_M.cpp
)
endif()
set(OBJCSOURCES
../common/twain/ttwain_capability.c
../common/twain/ttwain_conversion.c
../common/twain/ttwain_error.c
../common/twain/ttwain_state.c
../common/twain/ttwain_util.c
../common/twain/ttwain_win.c
tscanner/tscanner.cpp
tscanner/tscannertwain.cpp
)
if(BUILD_TARGET_WIN)
set(OBJCSOURCES ${OBJCSOURCES}
../common/twain/ttwain_stateW.c
../common/twain/ttwain_utilW.c
../common/twain/ttwain_winW.c
)
elseif(BUILD_TARGET_APPLE)
set(OBJCSOURCES ${OBJCSOURCES}
../common/twain/ttwain_stateM.c
../common/twain/ttwain_utilM.c
../common/twain/ttwain_winM.c
)
elseif(BUILD_TARGET_UNIX)
set(OBJCSOURCES ${OBJCSOURCES}
../common/twain/ttwain_stateX.c
../common/twain/ttwain_utilX.c
../common/twain/ttwain_winX.c
)
endif()
if(BUILD_ENV_APPLE)
#set_source_files_properties(${OBJCSOURCES} PROPERTIES LANGUAGE OBJCXX)
set_source_files_properties(${OBJCSOURCES} PROPERTIES COMPILE_FLAGS "-x objective-c++")
@ -193,14 +130,12 @@ if(BUILD_ENV_MSVC)
tnzcore
)
elseif(BUILD_ENV_APPLE)
find_library(TWAIN_LIB TWAIN)
find_library(IOKIT_LIB IOKit)
find_library(COCOA_LIB Cocoa)
set(EXTRA_LIBS
"$<TARGET_FILE:tnzcore>"
${USB_LIB}
${TWAIN_LIB}
${IOKIT_LIB}
${COCOA_LIB}
)

16
toonz/sources/tnzbase/tscanner/TScannerIO/TScannerIO.h
View file

@ -1,16 +0,0 @@
#pragma once
#ifndef TSCANNER_IO_H
#define TSCANNER_IO_H
class TScannerIO {
public:
TScannerIO() {}
virtual bool open() = 0;
virtual void close() = 0;
virtual int receive(unsigned char *buffer, int size) = 0;
virtual int send(unsigned char *buffer, int size) = 0;
virtual void trace(bool on) = 0;
virtual ~TScannerIO() {}
};
#endif

23
toonz/sources/tnzbase/tscanner/TScannerIO/TUSBScannerIO.h
View file

@ -1,23 +0,0 @@
#pragma once
#ifndef TUSBSCANNER_IO_H
#define TUSBSCANNER_IO_H
#include "TScannerIO.h"
class TUSBScannerIOPD;
class TUSBScannerIO final : public TScannerIO {
TUSBScannerIOPD *m_data;
public:
TUSBScannerIO();
bool open() override;
void close() override;
int receive(unsigned char *buffer, int size) override;
int send(unsigned char *buffer, int size) override;
void trace(bool on) override;
~TUSBScannerIO();
};
#endif

207
toonz/sources/tnzbase/tscanner/TScannerIO/TUSBScannerIO_M.cpp
View file

@ -1,207 +0,0 @@
#include "TUSBScannerIO.h"
#include "tsystem.h"
#include <iostream>
#include <sstream>
//#define HAS_LIBUSB
#if defined(HAS_LIBUSB)
#include <USB.h>
#endif
#include <errno.h>
using namespace std;
class TUSBScannerIOPD {
public:
TUSBScannerIOPD();
struct usb_device *m_epson;
struct usb_dev_handle *m_handle;
int m_epR;
int m_epW;
bool m_trace;
};
static pthread_t T = 0;
//#define TRACE cout << __PRETTY_FUNCTION__ << endl;
#define TRACE
TUSBScannerIOPD::TUSBScannerIOPD()
: m_epson(0), m_handle(0), m_epR(0), m_epW(0), m_trace(false) {
/*initialize libusb*/
TRACE
if (T == 0) T = pthread_self();
#if defined(HAS_LIBUSB)
usb_set_debug(9);
usb_init();
usb_find_busses();
usb_find_devices();
#endif
}
namespace {
void buf2printable(const unsigned char *buffer, const int size,
stringstream &os) {
int i = 0;
if ((size == 2) && (buffer[0] == 0x1b)) {
os << "ESC ";
char c = buffer[1];
if (isprint(c)) os << c << " ";
return;
}
os << std::hex;
for (; i < std::min(size, 0x40); ++i) {
char c = buffer[i];
os << "0x" << (unsigned int)c << " ";
}
if (i < size) os << "...";
}
}
//-----------------------------------------------------------------------------
TUSBScannerIO::TUSBScannerIO() : m_data(new TUSBScannerIOPD()) { TRACE }
//-----------------------------------------------------------------------------
namespace {
#if defined(HAS_LIBUSB)
// looking for an Epson device
struct usb_device *doCheck(struct usb_device *dev, int level) {
if (!dev) return 0;
cout << "checking idVendor = " << std::hex << dev->descriptor.idVendor
<< endl;
if (dev->descriptor.idVendor == 0x04b8) return dev;
for (int i = 0; i < dev->num_children; i++)
if (doCheck(dev->children[i], level + 1)) return dev->children[i];
return 0;
}
#endif
};
bool TUSBScannerIO::open() {
#if defined(HAS_LIBUSB)
for (struct usb_bus *bus = usb_busses; bus; bus = bus->next) {
if (bus->root_dev) {
m_data->m_epson = doCheck(bus->root_dev, 0);
if (m_data->m_epson) break;
} else {
struct usb_device *dev;
for (dev = bus->devices; dev; dev = dev->next)
m_data->m_epson = doCheck(dev, 0);
if (m_data->m_epson) break;
}
}
if (!m_data->m_epson) return false;
cout << "found" << endl;
m_data->m_handle = usb_open(m_data->m_epson);
if (!m_data->m_handle) return false;
cout << "opened" << endl;
m_data->m_epR = m_data->m_epson->config[0]
.interface[0]
.altsetting[0]
.endpoint[0]
.bEndpointAddress;
m_data->m_epW = m_data->m_epson->config[0]
.interface[0]
.altsetting[0]
.endpoint[1]
.bEndpointAddress;
int rc;
rc = usb_set_configuration(m_data->m_handle,
m_data->m_epson->config[0].bConfigurationValue);
cout << "rc (config) = " << rc << endl;
int ifc = 0;
rc = usb_claim_interface(m_data->m_handle, ifc);
if ((rc == -EBUSY) || (rc == -ENOMEM)) return false;
cout << "rc (claim) = " << rc << endl;
cout << "gotit!" << endl;
return true;
#else
return false;
#endif
}
//-----------------------------------------------------------------------------
void TUSBScannerIO::close() {
TRACE
#if defined(HAS_LIBUSB)
if (m_data->m_handle) {
usb_release_interface(m_data->m_handle, 0);
usb_close(m_data->m_handle);
}
m_data->m_handle = 0;
m_data->m_epson = 0;
#endif
}
//-----------------------------------------------------------------------------
int TUSBScannerIO::receive(unsigned char *buffer, int size) {
TRACE
#if defined(HAS_LIBUSB)
int count;
count = usb_bulk_read(m_data->m_handle, m_data->m_epR, (char *)buffer, size,
30 * 1000);
if (m_data->m_trace) {
stringstream os;
os << "receive: size=" << size << " got = " << count << " buf=";
buf2printable(buffer, count, os);
os << '\n' << '\0';
TSystem::outputDebug(os.str());
}
return count;
#else
return 0;
#endif
}
//-----------------------------------------------------------------------------
int TUSBScannerIO::send(unsigned char *buffer, int size) {
TRACE
#if defined(HAS_LIBUSB)
int count;
if (T != pthread_self()) {
cout << "called from another thead" << endl;
return 0;
}
count = usb_bulk_write(m_data->m_handle, m_data->m_epW, (char *)buffer, size,
30 * 1000);
if (m_data->m_trace) {
stringstream os;
os << "send: size=" << size << " wrote = " << count << " buf=";
buf2printable(buffer, size, os);
os << '\n' << '\0';
TSystem::outputDebug(os.str());
}
return count;
#else
return 0;
#endif
}
//-----------------------------------------------------------------------------
void TUSBScannerIO::trace(bool on) {
TRACE
m_data->m_trace = on;
}
//-----------------------------------------------------------------------------
TUSBScannerIO::~TUSBScannerIO() { TRACE }

133
toonz/sources/tnzbase/tscanner/TScannerIO/TUSBScannerIO_W.cpp
View file

@ -1,133 +0,0 @@
#include "TUSBScannerIO.h"
#include "tsystem.h"
#include <windows.h>
#include <sstream>
class TUSBScannerIOPD {
public:
TUSBScannerIOPD() : m_handle(INVALID_HANDLE_VALUE), m_trace(false) {}
HANDLE m_handle;
bool m_trace;
};
//-----------------------------------------------------------------------------
namespace {
void buf2printable(const unsigned char *buffer, const int size,
std::stringstream &os) {
int i = 0;
if ((size == 2) && (buffer[0] == 0x1b)) {
os << "ESC ";
char c = buffer[1];
if (isprint(c)) os << c << " ";
return;
}
os << std::hex;
for (; i < std::min(size, 0x40); ++i) {
char c = buffer[i];
os << "0x" << (unsigned int)c << " ";
}
if (i < size) os << "...";
}
}
//-----------------------------------------------------------------------------
TUSBScannerIO::TUSBScannerIO() : m_data(new TUSBScannerIOPD()) {}
//-----------------------------------------------------------------------------
bool TUSBScannerIO::open() {
m_data->m_handle = CreateFile("\\\\.\\usbscan0", GENERIC_WRITE | GENERIC_READ,
FILE_SHARE_WRITE | FILE_SHARE_READ, NULL,
OPEN_EXISTING, 0, NULL);
if (m_data->m_handle == INVALID_HANDLE_VALUE) return false;
return true;
}
//-----------------------------------------------------------------------------
void TUSBScannerIO::close() {
if (m_data->m_handle && (m_data->m_handle != INVALID_HANDLE_VALUE))
CloseHandle(m_data->m_handle);
}
//-----------------------------------------------------------------------------
int TUSBScannerIO::receive(unsigned char *buffer, int size) {
int bytesLeft = size;
unsigned char *ptr = buffer;
DWORD count;
static int m_maxReadSize = 0x10000;
do {
int bytesToRead = bytesLeft;
notMoreThan<int>(m_maxReadSize, bytesToRead);
OVERLAPPED overlapped;
memset(&overlapped, 0, sizeof(OVERLAPPED));
overlapped.hEvent = CreateEvent(NULL, // pointertosecurityattributes,
// WIN95ignoresthisparameter
FALSE, // automaticreset
FALSE, // initializetonotsignaled
NULL); // pointertotheevent-objectname
ReadFile(m_data->m_handle, ptr, bytesToRead, &count, &overlapped);
DWORD waitRC = WaitForSingleObject(overlapped.hEvent, INFINITE);
if (m_data->m_trace) {
std::stringstream os;
os << "receive: size=" << size << " got = " << count << " buf=";
buf2printable(ptr, count, os);
os << '\n' << '\0';
TSystem::outputDebug(os.str());
}
if (count != bytesToRead) return 0;
ptr += count;
bytesLeft = bytesLeft - count;
} while (bytesLeft);
return size;
}
//-----------------------------------------------------------------------------
int TUSBScannerIO::send(unsigned char *buffer, int size) {
int bytesLeft = size;
DWORD count;
static int m_maxWriteSize = 64;
// bytesLeft = 64;
do {
int bytesToWrite = bytesLeft;
notMoreThan<int>(m_maxWriteSize, bytesToWrite);
WriteFile(m_data->m_handle, buffer, bytesToWrite, &count, 0);
if (m_data->m_trace) {
std::stringstream os;
os << "send: size=" << size << " wrote = " << count << " buf=";
buf2printable(buffer, size, os);
os << '\n' << '\0';
TSystem::outputDebug(os.str());
}
if (count != bytesToWrite) return 0;
// ptr += count;
bytesLeft = bytesLeft - count;
} while (bytesLeft);
return size;
}
//-----------------------------------------------------------------------------
void TUSBScannerIO::trace(bool on) { m_data->m_trace = on; }
//-----------------------------------------------------------------------------
TUSBScannerIO::~TUSBScannerIO() {}

574
toonz/sources/tnzbase/tscanner/tscanner.cpp
View file

@ -1,574 +0,0 @@
#include "tscanner.h"
#include "tscannertwain.h"
#include "texception.h"
#include "tscannerepson.h"
#include "tstream.h"
#include "tconvert.h"
#include "tfilepath.h"
#include "tfilepath_io.h"
#include "tenv.h"
#include "tsystem.h"
extern "C" {
#include "../common/twain/ttwain_util.h"
}
//===================================================================
//
// TScanParam
//
//-------------------------------------------------------------------
void TScanParam::update(const TScanParam &model) {
m_supported = model.m_supported;
m_min = model.m_min;
m_max = model.m_max;
m_def = model.m_def;
m_step = model.m_step;
m_value = tcrop(m_value, m_min, m_max);
}
//===================================================================
//
// TScannerParameters
//
//-------------------------------------------------------------------
const std::string BlackAndWhite = "Black & White";
const std::string Graytones = "Graytones";
const std::string Rgbcolors = "RGB Color";
//-------------------------------------------------------------------
TScannerParameters::TScannerParameters()
: m_bw(false)
, m_gray(false)
, m_rgb(false)
, m_scanType(None)
, m_scanArea(TRectD())
, m_cropBox(TRectD())
, m_isPreview(false)
, m_maxPaperSize(TDimensionD(0, 0))
, m_paperOverflow(false)
, m_brightness()
, m_contrast()
, m_threshold()
, m_dpi()
, m_paperFeeder()
, m_twainVersion()
, m_manufacturer()
, m_prodFamily()
, m_productName()
, m_version()
, m_reverseOrder(false)
, m_validatedByCurrentScanner(false) {
m_threshold.m_value = 127;
m_brightness.m_value = 127;
}
//-------------------------------------------------------------------------------------------------
TScannerParameters::~TScannerParameters() {}
//-------------------------------------------------------------------------------------------------
void TScannerParameters::assign(const TScannerParameters *src) { *this = *src; }
//-------------------------------------------------------------------------------------------------
void TScannerParameters::setSupportedTypes(bool bw, bool gray, bool rgb) {
m_bw = bw;
m_gray = gray;
m_rgb = rgb;
if (!m_bw && !m_gray && !m_rgb) {
m_scanType = None;
} else {
switch (m_scanType) {
case BW:
if (!m_bw) m_scanType = m_gray ? GR8 : RGB24;
break;
case GR8:
if (!m_gray) m_scanType = m_rgb ? RGB24 : BW;
break;
case RGB24:
if (!m_rgb) m_scanType = m_gray ? GR8 : BW;
break;
case None:
if (gray)
m_scanType = GR8;
else {
if (rgb)
m_scanType = RGB24;
else if (bw)
m_scanType = BW;
}
break;
}
}
}
//-------------------------------------------------------------------------------------------------
bool TScannerParameters::isSupported(ScanType scanType) const {
switch (scanType) {
case BW:
return m_bw;
case GR8:
return m_gray;
case RGB24:
return m_rgb;
default:
assert(0);
return false;
}
}
//-------------------------------------------------------------------------------------------------
void TScannerParameters::cropScanArea() {
m_paperOverflow = false;
if (m_maxPaperSize.lx == 0 || m_maxPaperSize.ly == 0) {
// probabilmente non e' ancora stato selezionato uno scanner e quindi non e'
// definita una maxPaperSize
return;
}
assert(m_maxPaperSize.lx > 0 && m_maxPaperSize.ly > 0);
if (m_scanArea.x1 > m_maxPaperSize.lx) {
m_paperOverflow = true;
m_scanArea.x1 = m_maxPaperSize.lx;
}
if (m_scanArea.y1 > m_maxPaperSize.ly) {
m_paperOverflow = true;
m_scanArea.y1 = m_maxPaperSize.ly;
}
}
//-------------------------------------------------------------------------------------------------
void TScannerParameters::setMaxPaperSize(double maxWidth, double maxHeight) {
// assert(maxWidth>0 && maxHeight>0);
m_maxPaperSize = TDimensionD(maxWidth, maxHeight);
cropScanArea();
}
//-----------------------------------------------------------------------------
void TScannerParameters::setPaperFormat(std::string paperFormat) {
TPaperFormatManager *formatManager = TPaperFormatManager::instance();
assert(formatManager->isValidFormat(paperFormat));
if (!formatManager->isValidFormat(paperFormat))
paperFormat = formatManager->getDefaultFormat();
m_paperFormat = paperFormat;
TDimensionD d = TPaperFormatManager::instance()->getSize(paperFormat);
m_scanArea = TRectD(TPointD(0, 0), d);
cropScanArea();
if (m_cropBox == TRectD()) m_cropBox = m_scanArea;
}
//-----------------------------------------------------------------------------
void TScannerParameters::updatePaperFormat() {
if (m_paperFormat == "")
m_paperFormat = TPaperFormatManager::instance()->getDefaultFormat();
setPaperFormat(m_paperFormat);
}
//-----------------------------------------------------------------------------
void TScannerParameters::setScanType(ScanType scanType) {
assert(scanType == None || scanType == BW || scanType == GR8 ||
scanType == RGB24);
m_scanType = scanType;
}
//-----------------------------------------------------------------------------
void TScannerParameters::adaptToCurrentScanner() {
try {
if (TScanner::instance()->isDeviceSelected()) {
TScanner::instance()->updateParameters(*this);
m_validatedByCurrentScanner = true;
}
} catch (TException &) {
// TMessage::error("%1", e.getMessage());
}
}
//-------------------------------------------------------------------------------------------------
void TScannerParameters::saveData(TOStream &os) const {
std::map<std::string, std::string> attr;
attr["fmt"] = m_paperFormat;
os.openCloseChild("paper", attr);
if (m_paperFeeder.m_value == 1.0) {
attr.clear();
os.openCloseChild("autoFeeder", attr);
}
if (m_reverseOrder) {
attr.clear();
os.openCloseChild("reverseOrder", attr);
}
if (m_scanType != None) {
std::string scanTypeString = Rgbcolors;
switch (m_scanType) {
case BW:
scanTypeString = BlackAndWhite;
break;
case GR8:
scanTypeString = Graytones;
break;
case RGB24:
scanTypeString = Rgbcolors;
break;
default:
break;
}
attr.clear();
attr["value"] = scanTypeString;
os.openCloseChild("mode", attr);
}
if (m_dpi.m_supported) {
attr.clear();
attr["value"] = std::to_string(m_dpi.m_value);
os.openCloseChild("dpi", attr);
}
if (m_brightness.m_supported) {
attr.clear();
attr["value"] = std::to_string(m_brightness.m_value);
os.openCloseChild("brightness", attr);
}
if (m_contrast.m_supported) {
attr.clear();
attr["value"] = std::to_string(m_contrast.m_value);
os.openCloseChild("contrast", attr);
}
if (m_threshold.m_supported) {
attr.clear();
attr["value"] = std::to_string(m_threshold.m_value);
os.openCloseChild("threshold", attr);
}
}
//-------------------------------------------------------------------------------------------------
void TScannerParameters::loadData(TIStream &is) {
std::string tagName;
while (is.matchTag(tagName)) {
if (tagName == "dpi") {
std::string s = is.getTagAttribute("value");
if (isDouble(s)) m_dpi.m_value = std::stof(s);
} else if (tagName == "brightness") {
std::string s = is.getTagAttribute("value");
if (isDouble(s)) m_brightness.m_value = std::stof(s);
} else if (tagName == "threshold") {
std::string s = is.getTagAttribute("value");
if (isDouble(s)) m_threshold.m_value = std::stof(s);
} else if (tagName == "contrast") {
std::string s = is.getTagAttribute("value");
if (isDouble(s)) m_contrast.m_value = std::stof(s);
} else if (tagName == "autoFeeder") {
m_paperFeeder.m_value = 1.0;
} else if (tagName == "reverseOrder") {
m_reverseOrder = true;
} else if (tagName == "mode") {
std::string scanTypeString = is.getTagAttribute("value");
m_scanType = None;
if (scanTypeString == BlackAndWhite)
m_scanType = BW;
else if (scanTypeString == Graytones)
m_scanType = GR8;
else if (scanTypeString == Rgbcolors)
m_scanType = RGB24;
} else if (tagName == "paper") {
std::string paperFormat = is.getTagAttribute("fmt");
if (paperFormat != "") setPaperFormat(paperFormat);
}
}
m_validatedByCurrentScanner = false;
}
//===================================================================
//
// TScanner
//
//-------------------------------------------------------------------
namespace {
TScanner *instanceTwain = 0;
TScanner *instanceEpson = 0;
}
//-------------------------------------------------------------------
bool TScanner::m_isTwain = true;
//-------------------------------------------------------------------
namespace {
class Cleaner {
public:
bool m_activated;
Cleaner() : m_activated(false) {}
~Cleaner() {
TScanner *scannerToDestroy = 0;
if (m_activated) scannerToDestroy = TScanner::instance();
delete scannerToDestroy;
}
};
Cleaner MyCleaner;
};
//-------------------------------------------------------------------
// #define DUMMYSCAN
#ifdef DUMMYSCAN
class TScannerDummy final : public TScanner {
public:
TScannerDummy() {}
~TScannerDummy() {}
void selectDevice() {}
bool isDeviceAvailable() { return true; }
void updateParameters(TScannerParameters &parameters) {
parameters.setSupportedTypes(false, true, true);
parameters.setMaxPaperSize(1000., 1000.);
parameters.enablePaperFeeder(true);
parameters.m_brightness.update(TScanParam(0, 255, 128, 1));
parameters.m_contrast.update(TScanParam(0, 255, 128, 1));
parameters.m_threshold.update(TScanParam(0, 255, 128, 1));
parameters.m_dpi.update(TScanParam(60, 1200, 100, 1));
setName("DummyScanner");
}
bool isTwain() const { return true; }
void acquire(const TScannerParameters &param, int paperCount) { return; }
bool isAreaSupported() { return true; }
};
#endif
//-----------------------------------------------------------------------------
TScanner *TScanner::instance() {
MyCleaner.m_activated = true;
#ifdef DUMMYSCAN
static TScannerDummy dummy = TScannerDummy();
return &dummy;
#else
if (m_isTwain) {
if (instanceEpson) {
TScannerEpson *se = (TScannerEpson *)instanceEpson;
se->closeIO();
// delete m_instanceEpson; //e' singletone, perche' buttarlo? (vinz)
// m_instanceEpson=0;
}
if (!instanceTwain) instanceTwain = new TScannerTwain();
} else if (!m_isTwain) {
if (instanceTwain) {
// delete m_instanceTwain; //e' singletone, perche' buttarlo? (vinz)
// m_instanceTwain=0;
TTWAIN_CloseAll(0);
}
if (!instanceEpson) instanceEpson = new TScannerEpson();
}
return (m_isTwain ? instanceTwain : instanceEpson);
#endif
}
//-----------------------------------------------------------------------------
TScanner::TScanner() : m_paperLeft(0) {}
//-----------------------------------------------------------------------------
TScanner::~TScanner() {
if (instanceEpson) {
TScannerEpson *se = (TScannerEpson *)instanceEpson;
se->closeIO();
}
}
//-----------------------------------------------------------------------------
void TScanner::addListener(TScannerListener *lst) { m_listeners.insert(lst); }
//-----------------------------------------------------------------------------
void TScanner::removeListener(TScannerListener *lst) { m_listeners.erase(lst); }
//-----------------------------------------------------------------------------
void TScanner::notifyImageDone(const TRasterImageP &img) {
std::set<TScannerListener *>::iterator it = m_listeners.begin();
for (; it != m_listeners.end(); ++it) {
(*it)->onImage(img);
}
}
//-----------------------------------------------------------------------------
void TScanner::notifyNextPaper() {
std::set<TScannerListener *>::iterator it = m_listeners.begin();
for (; it != m_listeners.end(); ++it) {
(*it)->onNextPaper();
}
}
//-----------------------------------------------------------------------------
void TScanner::notifyAutomaticallyNextPaper() {
std::set<TScannerListener *>::iterator it = m_listeners.begin();
for (; it != m_listeners.end(); ++it) {
(*it)->onAutomaticallyNextPaper();
}
}
//-----------------------------------------------------------------------------
void TScanner::notifyError() {
std::set<TScannerListener *>::iterator it = m_listeners.begin();
for (; it != m_listeners.end(); ++it) {
(*it)->onError();
}
}
//-----------------------------------------------------------------------------
/*! If one listener is set to cancel return true. */
bool TScanner::isScanningCanceled() {
std::set<TScannerListener *>::iterator it = m_listeners.begin();
for (; it != m_listeners.end(); ++it) {
if ((*it)->isCanceled()) return true;
}
return false;
}
//===================================================================
//
// TPaperFormatManager
//
//-------------------------------------------------------------------
namespace {
const std::pair<std::string, TDimensionD> defaultPaperFormat(
"A4 paper", TDimensionD(210.00, 297.00));
}
//-----------------------------------------------------------------------------
TPaperFormatManager::TPaperFormatManager() {
readPaperFormats();
// se non c'e' aggiungo il formato di default. In questo modo e' sempre
// definito
if (!isValidFormat(defaultPaperFormat.first))
m_formats[defaultPaperFormat.first] = Format(defaultPaperFormat.second);
}
//-----------------------------------------------------------------------------
TPaperFormatManager *TPaperFormatManager::instance() {
static TPaperFormatManager _instance;
return &_instance;
}
//-----------------------------------------------------------------------------
void TPaperFormatManager::getFormats(std::vector<std::string> &names) const {
for (FormatTable::const_iterator it = m_formats.begin();
it != m_formats.end(); ++it)
names.push_back(it->first);
}
//-----------------------------------------------------------------------------
TDimensionD TPaperFormatManager::getSize(std::string name) const {
FormatTable::const_iterator it = m_formats.find(name);
if (it == m_formats.end())
return TDimensionD(0., 0.);
else
return it->second.m_size;
}
//-----------------------------------------------------------------------------
bool TPaperFormatManager::isValidFormat(std::string name) const {
FormatTable::const_iterator it = m_formats.find(name);
return it != m_formats.end();
}
//-----------------------------------------------------------------------------
std::string TPaperFormatManager::getDefaultFormat() const {
return defaultPaperFormat.first;
}
//-----------------------------------------------------------------------------
void TPaperFormatManager::readPaperFormat(const TFilePath &path) {
if (path.getType() != "pap") return;
Tifstream is(path);
std::string name;
TDimensionD size(0, 0);
while (is) {
char buffer[1024];
is.getline(buffer, sizeof buffer);
// i e' il carattere successivo alla fine della linea
unsigned int i = 0;
for (i = 0; i < sizeof buffer && buffer[i]; i++) {
}
if (i > 0 && buffer[i - 1] == '\n') i--;
while (i > 0 && buffer[i - 1] == ' ') i--;
unsigned int j = 0;
unsigned int k = 0;
// j e' il carattere successivo alla fine del primo token
for (j = 0; j < i && buffer[j] != ' '; j++) {
}
// k e' l'inizio del secondo token (se c'e', altrimenti == i)
for (k = j; k < i && buffer[k] == ' '; k++) {
}
std::string value;
if (k < i) value = std::string(buffer + k, i - k);
if (buffer[0] == '#') {
if (k < i && name == "") name = value;
} else if (std::string(buffer).find("WIDTH") == 0) {
if (isDouble(value)) size.lx = std::stod(value);
} else if (std::string(buffer).find("LENGTH") == 0) {
if (isDouble(value)) size.ly = std::stod(value);
}
}
if (name == "" || size.lx == 0 || size.ly == 0) {
// TMessage::error("Error reading paper format file : %1",path);
} else
m_formats[name] = Format(size);
}
//-----------------------------------------------------------------------------
void TPaperFormatManager::readPaperFormats() {
TFilePathSet fps;
TFilePath papDir = TEnv::getConfigDir() + "pap";
if (!TFileStatus(papDir).isDirectory()) {
// TMessage::error("E_CanNotReadDirectory_%1", papDir);
return;
}
try {
fps = TSystem::readDirectory(papDir);
} catch (TException &) {
// TMessage::error("E_CanNotReadDirectory_%1", papDir);
return;
}
TFilePathSet::const_iterator it = fps.begin();
for (; it != fps.end(); ++it) readPaperFormat(*it);
}

984
toonz/sources/tnzbase/tscanner/tscannerepson.cpp
View file

@ -1,984 +0,0 @@
#include <errno.h>
#include "texception.h"
#include "tscanner.h"
#include "tscannerepson.h"
#include "tscannerutil.h"
#include "tsystem.h"
#include "tconvert.h"
#include "trop.h"
#include "TScannerIO/TUSBScannerIO.h"
#include <cassert>
#include <memory>
#include <fstream>
#include <sstream>
using namespace TScannerUtil;
static void sense(bool) {}
static int scsi_maxlen() {
assert(0);
return 0;
}
#define BW_USES_GRAYTONES
#ifndef _WIN32
#define SWAPIT
#endif
#ifdef i386
#undef SWAPIT
#endif
/*
Commands used to drive the scanner:
cmd spec Level
@ Reset B2 B3 B4 B5 A5
Q Sharpness B4 B5 A5
B Halftoning B1 B2 B3 B4 B5 A5
Z Gamma B2 B3 B4 B5 A5
L Brightness B2 B3 B4 B5 A5
t Threshold
H Zoom B2 B3 B4 B5 A5
R Resolution B1 B2 B3 B4 B5 A5
A Set read Area B1 B2 B3 B4 B5 A5
C Linesequence Mode B1 B2 B3 B4 B5 A5
d Line count B4 B5 A5
D Dataformat B1 B2 B3 B4 B5 A5
g Scan speed B4 B5 A5
G Start Scan B1 B2 B3 B4 B5
e Activate ADF
0x19 Load from ADF
0x0C Unload from ADF
*/
/* NOTE: you can find these codes with "man ascii". */
static unsigned char STX = 0x02;
static unsigned char ACK = 0x06;
static unsigned char NAK = 0x15;
static unsigned char CAN = 0x18;
static unsigned char ESC = 0x1B;
static unsigned char PF = 0x19;
/* STATUS bit in readLineData */
static unsigned char FatalError = 1 << 7;
static unsigned char NotReady = 1 << 6;
//-----------------------------------------------------------------------------
#define log(_str)
class TScannerExpection final : public TException {
TString m_scannerMsg;
public:
TScannerExpection(const std::vector<std::string> &notFatal,
const std::string &fatal)
: TException("Scanner Expection") {
m_scannerMsg = ::to_wstring(fatal);
for (int i = notFatal.size(); i; i--)
m_scannerMsg += L"\n" + ::to_wstring(notFatal[i - 1]);
log("Exception created: " + ::to_string(m_scannerMsg));
}
TString getMessage() const override { return m_scannerMsg; }
};
//-----------------------------------------------------------------------------
namespace {
/*
void log(string s)
{
std::ofstream os("C:\\butta.txt", std::ios::app);
os << s << std::endl;
os.flush();
}
*/
}
//-----------------------------------------------------------------------------
TScannerEpson::TScannerEpson()
: m_scannerIO(new TUSBScannerIO()), m_hasADF(false), m_isOpened(false) {
log("Created");
}
//-----------------------------------------------------------------------------
void TScannerEpson::closeIO() {
log("CloseIO.");
if (m_scannerIO && m_isOpened) m_scannerIO->close();
m_isOpened = false;
}
//-----------------------------------------------------------------------------
TScannerEpson::~TScannerEpson() {
closeIO();
log("Destroyed");
}
//-----------------------------------------------------------------------------
void TScannerEpson::selectDevice() {
log(std::string("selectDevice; isOpened=") + (m_isOpened ? "true" : "false"));
if (!m_scannerIO->open()) {
log("open() failed");
throw TException("unable to get handle to scanner");
}
m_isOpened = true;
/*
char lev0, lev1;
unsigned short lowRes, hiRes, hMax,vMax;
collectInformation(&lev0, &lev1, &lowRes, &hiRes, &hMax, &vMax);
string version = toString(lev0) + "." + toString(lev1);
*/
setName("Scanner EPSON (Internal driver)");
}
//-----------------------------------------------------------------------------
bool TScannerEpson::isDeviceAvailable() { return true; }
//-----------------------------------------------------------------------------
bool TScannerEpson::isDeviceSelected() { return m_isOpened; }
//-----------------------------------------------------------------------------
void TScannerEpson::updateParameters(TScannerParameters &parameters) {
log("updateParameters()");
char lev0, lev1;
unsigned short lowRes, hiRes, hMax, vMax;
collectInformation(&lev0, &lev1, &lowRes, &hiRes, &hMax, &vMax);
log("collected info. res = " + std::to_string(lowRes) + "/" +
std::to_string(hiRes));
// non supportiamo black & white
parameters.setSupportedTypes(true, true, true);
// param.m_scanArea = TRectD(0, 0, 0, 0);
parameters.setMaxPaperSize((25.4 * hMax) / (float)hiRes,
(25.4 * vMax) / (float)hiRes);
parameters.updatePaperFormat();
// cambio range, default, step, e supported. aggiorno, se necessario, il value
// (n.b. non dovrebbe succedere
// mai, perche' i range sono sempre gli stessi su tutti gli scanner
TScanParam defaultEpsonParam(0., 255., 128., 1.);
parameters.m_brightness.update(defaultEpsonParam);
parameters.m_contrast.update(defaultEpsonParam);
parameters.m_threshold.update(defaultEpsonParam);
if (m_hasADF) {
TScanParam defaultPaperFeederParam(0., 1., 0., 1.);
parameters.m_paperFeeder.update(defaultPaperFeederParam);
} else
parameters.m_paperFeeder.m_supported = false;
// cerco un default per il dpi. il piu' piccolo possibile nella forma 100+k50
float defaultDpi = 100;
while (defaultDpi < lowRes) defaultDpi += 50;
TScanParam defaultDpiParam(lowRes, hiRes, defaultDpi,
hiRes > lowRes ? 1.F : 0.F);
parameters.m_dpi.update(defaultDpiParam);
// parameters.m_twainVersion = "NATIVE";
// parameters.m_manufacturer = "EPSON";
// parameters.m_version = toString(lev0) + "." + toString(lev1);
log("end updateParameters()");
}
//-----------------------------------------------------------------------------
void TScannerEpson::acquire(const TScannerParameters &params, int paperCount) {
log("acquire");
TRectD scanArea = params.getScanArea();
if (scanArea.isEmpty())
throw TException("Scan area is empty, select a paper size");
/*
if ((scanArea.getSize().lx > params.m_maxPaperSize.lx) ||
(scanArea.getSize().ly > params.m_maxPaperSize.ly))
throw TException("Scan area too large, select a correct paper size");
*/
for (int i = 0; i < paperCount; ++i) {
log("paper " + std::to_string(i));
#ifdef _DEBUG
m_scannerIO->trace(true);
#endif
doSettings(params, i == 0);
unsigned int nTimes = 0;
unsigned int bytes_to_read;
bool rc;
unsigned char stx;
#ifdef _DEBUG
m_scannerIO->trace(false);
#endif
TRasterP ras, rasBuffer;
unsigned char *buffer = 0;
log("Scan command");
rc = ESCI_command('G', false); /* 'SCAN' command */
if (!rc) throw TException("Start Scan failed");
log("Scan command OK");
unsigned short offsetx = 0, offsety = 0;
unsigned short dimlx = 0, dimly = 0;
TRectD scanArea =
params.isPreview() ? params.getScanArea() : params.getCropBox();
scanArea2pix(params, offsetx, offsety, dimlx, dimly, scanArea);
std::swap(dimlx, dimly);
unsigned int bytes;
switch (params.getScanType()) {
case TScannerParameters::BW:
#ifdef BW_USES_GRAYTONES
ras = TRasterGR8P(dimlx, dimly);
bytes = dimlx * dimly;
rasBuffer = TRasterGR8P(dimlx, dimly);
buffer = rasBuffer->getRawData();
break;
break;
#else
ras = TRasterGR8P(dimlx, dimly);
bytes = tceil(dimlx / 8) * dimly;
rasBuffer = TRasterGR8P(tceil(dimlx / 8), dimly);
// bytes = (dimlx + 7) % 8 * dimly;
// rasBuffer = TRasterGR8P((dimlx + 7) % 8,dimly);
buffer = rasBuffer->getRawData();
break;
#endif
case TScannerParameters::GR8:
#ifdef GRAYTONES_USES_RGB
ras = TRasterGR8P(dimlx, dimly);
bytes = dimlx * dimly * 3;
rasBuffer = TRasterGR8P(dimlx * 3, dimly);
buffer = rasBuffer->getRawData();
break;
#else
ras = TRasterGR8P(dimlx, dimly);
bytes = dimlx * dimly;
rasBuffer = TRasterGR8P(dimlx, dimly);
buffer = rasBuffer->getRawData();
break;
#endif
case TScannerParameters::RGB24:
ras = TRaster32P(dimlx, dimly);
bytes = dimlx * dimly * 3;
rasBuffer = TRasterGR8P(dimlx * 3, dimly);
buffer = rasBuffer->getRawData();
break;
default:
throw TException("Unknown scanner mode");
break;
}
log("sleep");
TSystem::sleep(2000);
log("reading data");
bool areaEnd = false;
unsigned int bytes_read = 0;
while (!areaEnd) {
unsigned short lines, counter;
unsigned char status = 0;
unsigned int retryCount = 0;
do {
ESCI_readLineData(stx, status, counter, lines, areaEnd);
if (status & FatalError) {
retryCount++;
if (retryCount == 1) throw TException("Error scanning");
}
} while (status & FatalError);
bytes_to_read = lines * counter;
if (stx != 0x02) {
std::stringstream os;
os << "header corrupted (" << std::hex << stx << ")" << '\0';
throw TException(os.str());
}
unsigned long reqBytes = bytes_to_read;
std::unique_ptr<unsigned char[]> readBuffer = ESCI_read_data2(reqBytes);
if (!readBuffer) throw TException("Error reading image data");
log("readline: OK");
/*
if (params.getScanType() == TScannerParameters::BW )
{
for (unsigned int i = 0; i< reqBytes;i++)
readBuffer[i] = ~readBuffer[i];
}
*/
memcpy(buffer + bytes_read, readBuffer.get(), reqBytes);
bytes_read += reqBytes;
nTimes++;
if (bytes_read == bytes) break; /* I've read enough bytes */
if (!(stx & 0x20)) sendACK();
}
log("read: OK");
{ /*
FILE *myFile = fopen("C:\\temp\\prova.dmp", "w+");
fwrite(buffer, 1, bytes_to_read, myFile);
fclose(myFile);*/
}
if (params.m_paperFeeder.m_supported &&
(params.m_paperFeeder.m_value == 1.)) {
log("Advance paper");
if (m_settingsMode == OLD_STYLE) ESCI_doADF(0);
log("Advance paper: OK");
}
switch (params.getScanType()) {
case TScannerParameters::BW:
#ifdef BW_USES_GRAYTONES
copyGR8BufferToTRasterBW(buffer, dimlx, dimly, ras, true,
params.m_threshold.m_value);
// copyGR8BufferToTRasterGR8(buffer, dimlx, dimly, ras, true);
break;
#else
copyBWBufferToTRasterGR8(buffer, dimlx, dimly, ras, true, true);
break;
#endif
case TScannerParameters::GR8:
#ifdef GRAYTONES_USES_RGB
copyRGBBufferToTRasterGR8(buffer, dimlx, dimly, dimlx, ras);
break;
#else
copyGR8BufferToTRasterGR8(buffer, dimlx, dimly, ras, true);
break;
#endif
case TScannerParameters::RGB24:
copyRGBBufferToTRaster32(buffer, dimlx, dimly, ras, true);
break;
default:
throw TException("Unknown scanner mode");
break;
}
if (params.getCropBox() != params.getScanArea() && !params.isPreview()) {
TRect scanRect(
TPoint(offsetx, offsety),
TDimension(dimly, dimlx)); // dimLx and ly was has been swapped
scanArea2pix(params, offsetx, offsety, dimlx, dimly,
params.getScanArea());
TRasterP app = ras->create(dimly, dimlx);
TRaster32P app32(app);
TRasterGR8P appGR8(app);
if (app32)
app32->fill(TPixel32::White);
else if (appGR8)
appGR8->fill(TPixelGR8::White);
app->copy(ras, TPoint(dimly - scanRect.y1 - 1, dimlx - scanRect.x1 - 1));
ras = app;
}
TRasterImageP rasImg(ras);
if (ras) {
rasImg->setDpi(params.m_dpi.m_value, params.m_dpi.m_value);
rasImg->setSavebox(ras->getBounds());
}
log("notifying");
notifyImageDone(rasImg);
if (!(params.m_paperFeeder.m_value == 1.) ||
params.isPreview()) // feeder here!
{
if ((paperCount - i) > 1) notifyNextPaper();
} else
notifyAutomaticallyNextPaper();
if (isScanningCanceled()) break;
}
/*Unload Paper if need*/
if ((m_settingsMode == NEW_STYLE) && params.m_paperFeeder.m_supported &&
(params.m_paperFeeder.m_value == 1.)) {
if (!ESCI_command_1b('e', 1, true)) {
std::vector<std::string> notFatal;
throw TScannerExpection(notFatal, "Scanner error (un)loading paper");
}
unsigned char p = 0x0C;
bool status = true;
send(&p, 1);
status = expectACK();
}
log("acquire OK");
}
//-----------------------------------------------------------------------------
bool TScannerEpson::isAreaSupported() { return true; }
//-----------------------------------------------------------------------------
inline unsigned char B0(const unsigned int v) { return (v & 0x000000ff); }
inline unsigned char B1(const unsigned int v) { return (v & 0x0000ff00) >> 8; }
inline unsigned char B2(const unsigned int v) { return (v & 0x00ff0000) >> 16; }
inline unsigned char B3(const unsigned int v) { return (v & 0xff000000) >> 24; }
void TScannerEpson::doSettings(const TScannerParameters &params,
bool firstSheet) {
log("doSettings");
int retryCount = 3;
std::vector<std::string> notFatal;
while (retryCount--) {
if (m_settingsMode == NEW_STYLE) {
if (firstSheet)
if (!resetScanner()) {
notFatal.push_back("Scanner error resetting");
continue;
}
} else {
if (!resetScanner()) {
notFatal.push_back("Scanner error resetting");
continue;
}
}
unsigned char cmd[64];
memset(&cmd, 0, 64);
unsigned char brightness = 0x00;
float bv = params.m_brightness.m_value;
if (bv >= 0 && bv < 43) brightness = 0xFD;
if (bv >= 43 && bv < 86) brightness = 0xFE;
if (bv >= 86 && bv < 128) brightness = 0xFF;
if (bv >= 128 && bv < 171) brightness = 0x00;
if (bv >= 171 && bv < 214) brightness = 0x01;
if (bv >= 214 && bv < 255) brightness = 0x02;
if (bv == 255) brightness = 0x03;
unsigned short dpi = (unsigned short)params.m_dpi.m_value;
unsigned short offsetx, offsety;
unsigned short sizelx, sizely;
TRectD scanArea =
params.isPreview() ? params.getScanArea() : params.getCropBox();
scanArea2pix(params, offsetx, offsety, sizelx, sizely, scanArea);
// the main scan resolution (ESC R)
cmd[0] = B0(dpi);
cmd[1] = B1(dpi);
cmd[2] = B2(dpi);
cmd[3] = B3(dpi);
// the sub scan resolution (ESC R)
cmd[4] = B0(dpi);
cmd[5] = B1(dpi);
cmd[6] = B2(dpi);
cmd[7] = B3(dpi);
// skipping length of main scan (ESC A)
cmd[8] = B0(offsetx);
cmd[9] = B1(offsetx);
cmd[10] = B2(offsetx);
cmd[11] = B3(offsetx);
// skipping length of sub scan (ESC A)
cmd[12] = B0(offsety);
cmd[13] = B1(offsety);
cmd[14] = B2(offsety);
cmd[15] = B3(offsety);
// the length of main scanning (ESC A)
cmd[16] = B0(sizelx);
cmd[17] = B1(sizelx);
cmd[18] = B2(sizelx);
cmd[19] = B3(sizelx);
// the length of sub scanning (ESC A)
cmd[20] = B0(sizely);
cmd[21] = B1(sizely);
cmd[22] = B2(sizely);
cmd[23] = B3(sizely);
#ifdef GRAYTONES_USES_RGB
cmd[24] = 0x13; // scanning color (ESC C)
cmd[25] = 0x08; // data format (ESC D)
#else
switch (params.getScanType()) {
case TScannerParameters::BW:
cmd[24] = 0x00; // scanning BW/Gray (ESC C)
#ifdef BW_USES_GRAYTONES
cmd[25] = 0x08; // data format (ESC D)
#else
cmd[25] = 0x01; // data format (ESC D)
break;
#endif
case TScannerParameters::GR8:
cmd[24] = 0x00; // scanning BW/Gray (ESC C)
cmd[25] = 0x08; // data format (ESC D)
break;
case TScannerParameters::RGB24:
cmd[24] = 0x13; // scanning color (ESC C)
cmd[25] = 0x08; // data format (ESC D)
break;
default:
throw TException("Unknown scanner mode");
break;
}
// cmd[24] = (params.getScanType() == TScannerParameters::RGB24)?0x13:0x00;
// //scanning color (ESC C)
// cmd[25] = (params.getScanType() == TScannerParameters::RGB24)?0x08:0x08; //
// data format (ESC D)
#endif
if (m_settingsMode == NEW_STYLE)
cmd[26] = 0;
else
cmd[26] = (params.m_paperFeeder.m_supported &&
(params.m_paperFeeder.m_value == 1.))
? 0x01
: 0x00; // option control (ESC e)
cmd[27] = 0x00; // scanning mode (ESC g)
cmd[28] = 0xFF; // the number of block line (ESC d)
cmd[29] = 0x02; // gamma (ESC Z)
cmd[30] = brightness; // brightness (ESC L)
cmd[31] = 0x80; // color collection (ESC M)
cmd[32] = 0x01; // half toning processing (ESC B)
cmd[33] = (unsigned char)params.m_threshold.m_value; // threshold (ESC t)
cmd[34] = 0x00; // separate of area (ESC s)
cmd[35] = 0x01; // sharpness control (ESC Q)
cmd[36] = 0x00; // mirroring (ESC K)
cmd[37] = 0x00; // set film type (ESC N)
// other bytes should be set to 0x00 !
if (m_settingsMode == NEW_STYLE)
if (params.m_paperFeeder.m_supported &&
(params.m_paperFeeder.m_value == 1.)) {
unsigned char v = (params.m_paperFeeder.m_value == 1.) ? 0x01 : 0x00;
if (!ESCI_command_1b('e', v, true))
throw TScannerExpection(notFatal, "Scanner error (un)loading paper");
if (v) {
unsigned char p = 0x19;
bool status = true;
send(&p, 1);
status = expectACK();
}
}
unsigned char setParamCmd[2] = {0x1C, 0x57};
int wrote = send(&setParamCmd[0], 2);
if (wrote != 2)
throw TScannerExpection(notFatal,
"Error setting scanner parameters - W -");
if (!expectACK()) {
notFatal.push_back("Error setting scanner parameters - NAK on W -");
continue;
}
wrote = send(&cmd[0], 0x40);
if (wrote != 0x40)
throw TScannerExpection(notFatal,
"Error setting scanner parameters - D -");
if (!expectACK()) {
notFatal.push_back("Error setting scanner parameters - NAK on D -");
continue;
}
// if here, everything is ok, exit from loop
break;
}
if (retryCount <= 0)
throw TScannerExpection(
notFatal, "Error setting scanner parameters, too many retries");
log("doSettings:OK");
}
//-----------------------------------------------------------------------------
void TScannerEpson::collectInformation(char *lev0, char *lev1,
unsigned short *lowRes,
unsigned short *hiRes,
unsigned short *hMax,
unsigned short *vMax) {
log("collectInformation");
unsigned char stx;
int pos = 0;
unsigned short counter;
unsigned char status;
/*
if (!resetScanner())
throw TException("Scanner error resetting");
*/
if (!ESCI_command('I', false))
throw TException("Unable to get scanner info. Is it off ?");
unsigned long s = 4; // 4 bytes cfr Identity Data Block on ESCI Manual!!!
std::unique_ptr<unsigned char[]> buffer2 = ESCI_read_data2(s);
if (!buffer2 || (s != 4)) throw TException("Error reading scanner info");
memcpy(&stx, buffer2.get(), 1);
memcpy(&counter, &(buffer2[2]), 2);
#ifdef SWAPIT
counter = swapUshort(counter);
#endif
#ifdef _DEBUG
memcpy(&status, &(buffer2[1]), 1);
std::stringstream os;
os << "stx = " << stx << " status = " << status << " counter=" << counter
<< '\n'
<< '\0';
#endif
s = counter;
std::unique_ptr<unsigned char[]> buffer = ESCI_read_data2(s);
int len = strlen((const char *)buffer.get());
/*printf("Level %c%c", buffer[0], buffer[1]);*/
if (len > 1) {
*lev0 = buffer[0];
*lev1 = buffer[1];
}
pos = 2;
/* buffer[pos] contains 'R' */
if (len < 3 || buffer[pos] != 'R') {
*lev0 = '0';
*lev1 = '0';
*lowRes = 0;
*hiRes = 0;
*vMax = 0;
*hMax = 0;
throw TException("unable to get information from scanner");
}
*lowRes = (buffer[pos + 2] * 256) + buffer[pos + 1];
*hiRes = *lowRes;
while (buffer[pos] == 'R') {
*hiRes = (buffer[pos + 2] * 256) + buffer[pos + 1];
/* printf("Resolution %c %d", buffer[pos], *hiRes);*/
pos += 3;
}
if (buffer[pos] != 'A') {
*lev0 = '0';
*lev1 = '0';
*lowRes = 0;
*hiRes = 0;
*vMax = 0;
*hMax = 0;
throw TException("unable to get information from scanner");
}
*hMax = (buffer[pos + 2] * 256) + buffer[pos + 1];
*vMax = (buffer[pos + 4] * 256) + buffer[pos + 3];
ESCI_command('f', false);
ESCI_readLineData2(stx, status, counter);
if (status & FatalError)
throw TException("Fatal error reading information from scanner");
s = counter;
buffer = ESCI_read_data2(s);
// name buffer+1A
const char *name = (const char *)(buffer.get() + 0x1A);
if (strncmp(name, "Perfection1640", strlen("Perfection1640"))) {
m_settingsMode = NEW_STYLE;
} else {
m_settingsMode = OLD_STYLE;
}
#if 0
scsi_new_d("ESCI_extended_status");
scsi_len(42);
/* main status*/
scsi_b00(0, "push_button_supported", 0);
scsi_b11(0, "warming_up", 0);
scsi_b33(0, "adf_load_sequence", 0); /* 1 from first sheet; 0 from last or not supp */
scsi_b44(0, "both_sides_on_adf", 0);
scsi_b55(0, "adf_installed_main_status", 0);
scsi_b66(0, "NFlatbed", 0); /*0 if scanner is flatbed else 1 */
scsi_b77(0, "system_error", 0);
/* adf status */
scsi_b77(1, "adf_installed",0);
/*... some other info.., refer to manual if needed*/
/**/
#endif
m_hasADF = !!(buffer[1] & 0x80);
log("collectInformation:OK");
}
//-----------------------------------------------------------------------------
bool TScannerEpson::resetScanner() {
log("resetScanner");
bool ret = ESCI_command('@', true);
log(std::string("resetScanner: ") + (ret ? "OK" : "FAILED"));
return ret;
}
//-----------------------------------------------------------------------------
int TScannerEpson::receive(unsigned char *buffer, int size) {
return m_scannerIO->receive(buffer, size);
}
int TScannerEpson::send(unsigned char *buffer, int size) {
return m_scannerIO->send(buffer, size);
}
int TScannerEpson::sendACK() { return send(&ACK, 1); }
bool TScannerEpson::expectACK() {
log("expectACK");
unsigned char ack = NAK;
int nb = receive(&ack, 1);
#ifdef _DEBUG
if (ack != ACK) {
std::stringstream os;
os << "ack fails ret = 0x" << std::hex << (int)ack << '\n' << '\0';
TSystem::outputDebug(os.str());
}
#endif
log(std::string("expectACK: ") + (ack == ACK ? "ACK" : "FAILED"));
return (ack == ACK);
}
char *TScannerEpson::ESCI_inquiry(char cmd) /* returns 0 if failed */
{
assert(0);
return 0;
}
bool TScannerEpson::ESCI_command(char cmd, bool checkACK) {
unsigned char p[2];
p[0] = ESC;
p[1] = cmd;
bool status;
int count = send(&(p[0]), 2);
status = count == 2;
if (checkACK) status = expectACK();
return status;
}
bool TScannerEpson::ESCI_command_1b(char cmd, unsigned char p0, bool checkACK) {
bool status = false;
if (ESCI_command(cmd, checkACK)) {
unsigned char p = p0;
status = true;
send(&p, 1);
if (checkACK) status = expectACK();
}
return status;
}
bool TScannerEpson::ESCI_command_2b(char cmd, unsigned char p0,
unsigned char p1, bool checkACK) {
bool status = false;
if (ESCI_command(cmd, checkACK)) {
status = true;
unsigned char p[2];
p[0] = p0;
p[1] = p1;
int timeout = 30000;
send(&(p[0]), 2);
if (checkACK) status = expectACK();
}
return status;
}
bool TScannerEpson::ESCI_command_2w(char cmd, unsigned short p0,
unsigned short p1, bool checkACK) {
bool status = false;
if (ESCI_command(cmd, checkACK)) {
status = true;
unsigned short p[2];
p[0] = p0;
p[1] = p1;
const int len = 1;
int timeout = 30000;
send((unsigned char *)(&(p[0])), 4);
if (checkACK) status = expectACK();
}
return status;
}
bool TScannerEpson::ESCI_command_4w(char cmd, unsigned short p0,
unsigned short p1, unsigned short p2,
unsigned short p3, bool checkACK) {
bool status = false;
if (ESCI_command(cmd, checkACK)) {
status = true;
unsigned char p[8];
p[0] = (unsigned char)p0;
p[1] = (unsigned char)(p0 >> 8);
p[2] = (unsigned char)p1;
p[3] = (unsigned char)(p1 >> 8);
p[4] = (unsigned char)p2;
p[5] = (unsigned char)(p2 >> 8);
p[6] = (unsigned char)(p3);
p[7] = (unsigned char)(p3 >> 8);
send((unsigned char *)&(p[0]), 8);
if (checkACK) status = expectACK();
}
return status;
}
std::unique_ptr<unsigned char[]> TScannerEpson::ESCI_read_data2(
unsigned long &size) {
std::unique_ptr<unsigned char[]> buffer(new unsigned char[size]);
memset(buffer.get(), 0, size);
unsigned long bytesToRead = size;
size = receive(buffer.get(), bytesToRead);
return buffer;
}
bool TScannerEpson::ESCI_doADF(bool on) {
// check ref esci documentation page 3-64
unsigned char eject = 0x0c;
int rc = send(&eject, 1);
bool status1 = expectACK();
return status1;
return 1;
if (!ESCI_command_1b('e', 0x01, true)) {
if (on)
throw TException("Scanner error loading paper");
else
throw TException("Scanner error unloading paper");
}
unsigned char p = on ? 0x19 : 0x0C;
send(&p, 1);
bool status = expectACK();
return status;
}
void TScannerEpson::scanArea2pix(const TScannerParameters &params,
unsigned short &offsetx,
unsigned short &offsety,
unsigned short &sizelx, unsigned short &sizely,
const TRectD &scanArea) {
const double f = 25.4;
offsetx = (unsigned short)((scanArea.x0 * params.m_dpi.m_value) / f);
offsety = (unsigned short)((scanArea.y0 * params.m_dpi.m_value) / f);
sizelx =
(unsigned short)(((scanArea.x1 - scanArea.x0) * params.m_dpi.m_value) /
f);
sizelx = (sizelx >> 3) << 3; // questo deve essere multiplo di 8
sizely =
(unsigned short)(((scanArea.y1 - scanArea.y0) * params.m_dpi.m_value) /
f);
}
void TScannerEpson::ESCI_readLineData(unsigned char &stx, unsigned char &status,
unsigned short &counter,
unsigned short &lines, bool &areaEnd) {
unsigned long s = 6;
std::unique_ptr<unsigned char[]> buffer = ESCI_read_data2(s);
if (!buffer) throw TException("Error reading scanner info");
/* PACKET DATA LEN = 6
type offs descr
byte 0 STX
b77 1 fatal_error
b66 1 not_ready
b55 1 area_end
b44 1 option_unit
b33 1 col_attrib_bit_3
b22 1 col_attrib_bit_2
b11 1 extended_commands
drow 2, counter
drow 4 lines
*/
bool fatalError = !!(buffer[1] & 0x80);
bool notReady = !!(buffer[1] & 0x40);
areaEnd = !!(buffer[1] & 0x20);
memcpy(&stx, buffer.get(), 1);
memcpy(&counter, &(buffer[2]), 2);
#ifdef SWAPIT
counter = swapUshort(counter);
#endif
memcpy(&lines, &(buffer[4]), 2);
#ifdef SWAPIT
lines = swapUshort(lines);
#endif
status = buffer[1];
#ifdef _DEBUG
std::stringstream os;
os << "fatal=" << fatalError;
os << " notReady=" << notReady;
os << " areaEnd=" << areaEnd;
os << " stx=" << stx;
os << " counter=" << counter;
os << " lines=" << lines;
os << '\n' << '\0';
TSystem::outputDebug(os.str());
#endif
}
void TScannerEpson::ESCI_readLineData2(unsigned char &stx,
unsigned char &status,
unsigned short &counter) {
unsigned long s = 4;
std::unique_ptr<unsigned char[]> buffer = ESCI_read_data2(s);
if (!buffer) throw TException("Error reading scanner info");
bool fatalError = !!(buffer[1] & 0x80);
bool notReady = !!(buffer[1] & 0x40);
memcpy(&stx, buffer.get(), 1);
memcpy(&counter, &(buffer[2]), 2);
#ifdef SWAPIT
counter = swapUshort(counter);
#endif
status = buffer[1];
#ifdef _DEBUG
std::stringstream os;
os << "fatal=" << fatalError;
os << " notReady=" << notReady;
os << " stx=" << stx;
os << " counter=" << counter;
os << '\n' << '\0';
TSystem::outputDebug(os.str());
#endif
}

72
toonz/sources/tnzbase/tscanner/tscannerepson.h
View file

@ -1,72 +0,0 @@
#pragma once
#ifndef TSCANNER_EPSON_INCLUDED
#define TSCANNER_EPSON_INCLUDED
#include "tscanner.h"
#include "TScannerIO/TScannerIO.h"
#include <memory>
/*
PLEASE DO NOT REMOVE unreferenced methods... they are useful for debugging :)
max
*/
class TScannerEpson final : public TScanner {
enum SettingsMode { OLD_STYLE, NEW_STYLE };
TScannerIO *m_scannerIO;
bool m_hasADF;
bool m_isOpened;
SettingsMode m_settingsMode;
public:
TScannerEpson();
~TScannerEpson();
void selectDevice() override;
bool isDeviceAvailable() override;
bool isDeviceSelected() override;
void updateParameters(TScannerParameters &param) override; // vedi TScanner
void acquire(const TScannerParameters &params, int paperCount) override;
bool isAreaSupported();
void closeIO();
private:
void doSettings(const TScannerParameters &params, bool isFirstSheet);
void collectInformation(char *lev0, char *lev1, unsigned short *lowRes,
unsigned short *hiRes, unsigned short *hMax,
unsigned short *vMax);
bool resetScanner();
void reportError(std::string errMsg); // debug only
char *ESCI_inquiry(char cmd); /* returns 0 if failed */
bool ESCI_command(char cmd, bool checkACK);
bool ESCI_command_1b(char cmd, unsigned char p0, bool checkACK);
bool ESCI_command_2b(char cmd, unsigned char p0, unsigned char p1,
bool checkACK);
bool ESCI_command_2w(char cmd, unsigned short p0, unsigned short p1,
bool checkACK);
bool ESCI_command_4w(char cmd, unsigned short p0, unsigned short p1,
unsigned short p2, unsigned short p3, bool checkACK);
std::unique_ptr<unsigned char[]> ESCI_read_data2(unsigned long &size);
void ESCI_readLineData(unsigned char &stx, unsigned char &status,
unsigned short &counter, unsigned short &lines,
bool &areaEnd);
void ESCI_readLineData2(unsigned char &stx, unsigned char &status,
unsigned short &counter);
int receive(unsigned char *buffer, int size);
int send(unsigned char *buffer, int size);
bool ESCI_doADF(bool on);
int sendACK();
bool expectACK();
void scanArea2pix(const TScannerParameters &params, unsigned short &offsetx,
unsigned short &offsety, unsigned short &dimlx,
unsigned short &dimly, const TRectD &scanArea);
};
#endif

339
toonz/sources/tnzbase/tscanner/tscannertwain.cpp
View file

@ -1,339 +0,0 @@
#include <texception.h>
#include <tscanner.h>
#include "tscannertwain.h"
#include "tscannerutil.h"
using namespace TScannerUtil;
extern "C" {
#include "../common/twain/ttwain_util.h"
#include "../common/twain/ttwain_global_def.h" /* forward declare functions */
}
/* callback used to handle TTWAIN done/error status*/
static void throwIT(const char *msg) { throw TException(msg); }
extern "C" void TTWAIN_ErrorBox(const char *msg) { throwIT(msg); }
extern "C" {
static int onDoneCB(UCHAR *buffer, TTWAIN_PIXTYPE pixelType, int lx, int ly,
int wrap, float xdpi, float ydpi, void *usrData) {
TRasterP ras;
switch (pixelType) {
case TTWAIN_BW:
case TTWAIN_WB: {
try {
TRasterGR8P ras8(lx, ly);
copy90BWBufferToRasGR8(buffer, lx, ly, wrap, (pixelType == TTWAIN_BW),
ras8, 1, 0);
ras8->xMirror();
ras8->yMirror();
ras = ras8;
} catch (...) {
}
} break;
case TTWAIN_RGB24: {
try {
TRaster32P ras32(lx, ly);
copyRGBBufferToTRaster32(buffer, lx, ly, ras32, false);
ras = ras32;
} catch (...) {
}
} break;
case TTWAIN_GRAY8: {
try {
TRasterGR8P ras8(lx, ly);
copyGR8BufferToTRasterGR8(buffer, lx, ly, ras8, false);
ras = ras8;
} catch (...) {
}
} break;
default:
break;
}
TRasterImageP rasImg;
if (ras) {
rasImg = TRasterImageP(ras);
rasImg->setDpi(xdpi, ydpi);
// rasImg->sethPos(hpos);
rasImg->setSavebox(ras->getBounds());
}
TScanner *scannerDevice = reinterpret_cast<TScanner *>(usrData);
scannerDevice->notifyImageDone(rasImg);
TTWAIN_FreeMemory(buffer);
scannerDevice->decrementPaperLeftCount();
return scannerDevice->getPaperLeftCount();
}
}
//-----------------------------------------------------------------------------
extern "C" {
static void onErrorCB(void *usrData, void *alwaysZero) {
TScanner *scannerDevice = reinterpret_cast<TScanner *>(usrData);
scannerDevice->notifyError();
}
}
//-----------------------------------------------------------------------------
TScannerTwain::TScannerTwain() {}
//-----------------------------------------------------------------------------
TScannerTwain::~TScannerTwain() {}
//-----------------------------------------------------------------------------
namespace {
bool deviceSelected = false;
}
//-----------------------------------------------------------------------------
void TScannerTwain::selectDevice() {
TTWAIN_SelectImageSource(0);
deviceSelected = true;
if (TTWAIN_OpenDefaultSource()) {
QString twainVersion(TTWAIN_GetTwainVersion());
QString manufacturer(TTWAIN_GetManufacturer());
QString productFamily(TTWAIN_GetProductFamily());
QString productName(TTWAIN_GetProductName());
QString version(TTWAIN_GetVersion());
TTWAIN_CloseAll(0);
if (manufacturer != "") {
// se c'e' il nome della marca lo tolgo dal productFamily e productName
productFamily.replace(manufacturer, "");
productName.replace(manufacturer, "");
}
setName(manufacturer + " " + productFamily + " " + productName + " (" +
version + ")");
}
}
//-----------------------------------------------------------------------------
bool TScannerTwain::isDeviceSelected() { return deviceSelected; }
//-----------------------------------------------------------------------------
bool TScannerTwain::isDeviceAvailable() { return !!TTWAIN_IsAvailable(); }
//-----------------------------------------------------------------------------
// TODO!! renderla un update
void TScannerTwain::updateParameters(TScannerParameters &param) {
int rc = TTWAIN_OpenDefaultSource();
if (!rc) return;
#ifdef MACOSX
// TTWAIN_DumpCapabilities(printf);
#endif
if (isAreaSupported()) {
float w, h;
TTWAIN_GetPhysicalWidthWoAdf(&w);
TTWAIN_GetPhysicalHeightWoAdf(&h);
double width_mm = w * 25.4;
double height_mm = h * 25.4;
param.setMaxPaperSize(width_mm, height_mm);
// sembra sbagliato: bisognerebbe comunque tenere conto del paperFormat
// selezionato
// param.m_scanArea = TRectD(0,0, width_mm,height_mm);
}
TScanParam defaultTwainParam(0., 255., 128., 1.);
if (TTWAIN_IsCapBrightnessSupported()) {
m_brightness.m_supported = true;
TTWAIN_GetBrightness(&m_brightness.m_min, &m_brightness.m_max,
&m_brightness.m_step, &m_brightness.m_def);
} else {
// m_brightness.m_def = m_brightness.m_max = m_brightness.m_min =
// m_brightness.m_step = 0.;
m_brightness.update(defaultTwainParam);
m_brightness.m_supported = false;
}
// m_brightness.m_value = m_brightness.m_def;
param.m_brightness.update(m_brightness);
if (TTWAIN_IsCapContrastSupported()) {
m_contrast.m_supported = true;
TTWAIN_GetContrast(&m_contrast.m_min, &m_contrast.m_max, &m_contrast.m_step,
&m_contrast.m_def);
} else {
// m_contrast.m_def = m_contrast.m_max = m_contrast.m_min =
// m_contrast.m_step = 0.;
m_contrast.update(defaultTwainParam);
m_contrast.m_supported = false;
}
// m_contrast.m_value = m_contrast.m_def;
param.m_contrast.update(m_contrast);
if (TTWAIN_IsCapThresholdSupported()) {
m_threshold.m_supported = true;
TTWAIN_GetThreshold(&m_threshold.m_min, &m_threshold.m_max,
&m_threshold.m_step, &m_threshold.m_def);
} else {
// m_threshold.m_def = m_threshold.m_max = m_threshold.m_min =
// m_threshold.m_step = 0.;
m_threshold.update(defaultTwainParam);
m_threshold.m_supported = false;
}
// m_threshold.m_value = m_threshold.m_def;
param.m_threshold.update(m_threshold);
if (TTWAIN_IsCapResolutionSupported()) {
m_dpi.m_supported = true;
TTWAIN_GetResolution(&m_dpi.m_min, &m_dpi.m_max, &m_dpi.m_step,
&m_dpi.m_def);
param.m_dpi.update(m_dpi);
} else {
// m_dpi.m_def = m_dpi.m_max = m_dpi.m_min = m_dpi.m_step = 0.;
param.m_dpi.m_supported = false;
}
// m_dpi.m_value = m_dpi.m_def;
/*
param.m_twainVersion = string(TTWAIN_GetTwainVersion());
param.m_manufacturer = string(TTWAIN_GetManufacturer ());
param.m_prodFamily = string(TTWAIN_GetProductFamily());
param.m_productName = string(TTWAIN_GetProductName ());
param.m_version = string(TTWAIN_GetVersion());
*/
bool bw = !!TTWAIN_SupportsPixelType(TTWAIN_BW) ||
!!TTWAIN_SupportsPixelType(TTWAIN_WB);
bool gray = !!TTWAIN_SupportsPixelType(TTWAIN_GRAY8);
bool rgb = !!TTWAIN_SupportsPixelType(TTWAIN_RGB24);
param.setSupportedTypes(bw, gray, rgb);
TTWAIN_CloseAll(0);
}
//-----------------------------------------------------------------------------
static void setupParameters(const TScannerParameters &params,
bool isAreaSupported) {
if (isAreaSupported) {
TRectD scanArea = params.getScanArea();
float L = (float)(scanArea.getP00().x / 25.4);
float T = (float)(scanArea.getP00().y / 25.4);
float R = (float)(scanArea.getP11().x / 25.4);
float B = (float)(scanArea.getP11().y / 25.4);
TTWAIN_SetImageLayout(L, T, R, B);
}
TTWAIN_PIXTYPE pt;
switch (params.getScanType()) {
case TScannerParameters::BW:
pt = TTWAIN_BW;
break;
case TScannerParameters::GR8:
pt = TTWAIN_GRAY8;
break;
case TScannerParameters::RGB24:
pt = TTWAIN_RGB24;
break;
default:
/* assert(0);*/
pt = TTWAIN_RGB24;
break;
}
TTWAIN_SetPixelType(pt);
if (params.m_dpi.m_supported) TTWAIN_SetResolution(params.m_dpi.m_value);
if (params.m_brightness.m_supported)
TTWAIN_SetBrightness(params.m_brightness.m_value);
if (params.m_contrast.m_supported)
TTWAIN_SetContrast(params.m_contrast.m_value);
if (params.m_threshold.m_supported)
TTWAIN_SetThreshold(params.m_threshold.m_value);
}
//-----------------------------------------------------------------------------
static void openAndSetupTwain() {
int rc = TTWAIN_OpenDefaultSource();
if (rc) {
TTWAIN_SetTwainUsage(TTWAIN_MODE_UNLEASHED);
if (TTWAIN_IsCapDeviceOnLineSupported()) {
int status = TTWAIN_IsDeviceOnLine();
if (status == 0) {
}
}
}
TTWAIN_SetUIStatus(TRUE);
}
void TScannerTwain::acquire(const TScannerParameters &params, int paperCount) {
openAndSetupTwain();
// int feeder = TTWAIN_IsFeederLoaded();
int feeder = params.isPaperFeederEnabled();
m_paperLeft = paperCount;
int rc;
#ifdef MACOSX
// pezza solo HP su MACOSX per gestire la scansione di piu' frame
bool ishp = !!(strcasestr(TTWAIN_GetProductName(), "hp"));
#else
bool ishp = false;
#endif
if (ishp) {
for (int i = 0; i < paperCount; ++i) {
printf("scanning %d/%d\n", i + 1, paperCount);
if (i == 0) {
setupParameters(params, isAreaSupported());
TTWAIN_SetOnDoneCallback(onDoneCB, this);
TTWAIN_SetOnErrorCallback(onErrorCB, this);
} else
openAndSetupTwain();
rc = TTWAIN_SetXferMech(TTWAIN_TRANSFERMODE_MEMORY, 0, 0, 0, 0, 1);
int acq_rc = TTWAIN_AcquireMemory(0);
if (acq_rc == 0) break; // error, or the user has closed the TWAIN UI
if (!feeder && ((paperCount - i) > 1)) notifyNextPaper();
TTWAIN_CloseAll(0);
}
} else {
for (int i = 0; i < (feeder ? 1 : paperCount); ++i) {
printf("scanning %d/%d\n", i + 1, paperCount);
setupParameters(params, isAreaSupported());
rc = TTWAIN_SetXferMech(TTWAIN_TRANSFERMODE_MEMORY, 0, 0, 0, 0,
paperCount);
TTWAIN_SetOnDoneCallback(onDoneCB, this);
TTWAIN_SetOnErrorCallback(onErrorCB, this);
int acq_rc = TTWAIN_AcquireMemory(0);
if (acq_rc == 0) break; // error, or the user has closed the TWAIN UI
if (!feeder && ((paperCount - i) > 1)) notifyNextPaper();
}
TTWAIN_CloseAll(0);
}
}
//-----------------------------------------------------------------------------
bool TScannerTwain::isAreaSupported() {
/*
TTWAIN_IsCapPhysicalWidthSupported (void);
TTWAIN_IsCapPhysicalHeightSupported (void);
*/
return !!TTWAIN_IsCapImageLayoutSupported();
}

22
toonz/sources/tnzbase/tscanner/tscannertwain.h
View file

@ -1,22 +0,0 @@
#pragma once
#ifndef SCANNER_TWAIN_INCLUDED
#define SCANNER_TWAIN_INCLUDED
#include "tscanner.h"
class TScannerTwain final : public TScanner {
public:
TScannerTwain();
~TScannerTwain();
bool isDeviceAvailable() override;
bool isDeviceSelected() override;
void selectDevice() override;
void updateParameters(TScannerParameters &) override; // vedi TScanner
void acquire(const TScannerParameters &param, int paperCount) override;
bool isAreaSupported();
};
#endif

297
toonz/sources/tnzbase/tscanner/tscannerutil.cpp
View file

@ -1,297 +0,0 @@
#include "tscannerutil.h"
#include <cstring>
#define BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) \
(((UCHAR *)(BUF))[(((X) + (BITOFFS)) >> 3) + (Y) * (BYTEWRAP)])
#define GET_BIT(X, Y, BUF, BYTEWRAP, BITOFFS) \
((BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) >> (7 - (((X) + (BITOFFS)) & 7))) & \
(UCHAR)1)
namespace TScannerUtil {
struct EP {
unsigned char r, g, b;
};
//-----------------------------------------------------------------------------
void copyRGBBufferToTRaster32(unsigned char *rgbBuffer, int rgbLx, int rgbLy,
const TRaster32P &rout, bool internal) {
if (internal) {
TPixelRGBM32 *dst = rout->pixels();
EP *src = (EP *)(rgbBuffer + (rgbLx * rgbLy - 1) * 3);
const int w = rout->getWrap();
for (int x = 0; x < rout->getLx(); ++x) {
dst = rout->pixels() + x;
for (int y = 0; y < rout->getLy(); ++y) {
dst->r = src->r;
dst->g = src->g;
dst->b = src->b;
dst->m = 0xff;
dst += w;
--src;
}
}
} else {
unsigned char *index = rgbBuffer;
unsigned char *end = index + (rgbLx * rgbLy * 3);
TPixel32 *outPix = rout->pixels();
while (index < end) {
outPix->r = (int)*index;
index++;
outPix->g = (int)*index;
index++;
outPix->b = (int)*index;
index++;
outPix->m = 255;
outPix++;
}
rout->yMirror();
}
}
//-----------------------------------------------------------------------------
void copyRGBBufferToTRasterGR8(unsigned char *rgbBuffer, int rgbLx, int rgbLy,
int rgbWrap, const TRasterGR8P &rout) {
TPixelGR8 *dst = rout->pixels();
EP *src = (EP *)(rgbBuffer + (rgbLx * rgbLy - 1) * 3);
const int w = rout->getWrap();
for (int x = 0; x < rout->getLx(); ++x) {
dst = rout->pixels() + x;
for (int y = 0; y < rout->getLy(); ++y) {
*dst = TPixelGR8::from(TPixelRGBM32(src->r, src->g, src->b));
dst += w;
--src;
}
}
}
//-----------------------------------------------------------------------------
void copyGR8BufferToTRasterGR8(unsigned char *gr8Buffer, int rgbLx, int rgbLy,
const TRasterGR8P &rout, bool internal) {
if (internal) {
unsigned char *dst = rout->getRawData();
unsigned char *src = (gr8Buffer + rgbLx * rgbLy - 1);
const int w = rout->getWrap();
for (int x = 0; x < rout->getLx(); ++x) {
dst = rout->getRawData() + x;
for (int y = 0; y < rout->getLy(); ++y) {
*dst = (*src);
dst += w;
--src;
}
}
} else {
memcpy(rout->getRawData(), gr8Buffer, rgbLx * rgbLy);
rout->yMirror();
}
}
//-----------------------------------------------------------------------------
void copyGR8BufferToTRasterBW(unsigned char *gr8Buffer, int rgbLx, int rgbLy,
const TRasterGR8P &rout, bool internal,
float thres) {
if (internal) {
unsigned char *dst = rout->getRawData();
unsigned char *src = (gr8Buffer + rgbLx * rgbLy - 1);
const int w = rout->getWrap();
for (int x = 0; x < rout->getLx(); ++x) {
dst = rout->getRawData() + x;
for (int y = 0; y < rout->getLy(); ++y) {
if (*src < thres)
*dst = 0;
else
*dst = 255;
dst += w;
--src;
}
}
} else {
memcpy(rout->getRawData(), gr8Buffer, rgbLx * rgbLy);
rout->yMirror();
}
}
//-----------------------------------------------------------------------------
void copyBWBufferToTRasterGR8(const unsigned char *buffer, int rgbLx, int rgbLy,
const TRasterGR8P &rout, bool isBW,
bool internal) {
if (0)
assert(0);
else {
int i = 0;
UCHAR *pix = rout->getRawData();
const unsigned char *byte;
while (i < rgbLx * rgbLy) {
int bytePos = i / 8;
int bitPos = i % 8;
byte = buffer + bytePos;
bool bit = (*byte) >> (7 - bitPos);
if (isBW)
*pix = (bit ? 255 : 0);
else
*pix = (bit ? 0 : 255);
pix++;
i++;
}
rout->yMirror();
}
}
//-----------------------------------------------------------------------------
void copy90BWBufferToRasGR8(unsigned char *bwBuffer, int bwLx, int bwLy,
int bwWrap, bool isBW, TRasterGR8P &rout,
int mirror, int ninety) {
int x1 = 0;
int y1 = 0;
int x2 = bwLx - 1;
int y2 = bwLy - 1;
int newx = 0;
int newy = 0;
UCHAR *bufin, *bufout, /* *bytein,*/ *byteout;
int bytewrapin, bitoffsin, wrapout;
int value_for_0, value_for_1;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudy, dvdy, dudx, dvdx;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
assert(0);
return;
}
if (isBW) {
value_for_0 = 0;
value_for_1 = 255;
} else {
value_for_0 = 255;
value_for_1 = 0;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = bwBuffer;
bytewrapin = (bwWrap + 7) >> 3;
bitoffsin = 0; // rin->bit_offs;
bufout = rout->getRawData();
wrapout = rout->getWrap();
dudx = 0;
dudy = 0;
dvdx = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
case (0 << 2) + 0:
u00 = u1;
v00 = v1;
dudx = 1;
dvdy = 1;
break;
case (0 << 2) + 1:
u00 = u1;
v00 = v1 + sv;
dudy = 1;
dvdx = -1;
break;
case (0 << 2) + 2:
u00 = u1 + su;
v00 = v1 + sv;
dudx = -1;
dvdy = -1;
break;
case (0 << 2) + 3:
u00 = u1 + su;
v00 = v1;
dudy = -1;
dvdx = 1;
break;
case (1 << 2) + 0:
u00 = u1 + su;
v00 = v1;
dudx = -1;
dvdy = 1;
break;
case (1 << 2) + 1:
u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dvdx = -1;
break;
case (1 << 2) + 2:
u00 = u1;
v00 = v1 + sv;
dudx = 1;
dvdy = -1;
break;
case (1 << 2) + 3:
u00 = u1;
v00 = v1;
dudy = 1;
dvdx = 1;
break;
default:
abort();
u00 = v00 = dudy = dvdx = 0;
}
if (dudx)
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; v0 += dvdy, y++) {
u = u0;
v = v0;
byteout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; u += dudx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*byteout++ = value_for_1;
else
*byteout++ = value_for_0;
}
}
else
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; u0 += dudy, y++) {
u = u0;
v = v0;
byteout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; v += dvdx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*byteout++ = value_for_1;
else
*byteout++ = value_for_0;
}
}
}
};

34
toonz/sources/tnzbase/tscanner/tscannerutil.h
View file

@ -1,34 +0,0 @@
#pragma once
#include <traster.h>
namespace TScannerUtil {
/* copia un rettangolo da rin a rout,
* specchiandolo orizzontalmente se mirror e' dispari,
* e poi ruotandolo del multiplo di novanta gradi specificato
* da ninety in senso antiorario
*
*/
void copyRGBBufferToTRaster32(unsigned char *rgbBuffer, int rgbLx, int rgbLy,
const TRaster32P &rout, bool internal);
void copyRGBBufferToTRasterGR8(unsigned char *rgbBuffer, int rgbLx, int rgbLy,
int rgbWrap, const TRasterGR8P &rout);
void copyGR8BufferToTRasterGR8(unsigned char *gr8Buffer, int rgbLx, int rgbLy,
const TRasterGR8P &rout, bool internal);
void copyGR8BufferToTRasterBW(unsigned char *gr8Buffer, int rgbLx, int rgbLy,
const TRasterGR8P &rout, bool internal,
float thres);
void copyBWBufferToTRasterGR8(const unsigned char *buffer, int rgbLx, int rgbLy,
const TRasterGR8P &rout, bool isBW,
bool internal);
void copy90BWBufferToRasGR8(unsigned char *bwBuffer, int bwLx, int bwLy,
int bwWrap, bool isBW, TRasterGR8P &rout,
int mirror, int ninety);
};

2
toonz/sources/toonz/CMakeLists.txt
View file

@ -79,7 +79,6 @@ set(MOC_HEADERS
reslist.h
ruler.h
savepresetpopup.h
scanpopup.h
scenesettingspopup.h
sceneviewer.h
sceneviewercontextmenu.h
@ -260,7 +259,6 @@ set(SOURCES
renumberpopup.cpp
runscriptcommand.cpp
savepresetpopup.cpp
scanpopup.cpp
sceneviewercontextmenu.cpp
scenesettingspopup.cpp
scriptconsolepanel.cpp

1
toonz/sources/toonz/iocommand.cpp
View file

@ -1334,7 +1334,6 @@ void IoCmd::newScene() {
CleanupPreviewCheck::instance()->setIsEnabled(false);
CameraTestCheck::instance()->setIsEnabled(false);
SetScanCropboxCheck::instance()->setIsEnabled(false);
if (!TApp::instance()->isApplicationStarting())
QApplication::clipboard()->clear();

1
toonz/sources/toonz/levelcreatepopup.cpp
View file

@ -187,7 +187,6 @@ LevelCreatePopup::LevelCreatePopup()
m_levelTypeOm->addItem(tr("Vector Level"), (int)PLI_XSHLEVEL);
m_levelTypeOm->addItem(tr("Smart Raster Level"), (int)TZP_XSHLEVEL);
m_levelTypeOm->addItem(tr("Raster Level"), (int)OVL_XSHLEVEL);
m_levelTypeOm->addItem(tr("Scan Level"), (int)TZI_XSHLEVEL);
if (Preferences::instance()->getUnits() == "pixel") {
m_widthFld->setMeasure("camera.lx");

1
toonz/sources/toonz/main.cpp
View file

@ -78,6 +78,7 @@
#include <QSettings>
#include <QLibraryInfo>
#include <QHash>
#include <QPainterPath>
#ifdef _WIN32
#ifndef x64

43
toonz/sources/toonz/mainwindow.cpp
View file

@ -1902,27 +1902,11 @@ void MainWindow::defineActions() {
touchToggle->setEnabled(true);
touchToggle->setIcon(QIcon(":Resources/touch.svg"));
createMenuScanCleanupAction(MI_DefineScanner, tr("&Define Scanner..."), "");
createMenuScanCleanupAction(MI_ScanSettings, tr("&Scan Settings..."), "");
createMenuScanCleanupAction(MI_Scan, tr("&Scan"), "");
createMenuScanCleanupAction(MI_Autocenter, tr("&Autocenter..."), "");
QAction *toggle = createToggle(MI_SetScanCropbox, tr("&Set Cropbox"), "", 0,
MenuScanCleanupCommandType);
if (toggle) {
SetScanCropboxCheck::instance()->setToggle(toggle);
QString scannerType = QSettings().value("CurrentScannerType").toString();
if (scannerType == "TWAIN") toggle->setDisabled(true);
toggle = createMenuScanCleanupAction(MI_ResetScanCropbox,
tr("&Reset Cropbox"), "");
if (scannerType == "TWAIN") toggle->setDisabled(true);
}
createMenuScanCleanupAction(MI_CleanupSettings, tr("&Cleanup Settings..."),
"");
toggle = createToggle(MI_CleanupPreview, tr("&Preview Cleanup"), "", 0,
MenuScanCleanupCommandType);
QAction *toggle = createToggle(MI_CleanupPreview, tr("&Preview Cleanup"), "",
0, MenuScanCleanupCommandType);
CleanupPreviewCheck::instance()->setToggle(toggle);
toggle = createToggle(MI_CameraTest, tr("&Camera Test"), "", 0,
MenuScanCleanupCommandType);
@ -2421,7 +2405,8 @@ void MainWindow::defineActions() {
createToolAction(T_Plastic, "plastic", tr("Plastic Tool"), "X",
tr("Plastic Tool: Builds a mesh that allows to deform and "
"animate a level"));
createToolAction(T_Ruler, "ruler", tr("Ruler Tool"), "", tr("Ruler Tool: Measure distances on the canvas"));
createToolAction(T_Ruler, "ruler", tr("Ruler Tool"), "",
tr("Ruler Tool: Measure distances on the canvas"));
createToolAction(T_Finger, "finger", tr("Finger Tool"), "",
tr("Finger Tool: Smudges small areas to cover with line"));
@ -3333,7 +3318,7 @@ void MainWindow::clearCacheFolder() {
// 1. $CACHE/[Current ProcessID]
// 2. $CACHE/temp/[Current scene folder] if the current scene is untitled
TFilePath cacheRoot = ToonzFolder::getCacheRootFolder();
TFilePath cacheRoot = ToonzFolder::getCacheRootFolder();
if (cacheRoot.isEmpty()) cacheRoot = TEnv::getStuffDir() + "cache";
TFilePathSet filesToBeRemoved;
@ -3467,9 +3452,9 @@ RecentFiles::~RecentFiles() {}
void RecentFiles::addFilePath(QString path, FileType fileType,
QString projectName) {
QList<QString> files =
(fileType == Scene)
? m_recentScenes
: (fileType == Level) ? m_recentLevels : m_recentFlipbookImages;
(fileType == Scene) ? m_recentScenes : (fileType == Level)
? m_recentLevels
: m_recentFlipbookImages;
int i;
for (i = 0; i < files.size(); i++)
if (files.at(i) == path) {
@ -3636,9 +3621,9 @@ void RecentFiles::saveRecentFiles() {
QList<QString> RecentFiles::getFilesNameList(FileType fileType) {
QList<QString> files =
(fileType == Scene)
? m_recentScenes
: (fileType == Level) ? m_recentLevels : m_recentFlipbookImages;
(fileType == Scene) ? m_recentScenes : (fileType == Level)
? m_recentLevels
: m_recentFlipbookImages;
QList<QString> names;
int i;
for (i = 0; i < files.size(); i++) {
@ -3665,9 +3650,9 @@ void RecentFiles::refreshRecentFilesMenu(FileType fileType) {
menu->setEnabled(false);
else {
CommandId clearActionId =
(fileType == Scene)
? MI_ClearRecentScene
: (fileType == Level) ? MI_ClearRecentLevel : MI_ClearRecentImage;
(fileType == Scene) ? MI_ClearRecentScene : (fileType == Level)
? MI_ClearRecentLevel
: MI_ClearRecentImage;
menu->setActions(names);
menu->addSeparator();
QAction *clearAction = CommandManager::instance()->getAction(clearActionId);

28
toonz/sources/toonz/menubar.cpp
View file

@ -453,25 +453,6 @@ QMenuBar *StackedMenuBar::createFullMenuBar() {
addMenuItem(arrangeMenu, MI_SendBackward);
}
// Menu' SCAN CLEANUP
QMenu *scanCleanupMenu = addMenu(tr("Scan && Cleanup"), fullMenuBar);
addMenuItem(scanCleanupMenu, MI_DefineScanner);
addMenuItem(scanCleanupMenu, MI_ScanSettings);
addMenuItem(scanCleanupMenu, MI_Scan);
addMenuItem(scanCleanupMenu, MI_SetScanCropbox);
addMenuItem(scanCleanupMenu, MI_ResetScanCropbox);
scanCleanupMenu->addSeparator();
addMenuItem(scanCleanupMenu, MI_CleanupSettings);
addMenuItem(scanCleanupMenu, MI_CleanupPreview);
addMenuItem(scanCleanupMenu, MI_CameraTest);
addMenuItem(scanCleanupMenu, MI_Cleanup);
scanCleanupMenu->addSeparator();
addMenuItem(scanCleanupMenu, MI_PencilTest);
#ifdef LINETEST
scanCleanupMenu->addSeparator();
addMenuItem(scanCleanupMenu, MI_Autocenter);
#endif
// Menu' LEVEL
QMenu *levelMenu = addMenu(tr("Level"), fullMenuBar);
QMenu *newMenu = levelMenu->addMenu(tr("New"));
@ -645,6 +626,15 @@ QMenuBar *StackedMenuBar::createFullMenuBar() {
renderMenu->addSeparator();
addMenuItem(renderMenu, MI_FastRender);
// Menu' SCAN CLEANUP
QMenu* scanCleanupMenu = addMenu(tr("Cleanup"), fullMenuBar);
addMenuItem(scanCleanupMenu, MI_CleanupSettings);
addMenuItem(scanCleanupMenu, MI_CleanupPreview);
addMenuItem(scanCleanupMenu, MI_CameraTest);
addMenuItem(scanCleanupMenu, MI_Cleanup);
scanCleanupMenu->addSeparator();
addMenuItem(scanCleanupMenu, MI_PencilTest);
// Menu' VIEW
QMenu *viewMenu = addMenu(tr("View"), fullMenuBar);
addMenuItem(viewMenu, MI_ViewTable);

6
toonz/sources/toonz/menubarcommandids.h
View file

@ -64,12 +64,6 @@
#define MI_Undo "MI_Undo"
#define MI_Redo "MI_Redo"
#define MI_DefineScanner "MI_DefineScanner"
#define MI_ScanSettings "MI_ScanSettings"
#define MI_Scan "MI_Scan"
#define MI_Autocenter "MI_Autocenter"
#define MI_SetScanCropbox "MI_SetScanCropbox"
#define MI_ResetScanCropbox "MI_ResetScanCropbox"
#define MI_CleanupSettings "MI_CleanupSettings"
#define MI_CleanupPreview "MI_CleanupPreview"
#define MI_CameraTest "MI_CameraTest"

1211
toonz/sources/toonz/scanpopup.cpp
View file

File diff suppressed because it is too large Load diff

120
toonz/sources/toonz/scanpopup.h
View file

@ -1,120 +0,0 @@
#pragma once
#ifndef SCANPOPUP_H
#define SCANPOPUP_H
#include "toonzqt/dvdialog.h"
#include "tscanner.h"
#include "scanlist.h"
// forward declaration
namespace DVGui {
class DoubleField;
class IntField;
class CheckBox;
}
class QComboBox;
class ProgressDialog;
//=============================================================================
// MyScannerListener
//-----------------------------------------------------------------------------
class MyScannerListener final : public QObject, public TScannerListener {
Q_OBJECT
int m_current;
int m_inc;
ScanList m_scanList;
bool m_isCanceled, m_isPreview;
DVGui::ProgressDialog *m_progressDialog;
public:
MyScannerListener(const ScanList &scanList);
void onImage(const TRasterImageP &) override;
void onError() override;
void onNextPaper() override;
void onAutomaticallyNextPaper() override;
bool isCanceled() override;
protected slots:
void cancelButtonPressed();
};
//=============================================================================
// DefineScannerPopup
//-----------------------------------------------------------------------------
class DefineScannerPopup final : public DVGui::Dialog {
Q_OBJECT
QComboBox *m_scanDriverOm;
public:
DefineScannerPopup();
public slots:
void accept() override;
};
//=============================================================================
// ScanSettingsPopup
//-----------------------------------------------------------------------------
class ScanSettingsPopup final : public DVGui::Dialog {
Q_OBJECT
QLabel *m_scannerNameLbl;
DVGui::CheckBox *m_reverseOrderCB;
DVGui::CheckBox *m_paperFeederCB;
QComboBox *m_modeOm;
DVGui::DoubleField *m_dpi;
DVGui::IntField *m_threshold;
DVGui::IntField *m_brightness;
QComboBox *m_paperFormatOm;
QLabel *m_formatLbl;
QLabel *m_modeLbl;
QLabel *m_thresholdLbl;
QLabel *m_brightnessLbl;
QLabel *m_dpiLbl;
public:
ScanSettingsPopup();
protected:
void showEvent(QShowEvent *event) override;
void hideEvent(QHideEvent *event) override;
void connectAll();
void disconnectAll();
public slots:
void updateUI();
void onToggle(int);
void onPaperChanged(const QString &format);
void onValueChanged(bool);
void onModeChanged(const QString &mode);
};
#ifdef LINETEST
//=============================================================================
// AutocenterPopup
//-----------------------------------------------------------------------------
class AutocenterPopup final : public DVGui::Dialog {
Q_OBJECT
DVGui::CheckBox *m_autocenter;
QComboBox *m_pegbarHoles;
QComboBox *m_fieldGuide;
public:
AutocenterPopup();
protected:
void showEvent(QShowEvent *event);
protected slots:
void onAutocenterToggled(bool);
void onPegbarHolesChanged(const QString &);
void onFieldGuideChanged(const QString &);
};
#endif // LINETEST
#endif // SCANPOPUP_H

10
toonz/sources/toonzlib/sceneproperties.cpp
View file

@ -15,7 +15,6 @@
// TnzBase includes
#include "toutputproperties.h"
#include "trasterfx.h"
#include "tscanner.h"
// TnzCore includes
#include "tstream.h"
@ -27,7 +26,6 @@
TSceneProperties::TSceneProperties()
: m_cleanupParameters(new CleanupParameters())
, m_scanParameters(new TScannerParameters())
, m_vectorizerParameters(new VectorizerParameters())
, m_captureParameters(new CaptureParameters())
, m_outputProp(new TOutputProperties())
@ -55,7 +53,6 @@ TSceneProperties::TSceneProperties()
TSceneProperties::~TSceneProperties() {
delete m_cleanupParameters;
delete m_scanParameters;
delete m_vectorizerParameters;
delete m_captureParameters;
clearPointerContainer(m_cameras);
@ -74,7 +71,6 @@ void TSceneProperties::assign(const TSceneProperties *sprop) {
*m_previewProp = *sprop->m_previewProp;
m_cleanupParameters->assign(sprop->m_cleanupParameters);
m_scanParameters->assign(sprop->m_scanParameters);
assert(sprop->m_vectorizerParameters);
*m_vectorizerParameters = *sprop->m_vectorizerParameters;
@ -303,9 +299,6 @@ void TSceneProperties::saveData(TOStream &os) const {
os.openChild("cleanupParameters");
m_cleanupParameters->saveData(os);
os.closeChild();
os.openChild("scanParameters");
m_scanParameters->saveData(os);
os.closeChild();
os.openChild("vectorizerParameters");
m_vectorizerParameters->saveData(os);
os.closeChild();
@ -681,9 +674,6 @@ void TSceneProperties::loadData(TIStream &is, bool isLoadingProject) {
m_cleanupParameters->m_cleanupPalette->loadData(is);
} else if (tagName == "cleanupParameters") {
m_cleanupParameters->loadData(is, !isLoadingProject);
} else if (tagName == "scanParameters") {
// m_scanParameters->adaptToCurrentScanner(); Rallenta tutto!!!
m_scanParameters->loadData(is);
} else if (tagName == "vectorizerParameters") {
m_vectorizerParameters->loadData(is);
} else if (tagName == "captureParameters") {

36
toonz/sources/toonzlib/stage2.cpp
View file

@ -114,39 +114,3 @@ void CleanupPreviewCheck::setIsEnabled(bool on) {
//-----------------------------------------------------------------------------
void CleanupPreviewCheck::setToggle(QAction *toggle) { m_toggle = toggle; }
//=============================================================================
/*! \class SetScanCropBoxCheck
\brief The SetScanCropBoxCheck class allows visualization in
"Set Crop Box" mode, from scan menu
*/
//=============================================================================
SetScanCropboxCheck::SetScanCropboxCheck() : m_enabled(false), m_toggle(0) {}
//-----------------------------------------------------------------------------
/*! Return current \b SetScanCropBoxCheck instance.
*/
SetScanCropboxCheck *SetScanCropboxCheck::instance() {
static SetScanCropboxCheck _instance;
return &_instance;
}
//-----------------------------------------------------------------------------
void SetScanCropboxCheck::setToggle(QAction *toggle) { m_toggle = toggle; }
//-----------------------------------------------------------------------------
void SetScanCropboxCheck::setIsEnabled(bool on) {
if (!m_toggle) return;
m_enabled = on;
m_toggle->setChecked(on);
}
//-----------------------------------------------------------------------------
void SetScanCropboxCheck::uncheck() {
if (isEnabled()) m_toggle->trigger();
}

1
toonz/sources/toonzqt/paramfield.cpp
View file

@ -22,6 +22,7 @@
#include <QComboBox>
#include <QFontComboBox>
#include <QKeyEvent>
#include <QPainterPath>
using namespace DVGui;