From 69a9026b455c5f108aa0c1b5c1302d6a705c2a34 Mon Sep 17 00:00:00 2001 From: gb <741021719@qq.com> Date: Tue, 28 Jun 2022 17:16:03 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E6=96=87=E4=BB=B6=E6=A0=BC?= =?UTF-8?q?=E5=BC=8F=E8=BD=AC=E6=8D=A2=E6=8E=A5=E5=8F=A3=EF=BC=9B=E6=B7=BB?= =?UTF-8?q?=E5=8A=A0=E9=BB=91=E7=99=BD=E5=9B=BE=E5=83=8F=E9=98=88=E5=80=BC?= =?UTF-8?q?=E5=B1=9E=E6=80=A7=EF=BC=9B=E6=9B=B4=E6=94=B9=E5=B1=9E=E6=80=A7?= =?UTF-8?q?=E5=87=BD=E6=95=B0=E8=B0=83=E7=94=A8=E6=96=B9=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- hgdriver/3rdparty/tiff/include/tiff.h | 695 ++++++++++++++++++++++ hgdriver/3rdparty/tiff/include/tiffconf.h | 121 ++++ hgdriver/3rdparty/tiff/include/tiffio.h | 568 ++++++++++++++++++ hgdriver/3rdparty/tiff/include/tiffvers.h | 9 + hgdriver/ImageProcess/G4Tiff.cpp | 178 ++++++ hgdriver/ImageProcess/G4Tiff.h | 41 ++ hgdriver/hgdev/hg_ipc.cpp | 18 + hgdriver/hgdev/hg_ipc.h | 7 + hgdriver/hgdev/hg_scanner.cpp | 476 +++++++-------- hgdriver/hgdev/hg_scanner.h | 195 +++--- hgdriver/hgdev/hg_scanner_200.cpp | 63 -- hgdriver/hgdev/hg_scanner_200.h | 1 - hgdriver/hgdev/hg_scanner_239.cpp | 66 +- hgdriver/hgdev/hg_scanner_239.h | 3 +- hgdriver/hgdev/hg_scanner_300.cpp | 60 -- hgdriver/hgdev/hg_scanner_300.h | 1 - hgdriver/hgdev/hg_scanner_400.cpp | 60 -- hgdriver/hgdev/hg_scanner_400.h | 1 - hgdriver/hgdev/image_process.cpp | 178 ++++++ hgdriver/hgdev/image_process.h | 5 + 20 files changed, 2117 insertions(+), 629 deletions(-) create mode 100644 hgdriver/3rdparty/tiff/include/tiff.h create mode 100644 hgdriver/3rdparty/tiff/include/tiffconf.h create mode 100644 hgdriver/3rdparty/tiff/include/tiffio.h create mode 100644 hgdriver/3rdparty/tiff/include/tiffvers.h create mode 100644 hgdriver/ImageProcess/G4Tiff.cpp create mode 100644 hgdriver/ImageProcess/G4Tiff.h diff --git a/hgdriver/3rdparty/tiff/include/tiff.h b/hgdriver/3rdparty/tiff/include/tiff.h new file mode 100644 index 0000000..5b0a0c9 --- /dev/null +++ b/hgdriver/3rdparty/tiff/include/tiff.h @@ -0,0 +1,695 @@ +/* + * Copyright (c) 1988-1997 Sam Leffler + * Copyright (c) 1991-1997 Silicon Graphics, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that (i) the above copyright notices and this permission notice appear in + * all copies of the software and related documentation, and (ii) the names of + * Sam Leffler and Silicon Graphics may not be used in any advertising or + * publicity relating to the software without the specific, prior written + * permission of Sam Leffler and Silicon Graphics. + * + * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, + * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY + * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. + * + * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR + * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, + * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, + * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF + * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#ifndef _TIFF_ +#define _TIFF_ + +#include "tiffconf.h" + +/* + * Tag Image File Format (TIFF) + * + * Based on Rev 6.0 from: + * Developer's Desk + * Aldus Corporation + * 411 First Ave. South + * Suite 200 + * Seattle, WA 98104 + * 206-622-5500 + * + * (http://partners.adobe.com/asn/developer/PDFS/TN/TIFF6.pdf) + * + * For BigTIFF design notes see the following links + * http://www.remotesensing.org/libtiff/bigtiffdesign.html + * http://www.awaresystems.be/imaging/tiff/bigtiff.html + */ + +#define TIFF_VERSION_CLASSIC 42 +#define TIFF_VERSION_BIG 43 + +#define TIFF_BIGENDIAN 0x4d4d +#define TIFF_LITTLEENDIAN 0x4949 +#define MDI_LITTLEENDIAN 0x5045 +#define MDI_BIGENDIAN 0x4550 + +/* + * Intrinsic data types required by the file format: + * + * 8-bit quantities int8/uint8 + * 16-bit quantities int16/uint16 + * 32-bit quantities int32/uint32 + * 64-bit quantities int64/uint64 + * strings unsigned char* + */ + +typedef TIFF_INT8_T int8; +typedef TIFF_UINT8_T uint8; + +typedef TIFF_INT16_T int16; +typedef TIFF_UINT16_T uint16; + +typedef TIFF_INT32_T int32; +typedef TIFF_UINT32_T uint32; + +typedef TIFF_INT64_T int64; +typedef TIFF_UINT64_T uint64; + +/* + * Some types as promoted in a variable argument list + * We use uint16_vap rather then directly using int, because this way + * we document the type we actually want to pass through, conceptually, + * rather then confusing the issue by merely stating the type it gets + * promoted to + */ + +typedef int uint16_vap; + +/* + * TIFF header. + */ +typedef struct { + uint16 tiff_magic; /* magic number (defines byte order) */ + uint16 tiff_version; /* TIFF version number */ +} TIFFHeaderCommon; +typedef struct { + uint16 tiff_magic; /* magic number (defines byte order) */ + uint16 tiff_version; /* TIFF version number */ + uint32 tiff_diroff; /* byte offset to first directory */ +} TIFFHeaderClassic; +typedef struct { + uint16 tiff_magic; /* magic number (defines byte order) */ + uint16 tiff_version; /* TIFF version number */ + uint16 tiff_offsetsize; /* size of offsets, should be 8 */ + uint16 tiff_unused; /* unused word, should be 0 */ + uint64 tiff_diroff; /* byte offset to first directory */ +} TIFFHeaderBig; + + +/* + * NB: In the comments below, + * - items marked with a + are obsoleted by revision 5.0, + * - items marked with a ! are introduced in revision 6.0. + * - items marked with a % are introduced post revision 6.0. + * - items marked with a $ are obsoleted by revision 6.0. + * - items marked with a & are introduced by Adobe DNG specification. + */ + +/* + * Tag data type information. + * + * Note: RATIONALs are the ratio of two 32-bit integer values. + */ +typedef enum { + TIFF_NOTYPE = 0, /* placeholder */ + TIFF_BYTE = 1, /* 8-bit unsigned integer */ + TIFF_ASCII = 2, /* 8-bit bytes w/ last byte null */ + TIFF_SHORT = 3, /* 16-bit unsigned integer */ + TIFF_LONG = 4, /* 32-bit unsigned integer */ + TIFF_RATIONAL = 5, /* 64-bit unsigned fraction */ + TIFF_SBYTE = 6, /* !8-bit signed integer */ + TIFF_UNDEFINED = 7, /* !8-bit untyped data */ + TIFF_SSHORT = 8, /* !16-bit signed integer */ + TIFF_SLONG = 9, /* !32-bit signed integer */ + TIFF_SRATIONAL = 10, /* !64-bit signed fraction */ + TIFF_FLOAT = 11, /* !32-bit IEEE floating point */ + TIFF_DOUBLE = 12, /* !64-bit IEEE floating point */ + TIFF_IFD = 13, /* %32-bit unsigned integer (offset) */ + TIFF_LONG8 = 16, /* BigTIFF 64-bit unsigned integer */ + TIFF_SLONG8 = 17, /* BigTIFF 64-bit signed integer */ + TIFF_IFD8 = 18 /* BigTIFF 64-bit unsigned integer (offset) */ +} TIFFDataType; + +/* + * TIFF Tag Definitions. + */ +#define TIFFTAG_SUBFILETYPE 254 /* subfile data descriptor */ +#define FILETYPE_REDUCEDIMAGE 0x1 /* reduced resolution version */ +#define FILETYPE_PAGE 0x2 /* one page of many */ +#define FILETYPE_MASK 0x4 /* transparency mask */ +#define TIFFTAG_OSUBFILETYPE 255 /* +kind of data in subfile */ +#define OFILETYPE_IMAGE 1 /* full resolution image data */ +#define OFILETYPE_REDUCEDIMAGE 2 /* reduced size image data */ +#define OFILETYPE_PAGE 3 /* one page of many */ +#define TIFFTAG_IMAGEWIDTH 256 /* image width in pixels */ +#define TIFFTAG_IMAGELENGTH 257 /* image height in pixels */ +#define TIFFTAG_BITSPERSAMPLE 258 /* bits per channel (sample) */ +#define TIFFTAG_COMPRESSION 259 /* data compression technique */ +#define COMPRESSION_NONE 1 /* dump mode */ +#define COMPRESSION_CCITTRLE 2 /* CCITT modified Huffman RLE */ +#define COMPRESSION_CCITTFAX3 3 /* CCITT Group 3 fax encoding */ +#define COMPRESSION_CCITT_T4 3 /* CCITT T.4 (TIFF 6 name) */ +#define COMPRESSION_CCITTFAX4 4 /* CCITT Group 4 fax encoding */ +#define COMPRESSION_CCITT_T6 4 /* CCITT T.6 (TIFF 6 name) */ +#define COMPRESSION_LZW 5 /* Lempel-Ziv & Welch */ +#define COMPRESSION_OJPEG 6 /* !6.0 JPEG */ +#define COMPRESSION_JPEG 7 /* %JPEG DCT compression */ +#define COMPRESSION_T85 9 /* !TIFF/FX T.85 JBIG compression */ +#define COMPRESSION_T43 10 /* !TIFF/FX T.43 colour by layered JBIG compression */ +#define COMPRESSION_NEXT 32766 /* NeXT 2-bit RLE */ +#define COMPRESSION_CCITTRLEW 32771 /* #1 w/ word alignment */ +#define COMPRESSION_PACKBITS 32773 /* Macintosh RLE */ +#define COMPRESSION_THUNDERSCAN 32809 /* ThunderScan RLE */ +/* codes 32895-32898 are reserved for ANSI IT8 TIFF/IT */ +#define COMPRESSION_DCS 32947 /* Kodak DCS encoding */ +#define COMPRESSION_JBIG 34661 /* ISO JBIG */ +#define COMPRESSION_SGILOG 34676 /* SGI Log Luminance RLE */ +#define COMPRESSION_SGILOG24 34677 /* SGI Log 24-bit packed */ +#define COMPRESSION_JP2000 34712 /* Leadtools JPEG2000 */ +#define COMPRESSION_LERC 34887 /* ESRI Lerc codec: https://github.com/Esri/lerc */ +/* compression codes 34887-34889 are reserved for ESRI */ +#define COMPRESSION_LZMA 34925 /* LZMA2 */ +#define COMPRESSION_ZSTD 50000 /* ZSTD: WARNING not registered in Adobe-maintained registry */ +#define COMPRESSION_WEBP 50001 /* WEBP: WARNING not registered in Adobe-maintained registry */ +#define TIFFTAG_PHOTOMETRIC 262 /* photometric interpretation */ +#define PHOTOMETRIC_MINISWHITE 0 /* min value is white */ +#define PHOTOMETRIC_MINISBLACK 1 /* min value is black */ +#define PHOTOMETRIC_RGB 2 /* RGB color model */ +#define PHOTOMETRIC_PALETTE 3 /* color map indexed */ +#define PHOTOMETRIC_MASK 4 /* $holdout mask */ +#define PHOTOMETRIC_SEPARATED 5 /* !color separations */ +#define PHOTOMETRIC_YCBCR 6 /* !CCIR 601 */ +#define PHOTOMETRIC_CIELAB 8 /* !1976 CIE L*a*b* */ +#define PHOTOMETRIC_ICCLAB 9 /* ICC L*a*b* [Adobe TIFF Technote 4] */ +#define PHOTOMETRIC_ITULAB 10 /* ITU L*a*b* */ +#define PHOTOMETRIC_CFA 32803 /* color filter array */ +#define PHOTOMETRIC_LOGL 32844 /* CIE Log2(L) */ +#define PHOTOMETRIC_LOGLUV 32845 /* CIE Log2(L) (u',v') */ +#define TIFFTAG_THRESHHOLDING 263 /* +thresholding used on data */ +#define THRESHHOLD_BILEVEL 1 /* b&w art scan */ +#define THRESHHOLD_HALFTONE 2 /* or dithered scan */ +#define THRESHHOLD_ERRORDIFFUSE 3 /* usually floyd-steinberg */ +#define TIFFTAG_CELLWIDTH 264 /* +dithering matrix width */ +#define TIFFTAG_CELLLENGTH 265 /* +dithering matrix height */ +#define TIFFTAG_FILLORDER 266 /* data order within a byte */ +#define FILLORDER_MSB2LSB 1 /* most significant -> least */ +#define FILLORDER_LSB2MSB 2 /* least significant -> most */ +#define TIFFTAG_DOCUMENTNAME 269 /* name of doc. image is from */ +#define TIFFTAG_IMAGEDESCRIPTION 270 /* info about image */ +#define TIFFTAG_MAKE 271 /* scanner manufacturer name */ +#define TIFFTAG_MODEL 272 /* scanner model name/number */ +#define TIFFTAG_STRIPOFFSETS 273 /* offsets to data strips */ +#define TIFFTAG_ORIENTATION 274 /* +image orientation */ +#define ORIENTATION_TOPLEFT 1 /* row 0 top, col 0 lhs */ +#define ORIENTATION_TOPRIGHT 2 /* row 0 top, col 0 rhs */ +#define ORIENTATION_BOTRIGHT 3 /* row 0 bottom, col 0 rhs */ +#define ORIENTATION_BOTLEFT 4 /* row 0 bottom, col 0 lhs */ +#define ORIENTATION_LEFTTOP 5 /* row 0 lhs, col 0 top */ +#define ORIENTATION_RIGHTTOP 6 /* row 0 rhs, col 0 top */ +#define ORIENTATION_RIGHTBOT 7 /* row 0 rhs, col 0 bottom */ +#define ORIENTATION_LEFTBOT 8 /* row 0 lhs, col 0 bottom */ +#define TIFFTAG_SAMPLESPERPIXEL 277 /* samples per pixel */ +#define TIFFTAG_ROWSPERSTRIP 278 /* rows per strip of data */ +#define TIFFTAG_STRIPBYTECOUNTS 279 /* bytes counts for strips */ +#define TIFFTAG_MINSAMPLEVALUE 280 /* +minimum sample value */ +#define TIFFTAG_MAXSAMPLEVALUE 281 /* +maximum sample value */ +#define TIFFTAG_XRESOLUTION 282 /* pixels/resolution in x */ +#define TIFFTAG_YRESOLUTION 283 /* pixels/resolution in y */ +#define TIFFTAG_PLANARCONFIG 284 /* storage organization */ +#define PLANARCONFIG_CONTIG 1 /* single image plane */ +#define PLANARCONFIG_SEPARATE 2 /* separate planes of data */ +#define TIFFTAG_PAGENAME 285 /* page name image is from */ +#define TIFFTAG_XPOSITION 286 /* x page offset of image lhs */ +#define TIFFTAG_YPOSITION 287 /* y page offset of image lhs */ +#define TIFFTAG_FREEOFFSETS 288 /* +byte offset to free block */ +#define TIFFTAG_FREEBYTECOUNTS 289 /* +sizes of free blocks */ +#define TIFFTAG_GRAYRESPONSEUNIT 290 /* $gray scale curve accuracy */ +#define GRAYRESPONSEUNIT_10S 1 /* tenths of a unit */ +#define GRAYRESPONSEUNIT_100S 2 /* hundredths of a unit */ +#define GRAYRESPONSEUNIT_1000S 3 /* thousandths of a unit */ +#define GRAYRESPONSEUNIT_10000S 4 /* ten-thousandths of a unit */ +#define GRAYRESPONSEUNIT_100000S 5 /* hundred-thousandths */ +#define TIFFTAG_GRAYRESPONSECURVE 291 /* $gray scale response curve */ +#define TIFFTAG_GROUP3OPTIONS 292 /* 32 flag bits */ +#define TIFFTAG_T4OPTIONS 292 /* TIFF 6.0 proper name alias */ +#define GROUP3OPT_2DENCODING 0x1 /* 2-dimensional coding */ +#define GROUP3OPT_UNCOMPRESSED 0x2 /* data not compressed */ +#define GROUP3OPT_FILLBITS 0x4 /* fill to byte boundary */ +#define TIFFTAG_GROUP4OPTIONS 293 /* 32 flag bits */ +#define TIFFTAG_T6OPTIONS 293 /* TIFF 6.0 proper name */ +#define GROUP4OPT_UNCOMPRESSED 0x2 /* data not compressed */ +#define TIFFTAG_RESOLUTIONUNIT 296 /* units of resolutions */ +#define RESUNIT_NONE 1 /* no meaningful units */ +#define RESUNIT_INCH 2 /* english */ +#define RESUNIT_CENTIMETER 3 /* metric */ +#define TIFFTAG_PAGENUMBER 297 /* page numbers of multi-page */ +#define TIFFTAG_COLORRESPONSEUNIT 300 /* $color curve accuracy */ +#define COLORRESPONSEUNIT_10S 1 /* tenths of a unit */ +#define COLORRESPONSEUNIT_100S 2 /* hundredths of a unit */ +#define COLORRESPONSEUNIT_1000S 3 /* thousandths of a unit */ +#define COLORRESPONSEUNIT_10000S 4 /* ten-thousandths of a unit */ +#define COLORRESPONSEUNIT_100000S 5 /* hundred-thousandths */ +#define TIFFTAG_TRANSFERFUNCTION 301 /* !colorimetry info */ +#define TIFFTAG_SOFTWARE 305 /* name & release */ +#define TIFFTAG_DATETIME 306 /* creation date and time */ +#define TIFFTAG_ARTIST 315 /* creator of image */ +#define TIFFTAG_HOSTCOMPUTER 316 /* machine where created */ +#define TIFFTAG_PREDICTOR 317 /* prediction scheme w/ LZW */ +#define PREDICTOR_NONE 1 /* no prediction scheme used */ +#define PREDICTOR_HORIZONTAL 2 /* horizontal differencing */ +#define PREDICTOR_FLOATINGPOINT 3 /* floating point predictor */ +#define TIFFTAG_WHITEPOINT 318 /* image white point */ +#define TIFFTAG_PRIMARYCHROMATICITIES 319 /* !primary chromaticities */ +#define TIFFTAG_COLORMAP 320 /* RGB map for palette image */ +#define TIFFTAG_HALFTONEHINTS 321 /* !highlight+shadow info */ +#define TIFFTAG_TILEWIDTH 322 /* !tile width in pixels */ +#define TIFFTAG_TILELENGTH 323 /* !tile height in pixels */ +#define TIFFTAG_TILEOFFSETS 324 /* !offsets to data tiles */ +#define TIFFTAG_TILEBYTECOUNTS 325 /* !byte counts for tiles */ +#define TIFFTAG_BADFAXLINES 326 /* lines w/ wrong pixel count */ +#define TIFFTAG_CLEANFAXDATA 327 /* regenerated line info */ +#define CLEANFAXDATA_CLEAN 0 /* no errors detected */ +#define CLEANFAXDATA_REGENERATED 1 /* receiver regenerated lines */ +#define CLEANFAXDATA_UNCLEAN 2 /* uncorrected errors exist */ +#define TIFFTAG_CONSECUTIVEBADFAXLINES 328 /* max consecutive bad lines */ +#define TIFFTAG_SUBIFD 330 /* subimage descriptors */ +#define TIFFTAG_INKSET 332 /* !inks in separated image */ +#define INKSET_CMYK 1 /* !cyan-magenta-yellow-black color */ +#define INKSET_MULTIINK 2 /* !multi-ink or hi-fi color */ +#define TIFFTAG_INKNAMES 333 /* !ascii names of inks */ +#define TIFFTAG_NUMBEROFINKS 334 /* !number of inks */ +#define TIFFTAG_DOTRANGE 336 /* !0% and 100% dot codes */ +#define TIFFTAG_TARGETPRINTER 337 /* !separation target */ +#define TIFFTAG_EXTRASAMPLES 338 /* !info about extra samples */ +#define EXTRASAMPLE_UNSPECIFIED 0 /* !unspecified data */ +#define EXTRASAMPLE_ASSOCALPHA 1 /* !associated alpha data */ +#define EXTRASAMPLE_UNASSALPHA 2 /* !unassociated alpha data */ +#define TIFFTAG_SAMPLEFORMAT 339 /* !data sample format */ +#define SAMPLEFORMAT_UINT 1 /* !unsigned integer data */ +#define SAMPLEFORMAT_INT 2 /* !signed integer data */ +#define SAMPLEFORMAT_IEEEFP 3 /* !IEEE floating point data */ +#define SAMPLEFORMAT_VOID 4 /* !untyped data */ +#define SAMPLEFORMAT_COMPLEXINT 5 /* !complex signed int */ +#define SAMPLEFORMAT_COMPLEXIEEEFP 6 /* !complex ieee floating */ +#define TIFFTAG_SMINSAMPLEVALUE 340 /* !variable MinSampleValue */ +#define TIFFTAG_SMAXSAMPLEVALUE 341 /* !variable MaxSampleValue */ +#define TIFFTAG_CLIPPATH 343 /* %ClipPath + [Adobe TIFF technote 2] */ +#define TIFFTAG_XCLIPPATHUNITS 344 /* %XClipPathUnits + [Adobe TIFF technote 2] */ +#define TIFFTAG_YCLIPPATHUNITS 345 /* %YClipPathUnits + [Adobe TIFF technote 2] */ +#define TIFFTAG_INDEXED 346 /* %Indexed + [Adobe TIFF Technote 3] */ +#define TIFFTAG_JPEGTABLES 347 /* %JPEG table stream */ +#define TIFFTAG_OPIPROXY 351 /* %OPI Proxy [Adobe TIFF technote] */ +/* Tags 400-435 are from the TIFF/FX spec */ +#define TIFFTAG_GLOBALPARAMETERSIFD 400 /* ! */ +#define TIFFTAG_PROFILETYPE 401 /* ! */ +#define PROFILETYPE_UNSPECIFIED 0 /* ! */ +#define PROFILETYPE_G3_FAX 1 /* ! */ +#define TIFFTAG_FAXPROFILE 402 /* ! */ +#define FAXPROFILE_S 1 /* !TIFF/FX FAX profile S */ +#define FAXPROFILE_F 2 /* !TIFF/FX FAX profile F */ +#define FAXPROFILE_J 3 /* !TIFF/FX FAX profile J */ +#define FAXPROFILE_C 4 /* !TIFF/FX FAX profile C */ +#define FAXPROFILE_L 5 /* !TIFF/FX FAX profile L */ +#define FAXPROFILE_M 6 /* !TIFF/FX FAX profile LM */ +#define TIFFTAG_CODINGMETHODS 403 /* !TIFF/FX coding methods */ +#define CODINGMETHODS_T4_1D (1 << 1) /* !T.4 1D */ +#define CODINGMETHODS_T4_2D (1 << 2) /* !T.4 2D */ +#define CODINGMETHODS_T6 (1 << 3) /* !T.6 */ +#define CODINGMETHODS_T85 (1 << 4) /* !T.85 JBIG */ +#define CODINGMETHODS_T42 (1 << 5) /* !T.42 JPEG */ +#define CODINGMETHODS_T43 (1 << 6) /* !T.43 colour by layered JBIG */ +#define TIFFTAG_VERSIONYEAR 404 /* !TIFF/FX version year */ +#define TIFFTAG_MODENUMBER 405 /* !TIFF/FX mode number */ +#define TIFFTAG_DECODE 433 /* !TIFF/FX decode */ +#define TIFFTAG_IMAGEBASECOLOR 434 /* !TIFF/FX image base colour */ +#define TIFFTAG_T82OPTIONS 435 /* !TIFF/FX T.82 options */ +/* + * Tags 512-521 are obsoleted by Technical Note #2 which specifies a + * revised JPEG-in-TIFF scheme. + */ +#define TIFFTAG_JPEGPROC 512 /* !JPEG processing algorithm */ +#define JPEGPROC_BASELINE 1 /* !baseline sequential */ +#define JPEGPROC_LOSSLESS 14 /* !Huffman coded lossless */ +#define TIFFTAG_JPEGIFOFFSET 513 /* !pointer to SOI marker */ +#define TIFFTAG_JPEGIFBYTECOUNT 514 /* !JFIF stream length */ +#define TIFFTAG_JPEGRESTARTINTERVAL 515 /* !restart interval length */ +#define TIFFTAG_JPEGLOSSLESSPREDICTORS 517 /* !lossless proc predictor */ +#define TIFFTAG_JPEGPOINTTRANSFORM 518 /* !lossless point transform */ +#define TIFFTAG_JPEGQTABLES 519 /* !Q matrix offsets */ +#define TIFFTAG_JPEGDCTABLES 520 /* !DCT table offsets */ +#define TIFFTAG_JPEGACTABLES 521 /* !AC coefficient offsets */ +#define TIFFTAG_YCBCRCOEFFICIENTS 529 /* !RGB -> YCbCr transform */ +#define TIFFTAG_YCBCRSUBSAMPLING 530 /* !YCbCr subsampling factors */ +#define TIFFTAG_YCBCRPOSITIONING 531 /* !subsample positioning */ +#define YCBCRPOSITION_CENTERED 1 /* !as in PostScript Level 2 */ +#define YCBCRPOSITION_COSITED 2 /* !as in CCIR 601-1 */ +#define TIFFTAG_REFERENCEBLACKWHITE 532 /* !colorimetry info */ +#define TIFFTAG_STRIPROWCOUNTS 559 /* !TIFF/FX strip row counts */ +#define TIFFTAG_XMLPACKET 700 /* %XML packet + [Adobe XMP Specification, + January 2004 */ +#define TIFFTAG_OPIIMAGEID 32781 /* %OPI ImageID + [Adobe TIFF technote] */ +/* tags 32952-32956 are private tags registered to Island Graphics */ +#define TIFFTAG_REFPTS 32953 /* image reference points */ +#define TIFFTAG_REGIONTACKPOINT 32954 /* region-xform tack point */ +#define TIFFTAG_REGIONWARPCORNERS 32955 /* warp quadrilateral */ +#define TIFFTAG_REGIONAFFINE 32956 /* affine transformation mat */ +/* tags 32995-32999 are private tags registered to SGI */ +#define TIFFTAG_MATTEING 32995 /* $use ExtraSamples */ +#define TIFFTAG_DATATYPE 32996 /* $use SampleFormat */ +#define TIFFTAG_IMAGEDEPTH 32997 /* z depth of image */ +#define TIFFTAG_TILEDEPTH 32998 /* z depth/data tile */ +/* tags 33300-33309 are private tags registered to Pixar */ +/* + * TIFFTAG_PIXAR_IMAGEFULLWIDTH and TIFFTAG_PIXAR_IMAGEFULLLENGTH + * are set when an image has been cropped out of a larger image. + * They reflect the size of the original uncropped image. + * The TIFFTAG_XPOSITION and TIFFTAG_YPOSITION can be used + * to determine the position of the smaller image in the larger one. + */ +#define TIFFTAG_PIXAR_IMAGEFULLWIDTH 33300 /* full image size in x */ +#define TIFFTAG_PIXAR_IMAGEFULLLENGTH 33301 /* full image size in y */ + /* Tags 33302-33306 are used to identify special image modes and data + * used by Pixar's texture formats. + */ +#define TIFFTAG_PIXAR_TEXTUREFORMAT 33302 /* texture map format */ +#define TIFFTAG_PIXAR_WRAPMODES 33303 /* s & t wrap modes */ +#define TIFFTAG_PIXAR_FOVCOT 33304 /* cotan(fov) for env. maps */ +#define TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN 33305 +#define TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA 33306 +/* tag 33405 is a private tag registered to Eastman Kodak */ +#define TIFFTAG_WRITERSERIALNUMBER 33405 /* device serial number */ +#define TIFFTAG_CFAREPEATPATTERNDIM 33421 /* dimensions of CFA pattern */ +#define TIFFTAG_CFAPATTERN 33422 /* color filter array pattern */ +/* tag 33432 is listed in the 6.0 spec w/ unknown ownership */ +#define TIFFTAG_COPYRIGHT 33432 /* copyright string */ +/* IPTC TAG from RichTIFF specifications */ +#define TIFFTAG_RICHTIFFIPTC 33723 +/* 34016-34029 are reserved for ANSI IT8 TIFF/IT */ +#define TIFFTAG_STONITS 37439 /* Sample value to Nits */ +/* tag 34929 is a private tag registered to FedEx */ +#define TIFFTAG_FEDEX_EDR 34929 /* unknown use */ +#define TIFFTAG_INTEROPERABILITYIFD 40965 /* Pointer to Interoperability private directory */ +/* tags 50674 to 50677 are reserved for ESRI */ +#define TIFFTAG_LERC_PARAMETERS 50674 /* Stores LERC version and additional compression method */ +/* Adobe Digital Negative (DNG) format tags */ +#define TIFFTAG_DNGVERSION 50706 /* &DNG version number */ +#define TIFFTAG_DNGBACKWARDVERSION 50707 /* &DNG compatibility version */ +#define TIFFTAG_UNIQUECAMERAMODEL 50708 /* &name for the camera model */ +#define TIFFTAG_LOCALIZEDCAMERAMODEL 50709 /* &localized camera model + name */ +#define TIFFTAG_CFAPLANECOLOR 50710 /* &CFAPattern->LinearRaw space + mapping */ +#define TIFFTAG_CFALAYOUT 50711 /* &spatial layout of the CFA */ +#define TIFFTAG_LINEARIZATIONTABLE 50712 /* &lookup table description */ +#define TIFFTAG_BLACKLEVELREPEATDIM 50713 /* &repeat pattern size for + the BlackLevel tag */ +#define TIFFTAG_BLACKLEVEL 50714 /* &zero light encoding level */ +#define TIFFTAG_BLACKLEVELDELTAH 50715 /* &zero light encoding level + differences (columns) */ +#define TIFFTAG_BLACKLEVELDELTAV 50716 /* &zero light encoding level + differences (rows) */ +#define TIFFTAG_WHITELEVEL 50717 /* &fully saturated encoding + level */ +#define TIFFTAG_DEFAULTSCALE 50718 /* &default scale factors */ +#define TIFFTAG_DEFAULTCROPORIGIN 50719 /* &origin of the final image + area */ +#define TIFFTAG_DEFAULTCROPSIZE 50720 /* &size of the final image + area */ +#define TIFFTAG_COLORMATRIX1 50721 /* &XYZ->reference color space + transformation matrix 1 */ +#define TIFFTAG_COLORMATRIX2 50722 /* &XYZ->reference color space + transformation matrix 2 */ +#define TIFFTAG_CAMERACALIBRATION1 50723 /* &calibration matrix 1 */ +#define TIFFTAG_CAMERACALIBRATION2 50724 /* &calibration matrix 2 */ +#define TIFFTAG_REDUCTIONMATRIX1 50725 /* &dimensionality reduction + matrix 1 */ +#define TIFFTAG_REDUCTIONMATRIX2 50726 /* &dimensionality reduction + matrix 2 */ +#define TIFFTAG_ANALOGBALANCE 50727 /* &gain applied the stored raw + values*/ +#define TIFFTAG_ASSHOTNEUTRAL 50728 /* &selected white balance in + linear reference space */ +#define TIFFTAG_ASSHOTWHITEXY 50729 /* &selected white balance in + x-y chromaticity + coordinates */ +#define TIFFTAG_BASELINEEXPOSURE 50730 /* &how much to move the zero + point */ +#define TIFFTAG_BASELINENOISE 50731 /* &relative noise level */ +#define TIFFTAG_BASELINESHARPNESS 50732 /* &relative amount of + sharpening */ +#define TIFFTAG_BAYERGREENSPLIT 50733 /* &how closely the values of + the green pixels in the + blue/green rows track the + values of the green pixels + in the red/green rows */ +#define TIFFTAG_LINEARRESPONSELIMIT 50734 /* &non-linear encoding range */ +#define TIFFTAG_CAMERASERIALNUMBER 50735 /* &camera's serial number */ +#define TIFFTAG_LENSINFO 50736 /* info about the lens */ +#define TIFFTAG_CHROMABLURRADIUS 50737 /* &chroma blur radius */ +#define TIFFTAG_ANTIALIASSTRENGTH 50738 /* &relative strength of the + camera's anti-alias filter */ +#define TIFFTAG_SHADOWSCALE 50739 /* &used by Adobe Camera Raw */ +#define TIFFTAG_DNGPRIVATEDATA 50740 /* &manufacturer's private data */ +#define TIFFTAG_MAKERNOTESAFETY 50741 /* &whether the EXIF MakerNote + tag is safe to preserve + along with the rest of the + EXIF data */ +#define TIFFTAG_CALIBRATIONILLUMINANT1 50778 /* &illuminant 1 */ +#define TIFFTAG_CALIBRATIONILLUMINANT2 50779 /* &illuminant 2 */ +#define TIFFTAG_BESTQUALITYSCALE 50780 /* &best quality multiplier */ +#define TIFFTAG_RAWDATAUNIQUEID 50781 /* &unique identifier for + the raw image data */ +#define TIFFTAG_ORIGINALRAWFILENAME 50827 /* &file name of the original + raw file */ +#define TIFFTAG_ORIGINALRAWFILEDATA 50828 /* &contents of the original + raw file */ +#define TIFFTAG_ACTIVEAREA 50829 /* &active (non-masked) pixels + of the sensor */ +#define TIFFTAG_MASKEDAREAS 50830 /* &list of coordinates + of fully masked pixels */ +#define TIFFTAG_ASSHOTICCPROFILE 50831 /* &these two tags used to */ +#define TIFFTAG_ASSHOTPREPROFILEMATRIX 50832 /* map cameras's color space + into ICC profile space */ +#define TIFFTAG_CURRENTICCPROFILE 50833 /* & */ +#define TIFFTAG_CURRENTPREPROFILEMATRIX 50834 /* & */ +/* tag 65535 is an undefined tag used by Eastman Kodak */ +#define TIFFTAG_DCSHUESHIFTVALUES 65535 /* hue shift correction data */ + +/* + * The following are ``pseudo tags'' that can be used to control + * codec-specific functionality. These tags are not written to file. + * Note that these values start at 0xffff+1 so that they'll never + * collide with Aldus-assigned tags. + * + * If you want your private pseudo tags ``registered'' (i.e. added to + * this file), please post a bug report via the tracking system at + * http://www.remotesensing.org/libtiff/bugs.html with the appropriate + * C definitions to add. + */ +#define TIFFTAG_FAXMODE 65536 /* Group 3/4 format control */ +#define FAXMODE_CLASSIC 0x0000 /* default, include RTC */ +#define FAXMODE_NORTC 0x0001 /* no RTC at end of data */ +#define FAXMODE_NOEOL 0x0002 /* no EOL code at end of row */ +#define FAXMODE_BYTEALIGN 0x0004 /* byte align row */ +#define FAXMODE_WORDALIGN 0x0008 /* word align row */ +#define FAXMODE_CLASSF FAXMODE_NORTC /* TIFF Class F */ +#define TIFFTAG_JPEGQUALITY 65537 /* Compression quality level */ +/* Note: quality level is on the IJG 0-100 scale. Default value is 75 */ +#define TIFFTAG_JPEGCOLORMODE 65538 /* Auto RGB<=>YCbCr convert? */ +#define JPEGCOLORMODE_RAW 0x0000 /* no conversion (default) */ +#define JPEGCOLORMODE_RGB 0x0001 /* do auto conversion */ +#define TIFFTAG_JPEGTABLESMODE 65539 /* What to put in JPEGTables */ +#define JPEGTABLESMODE_QUANT 0x0001 /* include quantization tbls */ +#define JPEGTABLESMODE_HUFF 0x0002 /* include Huffman tbls */ +/* Note: default is JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF */ +#define TIFFTAG_FAXFILLFUNC 65540 /* G3/G4 fill function */ +#define TIFFTAG_PIXARLOGDATAFMT 65549 /* PixarLogCodec I/O data sz */ +#define PIXARLOGDATAFMT_8BIT 0 /* regular u_char samples */ +#define PIXARLOGDATAFMT_8BITABGR 1 /* ABGR-order u_chars */ +#define PIXARLOGDATAFMT_11BITLOG 2 /* 11-bit log-encoded (raw) */ +#define PIXARLOGDATAFMT_12BITPICIO 3 /* as per PICIO (1.0==2048) */ +#define PIXARLOGDATAFMT_16BIT 4 /* signed short samples */ +#define PIXARLOGDATAFMT_FLOAT 5 /* IEEE float samples */ +/* 65550-65556 are allocated to Oceana Matrix */ +#define TIFFTAG_DCSIMAGERTYPE 65550 /* imager model & filter */ +#define DCSIMAGERMODEL_M3 0 /* M3 chip (1280 x 1024) */ +#define DCSIMAGERMODEL_M5 1 /* M5 chip (1536 x 1024) */ +#define DCSIMAGERMODEL_M6 2 /* M6 chip (3072 x 2048) */ +#define DCSIMAGERFILTER_IR 0 /* infrared filter */ +#define DCSIMAGERFILTER_MONO 1 /* monochrome filter */ +#define DCSIMAGERFILTER_CFA 2 /* color filter array */ +#define DCSIMAGERFILTER_OTHER 3 /* other filter */ +#define TIFFTAG_DCSINTERPMODE 65551 /* interpolation mode */ +#define DCSINTERPMODE_NORMAL 0x0 /* whole image, default */ +#define DCSINTERPMODE_PREVIEW 0x1 /* preview of image (384x256) */ +#define TIFFTAG_DCSBALANCEARRAY 65552 /* color balance values */ +#define TIFFTAG_DCSCORRECTMATRIX 65553 /* color correction values */ +#define TIFFTAG_DCSGAMMA 65554 /* gamma value */ +#define TIFFTAG_DCSTOESHOULDERPTS 65555 /* toe & shoulder points */ +#define TIFFTAG_DCSCALIBRATIONFD 65556 /* calibration file desc */ +/* Note: quality level is on the ZLIB 1-9 scale. Default value is -1 */ +#define TIFFTAG_ZIPQUALITY 65557 /* compression quality level */ +#define TIFFTAG_PIXARLOGQUALITY 65558 /* PixarLog uses same scale */ +/* 65559 is allocated to Oceana Matrix */ +#define TIFFTAG_DCSCLIPRECTANGLE 65559 /* area of image to acquire */ +#define TIFFTAG_SGILOGDATAFMT 65560 /* SGILog user data format */ +#define SGILOGDATAFMT_FLOAT 0 /* IEEE float samples */ +#define SGILOGDATAFMT_16BIT 1 /* 16-bit samples */ +#define SGILOGDATAFMT_RAW 2 /* uninterpreted data */ +#define SGILOGDATAFMT_8BIT 3 /* 8-bit RGB monitor values */ +#define TIFFTAG_SGILOGENCODE 65561 /* SGILog data encoding control*/ +#define SGILOGENCODE_NODITHER 0 /* do not dither encoded values*/ +#define SGILOGENCODE_RANDITHER 1 /* randomly dither encd values */ +#define TIFFTAG_LZMAPRESET 65562 /* LZMA2 preset (compression level) */ +#define TIFFTAG_PERSAMPLE 65563 /* interface for per sample tags */ +#define PERSAMPLE_MERGED 0 /* present as a single value */ +#define PERSAMPLE_MULTI 1 /* present as multiple values */ +#define TIFFTAG_ZSTD_LEVEL 65564 /* ZSTD compression level */ +#define TIFFTAG_LERC_VERSION 65565 /* LERC version */ +#define LERC_VERSION_2_4 4 +#define TIFFTAG_LERC_ADD_COMPRESSION 65566 /* LERC additional compression */ +#define LERC_ADD_COMPRESSION_NONE 0 +#define LERC_ADD_COMPRESSION_DEFLATE 1 +#define LERC_ADD_COMPRESSION_ZSTD 2 +#define TIFFTAG_LERC_MAXZERROR 65567 /* LERC maximum error */ +#define TIFFTAG_WEBP_LEVEL 65568 /* WebP compression level: WARNING not registered in Adobe-maintained registry */ +#define TIFFTAG_WEBP_LOSSLESS 65569 /* WebP lossless/lossy : WARNING not registered in Adobe-maintained registry */ + +/* + * EXIF tags + */ +#define EXIFTAG_EXPOSURETIME 33434 /* Exposure time */ +#define EXIFTAG_FNUMBER 33437 /* F number */ +#define EXIFTAG_EXPOSUREPROGRAM 34850 /* Exposure program */ +#define EXIFTAG_SPECTRALSENSITIVITY 34852 /* Spectral sensitivity */ +#define EXIFTAG_ISOSPEEDRATINGS 34855 /* ISO speed rating */ +#define EXIFTAG_OECF 34856 /* Optoelectric conversion + factor */ +#define EXIFTAG_EXIFVERSION 36864 /* Exif version */ +#define EXIFTAG_DATETIMEORIGINAL 36867 /* Date and time of original + data generation */ +#define EXIFTAG_DATETIMEDIGITIZED 36868 /* Date and time of digital + data generation */ +#define EXIFTAG_COMPONENTSCONFIGURATION 37121 /* Meaning of each component */ +#define EXIFTAG_COMPRESSEDBITSPERPIXEL 37122 /* Image compression mode */ +#define EXIFTAG_SHUTTERSPEEDVALUE 37377 /* Shutter speed */ +#define EXIFTAG_APERTUREVALUE 37378 /* Aperture */ +#define EXIFTAG_BRIGHTNESSVALUE 37379 /* Brightness */ +#define EXIFTAG_EXPOSUREBIASVALUE 37380 /* Exposure bias */ +#define EXIFTAG_MAXAPERTUREVALUE 37381 /* Maximum lens aperture */ +#define EXIFTAG_SUBJECTDISTANCE 37382 /* Subject distance */ +#define EXIFTAG_METERINGMODE 37383 /* Metering mode */ +#define EXIFTAG_LIGHTSOURCE 37384 /* Light source */ +#define EXIFTAG_FLASH 37385 /* Flash */ +#define EXIFTAG_FOCALLENGTH 37386 /* Lens focal length */ +#define EXIFTAG_SUBJECTAREA 37396 /* Subject area */ +#define EXIFTAG_MAKERNOTE 37500 /* Manufacturer notes */ +#define EXIFTAG_USERCOMMENT 37510 /* User comments */ +#define EXIFTAG_SUBSECTIME 37520 /* DateTime subseconds */ +#define EXIFTAG_SUBSECTIMEORIGINAL 37521 /* DateTimeOriginal subseconds */ +#define EXIFTAG_SUBSECTIMEDIGITIZED 37522 /* DateTimeDigitized subseconds */ +#define EXIFTAG_FLASHPIXVERSION 40960 /* Supported Flashpix version */ +#define EXIFTAG_COLORSPACE 40961 /* Color space information */ +#define EXIFTAG_PIXELXDIMENSION 40962 /* Valid image width */ +#define EXIFTAG_PIXELYDIMENSION 40963 /* Valid image height */ +#define EXIFTAG_RELATEDSOUNDFILE 40964 /* Related audio file */ +#define EXIFTAG_FLASHENERGY 41483 /* Flash energy */ +#define EXIFTAG_SPATIALFREQUENCYRESPONSE 41484 /* Spatial frequency response */ +#define EXIFTAG_FOCALPLANEXRESOLUTION 41486 /* Focal plane X resolution */ +#define EXIFTAG_FOCALPLANEYRESOLUTION 41487 /* Focal plane Y resolution */ +#define EXIFTAG_FOCALPLANERESOLUTIONUNIT 41488 /* Focal plane resolution unit */ +#define EXIFTAG_SUBJECTLOCATION 41492 /* Subject location */ +#define EXIFTAG_EXPOSUREINDEX 41493 /* Exposure index */ +#define EXIFTAG_SENSINGMETHOD 41495 /* Sensing method */ +#define EXIFTAG_FILESOURCE 41728 /* File source */ +#define EXIFTAG_SCENETYPE 41729 /* Scene type */ +#define EXIFTAG_CFAPATTERN 41730 /* CFA pattern */ +#define EXIFTAG_CUSTOMRENDERED 41985 /* Custom image processing */ +#define EXIFTAG_EXPOSUREMODE 41986 /* Exposure mode */ +#define EXIFTAG_WHITEBALANCE 41987 /* White balance */ +#define EXIFTAG_DIGITALZOOMRATIO 41988 /* Digital zoom ratio */ +#define EXIFTAG_FOCALLENGTHIN35MMFILM 41989 /* Focal length in 35 mm film */ +#define EXIFTAG_SCENECAPTURETYPE 41990 /* Scene capture type */ +#define EXIFTAG_GAINCONTROL 41991 /* Gain control */ +#define EXIFTAG_CONTRAST 41992 /* Contrast */ +#define EXIFTAG_SATURATION 41993 /* Saturation */ +#define EXIFTAG_SHARPNESS 41994 /* Sharpness */ +#define EXIFTAG_DEVICESETTINGDESCRIPTION 41995 /* Device settings description */ +#define EXIFTAG_SUBJECTDISTANCERANGE 41996 /* Subject distance range */ +#define EXIFTAG_GAINCONTROL 41991 /* Gain control */ +#define EXIFTAG_GAINCONTROL 41991 /* Gain control */ +#define EXIFTAG_IMAGEUNIQUEID 42016 /* Unique image ID */ + +#endif /* _TIFF_ */ + +/* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/hgdriver/3rdparty/tiff/include/tiffconf.h b/hgdriver/3rdparty/tiff/include/tiffconf.h new file mode 100644 index 0000000..ad6588a --- /dev/null +++ b/hgdriver/3rdparty/tiff/include/tiffconf.h @@ -0,0 +1,121 @@ +/* + Configuration defines for installed libtiff. + This file maintained for backward compatibility. Do not use definitions + from this file in your programs. +*/ + +#ifndef _TIFFCONF_ +#define _TIFFCONF_ + +/* Signed 16-bit type */ +#define TIFF_INT16_T signed short + +/* Signed 32-bit type */ +#define TIFF_INT32_T signed int + +/* Signed 64-bit type */ +#define TIFF_INT64_T signed long long + +/* Signed 8-bit type */ +#define TIFF_INT8_T signed char + +/* Unsigned 16-bit type */ +#define TIFF_UINT16_T unsigned short + +/* Unsigned 32-bit type */ +#define TIFF_UINT32_T unsigned int + +/* Unsigned 64-bit type */ +#define TIFF_UINT64_T unsigned long long + +/* Unsigned 8-bit type */ +#define TIFF_UINT8_T unsigned char + +/* Unsigned size type */ +#define TIFF_SIZE_T unsigned long long + +/* Signed size type */ +#define TIFF_SSIZE_T signed long long + +/* Pointer difference type */ +#define TIFF_PTRDIFF_T ptrdiff_t + +/* Compatibility stuff. */ + +/* Define as 0 or 1 according to the floating point format suported by the + machine */ +#define HAVE_IEEEFP 1 + +/* Set the native cpu bit order (FILLORDER_LSB2MSB or FILLORDER_MSB2LSB) */ +#define HOST_FILLORDER FILLORDER_LSB2MSB + +/* Native cpu byte order: 1 if big-endian (Motorola) or 0 if little-endian + (Intel) */ +#define HOST_BIGENDIAN 0 + +/* Support CCITT Group 3 & 4 algorithms */ +#define CCITT_SUPPORT 1 + +/* Support JPEG compression (requires IJG JPEG library) */ +/* #undef JPEG_SUPPORT */ + +/* Support JBIG compression (requires JBIG-KIT library) */ +/* #undef JBIG_SUPPORT */ + +/* Support LogLuv high dynamic range encoding */ +#define LOGLUV_SUPPORT 1 + +/* Support LZW algorithm */ +#define LZW_SUPPORT 1 + +/* Support NeXT 2-bit RLE algorithm */ +#define NEXT_SUPPORT 1 + +/* Support Old JPEG compresson (read contrib/ojpeg/README first! Compilation + fails with unpatched IJG JPEG library) */ +/* #undef OJPEG_SUPPORT */ + +/* Support Macintosh PackBits algorithm */ +#define PACKBITS_SUPPORT 1 + +/* Support Pixar log-format algorithm (requires Zlib) */ +/* #undef PIXARLOG_SUPPORT */ + +/* Support ThunderScan 4-bit RLE algorithm */ +#define THUNDER_SUPPORT 1 + +/* Support Deflate compression */ +/* #undef ZIP_SUPPORT */ + +/* Support strip chopping (whether or not to convert single-strip uncompressed + images to mutiple strips of ~8Kb to reduce memory usage) */ +#define STRIPCHOP_DEFAULT 1 + +/* Enable SubIFD tag (330) support */ +#define SUBIFD_SUPPORT 1 + +/* Treat extra sample as alpha (default enabled). The RGBA interface will + treat a fourth sample with no EXTRASAMPLE_ value as being ASSOCALPHA. Many + packages produce RGBA files but don't mark the alpha properly. */ +#define DEFAULT_EXTRASAMPLE_AS_ALPHA 1 + +/* Pick up YCbCr subsampling info from the JPEG data stream to support files + lacking the tag (default enabled). */ +#define CHECK_JPEG_YCBCR_SUBSAMPLING 1 + +/* Support MS MDI magic number files as TIFF */ +#define MDI_SUPPORT 1 + +/* + * Feature support definitions. + * XXX: These macros are obsoleted. Don't use them in your apps! + * Macros stays here for backward compatibility and should be always defined. + */ +#define COLORIMETRY_SUPPORT +#define YCBCR_SUPPORT +#define CMYK_SUPPORT +#define ICC_SUPPORT +#define PHOTOSHOP_SUPPORT +#define IPTC_SUPPORT + +#endif /* _TIFFCONF_ */ diff --git a/hgdriver/3rdparty/tiff/include/tiffio.h b/hgdriver/3rdparty/tiff/include/tiffio.h new file mode 100644 index 0000000..198481d --- /dev/null +++ b/hgdriver/3rdparty/tiff/include/tiffio.h @@ -0,0 +1,568 @@ +/* + * Copyright (c) 1988-1997 Sam Leffler + * Copyright (c) 1991-1997 Silicon Graphics, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that (i) the above copyright notices and this permission notice appear in + * all copies of the software and related documentation, and (ii) the names of + * Sam Leffler and Silicon Graphics may not be used in any advertising or + * publicity relating to the software without the specific, prior written + * permission of Sam Leffler and Silicon Graphics. + * + * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, + * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY + * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. + * + * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR + * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, + * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, + * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF + * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#ifndef _TIFFIO_ +#define _TIFFIO_ + +/* + * TIFF I/O Library Definitions. + */ +#include "tiff.h" +#include "tiffvers.h" + +/* + * TIFF is defined as an incomplete type to hide the + * library's internal data structures from clients. + */ +typedef struct tiff TIFF; + +/* + * The following typedefs define the intrinsic size of + * data types used in the *exported* interfaces. These + * definitions depend on the proper definition of types + * in tiff.h. Note also that the varargs interface used + * to pass tag types and values uses the types defined in + * tiff.h directly. + * + * NB: ttag_t is unsigned int and not unsigned short because + * ANSI C requires that the type before the ellipsis be a + * promoted type (i.e. one of int, unsigned int, pointer, + * or double) and because we defined pseudo-tags that are + * outside the range of legal Aldus-assigned tags. + * NB: tsize_t is signed and not unsigned because some functions + * return -1. + * NB: toff_t is not off_t for many reasons; TIFFs max out at + * 32-bit file offsets, and BigTIFF maxes out at 64-bit + * offsets being the most important, and to ensure use of + * a consistently unsigned type across architectures. + * Prior to libtiff 4.0, this was an unsigned 32 bit type. + */ +/* + * this is the machine addressing size type, only it's signed, so make it + * int32 on 32bit machines, int64 on 64bit machines + */ +typedef TIFF_SSIZE_T tmsize_t; +typedef uint64 toff_t; /* file offset */ +/* the following are deprecated and should be replaced by their defining + counterparts */ +typedef uint32 ttag_t; /* directory tag */ +typedef uint16 tdir_t; /* directory index */ +typedef uint16 tsample_t; /* sample number */ +typedef uint32 tstrile_t; /* strip or tile number */ +typedef tstrile_t tstrip_t; /* strip number */ +typedef tstrile_t ttile_t; /* tile number */ +typedef tmsize_t tsize_t; /* i/o size in bytes */ +typedef void* tdata_t; /* image data ref */ + +#if !defined(__WIN32__) && (defined(_WIN32) || defined(WIN32)) +#define __WIN32__ +#endif + +/* + * On windows you should define USE_WIN32_FILEIO if you are using tif_win32.c + * or AVOID_WIN32_FILEIO if you are using something else (like tif_unix.c). + * + * By default tif_unix.c is assumed. + */ + +#if defined(_WINDOWS) || defined(__WIN32__) || defined(_Windows) +# if !defined(__CYGWIN) && !defined(AVOID_WIN32_FILEIO) && !defined(USE_WIN32_FILEIO) +# define AVOID_WIN32_FILEIO +# endif +#endif + +#if defined(USE_WIN32_FILEIO) +# define VC_EXTRALEAN +# include +# ifdef __WIN32__ +DECLARE_HANDLE(thandle_t); /* Win32 file handle */ +# else +typedef HFILE thandle_t; /* client data handle */ +# endif /* __WIN32__ */ +#else +typedef void* thandle_t; /* client data handle */ +#endif /* USE_WIN32_FILEIO */ + +/* + * Flags to pass to TIFFPrintDirectory to control + * printing of data structures that are potentially + * very large. Bit-or these flags to enable printing + * multiple items. + */ +#define TIFFPRINT_NONE 0x0 /* no extra info */ +#define TIFFPRINT_STRIPS 0x1 /* strips/tiles info */ +#define TIFFPRINT_CURVES 0x2 /* color/gray response curves */ +#define TIFFPRINT_COLORMAP 0x4 /* colormap */ +#define TIFFPRINT_JPEGQTABLES 0x100 /* JPEG Q matrices */ +#define TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */ +#define TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */ + +/* + * Colour conversion stuff + */ + +/* reference white */ +#define D65_X0 (95.0470F) +#define D65_Y0 (100.0F) +#define D65_Z0 (108.8827F) + +#define D50_X0 (96.4250F) +#define D50_Y0 (100.0F) +#define D50_Z0 (82.4680F) + +/* Structure for holding information about a display device. */ + +typedef unsigned char TIFFRGBValue; /* 8-bit samples */ + +typedef struct { + float d_mat[3][3]; /* XYZ -> luminance matrix */ + float d_YCR; /* Light o/p for reference white */ + float d_YCG; + float d_YCB; + uint32 d_Vrwr; /* Pixel values for ref. white */ + uint32 d_Vrwg; + uint32 d_Vrwb; + float d_Y0R; /* Residual light for black pixel */ + float d_Y0G; + float d_Y0B; + float d_gammaR; /* Gamma values for the three guns */ + float d_gammaG; + float d_gammaB; +} TIFFDisplay; + +typedef struct { /* YCbCr->RGB support */ + TIFFRGBValue* clamptab; /* range clamping table */ + int* Cr_r_tab; + int* Cb_b_tab; + int32* Cr_g_tab; + int32* Cb_g_tab; + int32* Y_tab; +} TIFFYCbCrToRGB; + +typedef struct { /* CIE Lab 1976->RGB support */ + int range; /* Size of conversion table */ +#define CIELABTORGB_TABLE_RANGE 1500 + float rstep, gstep, bstep; + float X0, Y0, Z0; /* Reference white point */ + TIFFDisplay display; + float Yr2r[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yr to r */ + float Yg2g[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yg to g */ + float Yb2b[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yb to b */ +} TIFFCIELabToRGB; + +/* + * RGBA-style image support. + */ +typedef struct _TIFFRGBAImage TIFFRGBAImage; +/* + * The image reading and conversion routines invoke + * ``put routines'' to copy/image/whatever tiles of + * raw image data. A default set of routines are + * provided to convert/copy raw image data to 8-bit + * packed ABGR format rasters. Applications can supply + * alternate routines that unpack the data into a + * different format or, for example, unpack the data + * and draw the unpacked raster on the display. + */ +typedef void (*tileContigRoutine) + (TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32, + unsigned char*); +typedef void (*tileSeparateRoutine) + (TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32, + unsigned char*, unsigned char*, unsigned char*, unsigned char*); +/* + * RGBA-reader state. + */ +struct _TIFFRGBAImage { + TIFF* tif; /* image handle */ + int stoponerr; /* stop on read error */ + int isContig; /* data is packed/separate */ + int alpha; /* type of alpha data present */ + uint32 width; /* image width */ + uint32 height; /* image height */ + uint16 bitspersample; /* image bits/sample */ + uint16 samplesperpixel; /* image samples/pixel */ + uint16 orientation; /* image orientation */ + uint16 req_orientation; /* requested orientation */ + uint16 photometric; /* image photometric interp */ + uint16* redcmap; /* colormap palette */ + uint16* greencmap; + uint16* bluecmap; + /* get image data routine */ + int (*get)(TIFFRGBAImage*, uint32*, uint32, uint32); + /* put decoded strip/tile */ + union { + void (*any)(TIFFRGBAImage*); + tileContigRoutine contig; + tileSeparateRoutine separate; + } put; + TIFFRGBValue* Map; /* sample mapping array */ + uint32** BWmap; /* black&white map */ + uint32** PALmap; /* palette image map */ + TIFFYCbCrToRGB* ycbcr; /* YCbCr conversion state */ + TIFFCIELabToRGB* cielab; /* CIE L*a*b conversion state */ + + uint8* UaToAa; /* Unassociated alpha to associated alpha conversion LUT */ + uint8* Bitdepth16To8; /* LUT for conversion from 16bit to 8bit values */ + + int row_offset; + int col_offset; +}; + +/* + * Macros for extracting components from the + * packed ABGR form returned by TIFFReadRGBAImage. + */ +#define TIFFGetR(abgr) ((abgr) & 0xff) +#define TIFFGetG(abgr) (((abgr) >> 8) & 0xff) +#define TIFFGetB(abgr) (((abgr) >> 16) & 0xff) +#define TIFFGetA(abgr) (((abgr) >> 24) & 0xff) + +/* + * A CODEC is a software package that implements decoding, + * encoding, or decoding+encoding of a compression algorithm. + * The library provides a collection of builtin codecs. + * More codecs may be registered through calls to the library + * and/or the builtin implementations may be overridden. + */ +typedef int (*TIFFInitMethod)(TIFF*, int); +typedef struct { + char* name; + uint16 scheme; + TIFFInitMethod init; +} TIFFCodec; + +#include +#include + +/* share internal LogLuv conversion routines? */ +#ifndef LOGLUV_PUBLIC +#define LOGLUV_PUBLIC 1 +#endif + +#if !defined(__GNUC__) && !defined(__attribute__) +# define __attribute__(x) /*nothing*/ +#endif + +#if defined(c_plusplus) || defined(__cplusplus) +extern "C" { +#endif +typedef void (*TIFFErrorHandler)(const char*, const char*, va_list); +typedef void (*TIFFErrorHandlerExt)(thandle_t, const char*, const char*, va_list); +typedef tmsize_t (*TIFFReadWriteProc)(thandle_t, void*, tmsize_t); +typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int); +typedef int (*TIFFCloseProc)(thandle_t); +typedef toff_t (*TIFFSizeProc)(thandle_t); +typedef int (*TIFFMapFileProc)(thandle_t, void** base, toff_t* size); +typedef void (*TIFFUnmapFileProc)(thandle_t, void* base, toff_t size); +typedef void (*TIFFExtendProc)(TIFF*); + +extern const char* TIFFGetVersion(void); + +extern const TIFFCodec* TIFFFindCODEC(uint16); +extern TIFFCodec* TIFFRegisterCODEC(uint16, const char*, TIFFInitMethod); +extern void TIFFUnRegisterCODEC(TIFFCodec*); +extern int TIFFIsCODECConfigured(uint16); +extern TIFFCodec* TIFFGetConfiguredCODECs(void); + +/* + * Auxiliary functions. + */ + +extern void* _TIFFmalloc(tmsize_t s); +extern void* _TIFFcalloc(tmsize_t nmemb, tmsize_t siz); +extern void* _TIFFrealloc(void* p, tmsize_t s); +extern void _TIFFmemset(void* p, int v, tmsize_t c); +extern void _TIFFmemcpy(void* d, const void* s, tmsize_t c); +extern int _TIFFmemcmp(const void* p1, const void* p2, tmsize_t c); +extern void _TIFFfree(void* p); + +/* +** Stuff, related to tag handling and creating custom tags. +*/ +extern int TIFFGetTagListCount( TIFF * ); +extern uint32 TIFFGetTagListEntry( TIFF *, int tag_index ); + +#define TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */ +#define TIFF_VARIABLE -1 /* marker for variable length tags */ +#define TIFF_SPP -2 /* marker for SamplesPerPixel tags */ +#define TIFF_VARIABLE2 -3 /* marker for uint32 var-length tags */ + +#define FIELD_CUSTOM 65 + +typedef struct _TIFFField TIFFField; +typedef struct _TIFFFieldArray TIFFFieldArray; + +extern const TIFFField* TIFFFindField(TIFF *, uint32, TIFFDataType); +extern const TIFFField* TIFFFieldWithTag(TIFF*, uint32); +extern const TIFFField* TIFFFieldWithName(TIFF*, const char *); + +extern uint32 TIFFFieldTag(const TIFFField*); +extern const char* TIFFFieldName(const TIFFField*); +extern TIFFDataType TIFFFieldDataType(const TIFFField*); +extern int TIFFFieldPassCount(const TIFFField*); +extern int TIFFFieldReadCount(const TIFFField*); +extern int TIFFFieldWriteCount(const TIFFField*); + +typedef int (*TIFFVSetMethod)(TIFF*, uint32, va_list); +typedef int (*TIFFVGetMethod)(TIFF*, uint32, va_list); +typedef void (*TIFFPrintMethod)(TIFF*, FILE*, long); + +typedef struct { + TIFFVSetMethod vsetfield; /* tag set routine */ + TIFFVGetMethod vgetfield; /* tag get routine */ + TIFFPrintMethod printdir; /* directory print routine */ +} TIFFTagMethods; + +extern TIFFTagMethods *TIFFAccessTagMethods(TIFF *); +extern void *TIFFGetClientInfo(TIFF *, const char *); +extern void TIFFSetClientInfo(TIFF *, void *, const char *); + +extern void TIFFCleanup(TIFF* tif); +extern void TIFFClose(TIFF* tif); +extern int TIFFFlush(TIFF* tif); +extern int TIFFFlushData(TIFF* tif); +extern int TIFFGetField(TIFF* tif, uint32 tag, ...); +extern int TIFFVGetField(TIFF* tif, uint32 tag, va_list ap); +extern int TIFFGetFieldDefaulted(TIFF* tif, uint32 tag, ...); +extern int TIFFVGetFieldDefaulted(TIFF* tif, uint32 tag, va_list ap); +extern int TIFFReadDirectory(TIFF* tif); +extern int TIFFReadCustomDirectory(TIFF* tif, toff_t diroff, const TIFFFieldArray* infoarray); +extern int TIFFReadEXIFDirectory(TIFF* tif, toff_t diroff); +extern uint64 TIFFScanlineSize64(TIFF* tif); +extern tmsize_t TIFFScanlineSize(TIFF* tif); +extern uint64 TIFFRasterScanlineSize64(TIFF* tif); +extern tmsize_t TIFFRasterScanlineSize(TIFF* tif); +extern uint64 TIFFStripSize64(TIFF* tif); +extern tmsize_t TIFFStripSize(TIFF* tif); +extern uint64 TIFFRawStripSize64(TIFF* tif, uint32 strip); +extern tmsize_t TIFFRawStripSize(TIFF* tif, uint32 strip); +extern uint64 TIFFVStripSize64(TIFF* tif, uint32 nrows); +extern tmsize_t TIFFVStripSize(TIFF* tif, uint32 nrows); +extern uint64 TIFFTileRowSize64(TIFF* tif); +extern tmsize_t TIFFTileRowSize(TIFF* tif); +extern uint64 TIFFTileSize64(TIFF* tif); +extern tmsize_t TIFFTileSize(TIFF* tif); +extern uint64 TIFFVTileSize64(TIFF* tif, uint32 nrows); +extern tmsize_t TIFFVTileSize(TIFF* tif, uint32 nrows); +extern uint32 TIFFDefaultStripSize(TIFF* tif, uint32 request); +extern void TIFFDefaultTileSize(TIFF*, uint32*, uint32*); +extern int TIFFFileno(TIFF*); +extern int TIFFSetFileno(TIFF*, int); +extern thandle_t TIFFClientdata(TIFF*); +extern thandle_t TIFFSetClientdata(TIFF*, thandle_t); +extern int TIFFGetMode(TIFF*); +extern int TIFFSetMode(TIFF*, int); +extern int TIFFIsTiled(TIFF*); +extern int TIFFIsByteSwapped(TIFF*); +extern int TIFFIsUpSampled(TIFF*); +extern int TIFFIsMSB2LSB(TIFF*); +extern int TIFFIsBigEndian(TIFF*); +extern TIFFReadWriteProc TIFFGetReadProc(TIFF*); +extern TIFFReadWriteProc TIFFGetWriteProc(TIFF*); +extern TIFFSeekProc TIFFGetSeekProc(TIFF*); +extern TIFFCloseProc TIFFGetCloseProc(TIFF*); +extern TIFFSizeProc TIFFGetSizeProc(TIFF*); +extern TIFFMapFileProc TIFFGetMapFileProc(TIFF*); +extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF*); +extern uint32 TIFFCurrentRow(TIFF*); +extern uint16 TIFFCurrentDirectory(TIFF*); +extern uint16 TIFFNumberOfDirectories(TIFF*); +extern uint64 TIFFCurrentDirOffset(TIFF*); +extern uint32 TIFFCurrentStrip(TIFF*); +extern uint32 TIFFCurrentTile(TIFF* tif); +extern int TIFFReadBufferSetup(TIFF* tif, void* bp, tmsize_t size); +extern int TIFFWriteBufferSetup(TIFF* tif, void* bp, tmsize_t size); +extern int TIFFSetupStrips(TIFF *); +extern int TIFFWriteCheck(TIFF*, int, const char *); +extern void TIFFFreeDirectory(TIFF*); +extern int TIFFCreateDirectory(TIFF*); +extern int TIFFCreateCustomDirectory(TIFF*,const TIFFFieldArray*); +extern int TIFFCreateEXIFDirectory(TIFF*); +extern int TIFFLastDirectory(TIFF*); +extern int TIFFSetDirectory(TIFF*, uint16); +extern int TIFFSetSubDirectory(TIFF*, uint64); +extern int TIFFUnlinkDirectory(TIFF*, uint16); +extern int TIFFSetField(TIFF*, uint32, ...); +extern int TIFFVSetField(TIFF*, uint32, va_list); +extern int TIFFUnsetField(TIFF*, uint32); +extern int TIFFWriteDirectory(TIFF *); +extern int TIFFWriteCustomDirectory(TIFF *, uint64 *); +extern int TIFFCheckpointDirectory(TIFF *); +extern int TIFFRewriteDirectory(TIFF *); +extern int TIFFDeferStrileArrayWriting(TIFF *); +extern int TIFFForceStrileArrayWriting(TIFF* ); + +#if defined(c_plusplus) || defined(__cplusplus) +extern void TIFFPrintDirectory(TIFF*, FILE*, long = 0); +extern int TIFFReadScanline(TIFF* tif, void* buf, uint32 row, uint16 sample = 0); +extern int TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample = 0); +extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int = 0); +extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*, + int = ORIENTATION_BOTLEFT, int = 0); +#else +extern void TIFFPrintDirectory(TIFF*, FILE*, long); +extern int TIFFReadScanline(TIFF* tif, void* buf, uint32 row, uint16 sample); +extern int TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample); +extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int); +extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*, int, int); +#endif + +extern int TIFFReadRGBAStrip(TIFF*, uint32, uint32 * ); +extern int TIFFReadRGBATile(TIFF*, uint32, uint32, uint32 * ); +extern int TIFFReadRGBAStripExt(TIFF*, uint32, uint32 *, int stop_on_error ); +extern int TIFFReadRGBATileExt(TIFF*, uint32, uint32, uint32 *, int stop_on_error ); +extern int TIFFRGBAImageOK(TIFF*, char [1024]); +extern int TIFFRGBAImageBegin(TIFFRGBAImage*, TIFF*, int, char [1024]); +extern int TIFFRGBAImageGet(TIFFRGBAImage*, uint32*, uint32, uint32); +extern void TIFFRGBAImageEnd(TIFFRGBAImage*); +extern TIFF* TIFFOpen(const char*, const char*); +# ifdef __WIN32__ +extern TIFF* TIFFOpenW(const wchar_t*, const char*); +# endif /* __WIN32__ */ +extern TIFF* TIFFFdOpen(int, const char*, const char*); +extern TIFF* TIFFClientOpen(const char*, const char*, + thandle_t, + TIFFReadWriteProc, TIFFReadWriteProc, + TIFFSeekProc, TIFFCloseProc, + TIFFSizeProc, + TIFFMapFileProc, TIFFUnmapFileProc); +extern const char* TIFFFileName(TIFF*); +extern const char* TIFFSetFileName(TIFF*, const char *); +extern void TIFFError(const char*, const char*, ...) __attribute__((__format__ (__printf__,2,3))); +extern void TIFFErrorExt(thandle_t, const char*, const char*, ...) __attribute__((__format__ (__printf__,3,4))); +extern void TIFFWarning(const char*, const char*, ...) __attribute__((__format__ (__printf__,2,3))); +extern void TIFFWarningExt(thandle_t, const char*, const char*, ...) __attribute__((__format__ (__printf__,3,4))); +extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler); +extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt); +extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler); +extern TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt); +extern TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc); +extern uint32 TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s); +extern int TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s); +extern uint32 TIFFNumberOfTiles(TIFF*); +extern tmsize_t TIFFReadTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s); +extern tmsize_t TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s); +extern uint32 TIFFComputeStrip(TIFF*, uint32, uint16); +extern uint32 TIFFNumberOfStrips(TIFF*); +extern tmsize_t TIFFReadEncodedStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size); +extern tmsize_t TIFFReadRawStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size); +extern tmsize_t TIFFReadEncodedTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size); +extern tmsize_t TIFFReadRawTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size); +extern int TIFFReadFromUserBuffer(TIFF* tif, uint32 strile, + void* inbuf, tmsize_t insize, + void* outbuf, tmsize_t outsize); +extern tmsize_t TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc); +extern tmsize_t TIFFWriteRawStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc); +extern tmsize_t TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc); +extern tmsize_t TIFFWriteRawTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc); +extern int TIFFDataWidth(TIFFDataType); /* table of tag datatype widths */ +extern void TIFFSetWriteOffset(TIFF* tif, toff_t off); +extern void TIFFSwabShort(uint16*); +extern void TIFFSwabLong(uint32*); +extern void TIFFSwabLong8(uint64*); +extern void TIFFSwabFloat(float*); +extern void TIFFSwabDouble(double*); +extern void TIFFSwabArrayOfShort(uint16* wp, tmsize_t n); +extern void TIFFSwabArrayOfTriples(uint8* tp, tmsize_t n); +extern void TIFFSwabArrayOfLong(uint32* lp, tmsize_t n); +extern void TIFFSwabArrayOfLong8(uint64* lp, tmsize_t n); +extern void TIFFSwabArrayOfFloat(float* fp, tmsize_t n); +extern void TIFFSwabArrayOfDouble(double* dp, tmsize_t n); +extern void TIFFReverseBits(uint8* cp, tmsize_t n); +extern const unsigned char* TIFFGetBitRevTable(int); + +extern uint64 TIFFGetStrileOffset(TIFF *tif, uint32 strile); +extern uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile); +extern uint64 TIFFGetStrileOffsetWithErr(TIFF *tif, uint32 strile, int *pbErr); +extern uint64 TIFFGetStrileByteCountWithErr(TIFF *tif, uint32 strile, int *pbErr); + +#ifdef LOGLUV_PUBLIC +#define U_NEU 0.210526316 +#define V_NEU 0.473684211 +#define UVSCALE 410. +extern double LogL16toY(int); +extern double LogL10toY(int); +extern void XYZtoRGB24(float*, uint8*); +extern int uv_decode(double*, double*, int); +extern void LogLuv24toXYZ(uint32, float*); +extern void LogLuv32toXYZ(uint32, float*); +#if defined(c_plusplus) || defined(__cplusplus) +extern int LogL16fromY(double, int = SGILOGENCODE_NODITHER); +extern int LogL10fromY(double, int = SGILOGENCODE_NODITHER); +extern int uv_encode(double, double, int = SGILOGENCODE_NODITHER); +extern uint32 LogLuv24fromXYZ(float*, int = SGILOGENCODE_NODITHER); +extern uint32 LogLuv32fromXYZ(float*, int = SGILOGENCODE_NODITHER); +#else +extern int LogL16fromY(double, int); +extern int LogL10fromY(double, int); +extern int uv_encode(double, double, int); +extern uint32 LogLuv24fromXYZ(float*, int); +extern uint32 LogLuv32fromXYZ(float*, int); +#endif +#endif /* LOGLUV_PUBLIC */ + +extern int TIFFCIELabToRGBInit(TIFFCIELabToRGB*, const TIFFDisplay *, float*); +extern void TIFFCIELabToXYZ(TIFFCIELabToRGB *, uint32, int32, int32, + float *, float *, float *); +extern void TIFFXYZToRGB(TIFFCIELabToRGB *, float, float, float, + uint32 *, uint32 *, uint32 *); + +extern int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB*, float*, float*); +extern void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *, uint32, int32, int32, + uint32 *, uint32 *, uint32 *); + +/**************************************************************************** + * O B S O L E T E D I N T E R F A C E S + * + * Don't use this stuff in your applications, it may be removed in the future + * libtiff versions. + ****************************************************************************/ +typedef struct { + ttag_t field_tag; /* field's tag */ + short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */ + short field_writecount; /* write count/TIFF_VARIABLE */ + TIFFDataType field_type; /* type of associated data */ + unsigned short field_bit; /* bit in fieldsset bit vector */ + unsigned char field_oktochange; /* if true, can change while writing */ + unsigned char field_passcount; /* if true, pass dir count on set */ + char *field_name; /* ASCII name */ +} TIFFFieldInfo; + +extern int TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], uint32); + +#if defined(c_plusplus) || defined(__cplusplus) +} +#endif + +#endif /* _TIFFIO_ */ + +/* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/hgdriver/3rdparty/tiff/include/tiffvers.h b/hgdriver/3rdparty/tiff/include/tiffvers.h new file mode 100644 index 0000000..aa3f613 --- /dev/null +++ b/hgdriver/3rdparty/tiff/include/tiffvers.h @@ -0,0 +1,9 @@ +#define TIFFLIB_VERSION_STR "LIBTIFF, Version 4.1.0\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc." +/* + * This define can be used in code that requires + * compilation-related definitions specific to a + * version or versions of the library. Runtime + * version checking should be done based on the + * string returned by TIFFGetVersion. + */ +#define TIFFLIB_VERSION 20191103 diff --git a/hgdriver/ImageProcess/G4Tiff.cpp b/hgdriver/ImageProcess/G4Tiff.cpp new file mode 100644 index 0000000..a10c32e --- /dev/null +++ b/hgdriver/ImageProcess/G4Tiff.cpp @@ -0,0 +1,178 @@ +#include "G4Tiff.h" +#ifdef WIN32 +#include +#else +#include +#include +#include +#define _access access +#define _fileno fileno +#define _lseek lseek +#endif + +G4Tiff::G4Tiff(cv::Mat & mat, Mode mode,std::string path + , int threshold,int res, int compression) + : m_threshold(threshold), m_res(res), m_mode(mode) + , compression_(compression) +{ + m_tmppath = mode == Mode::MemoryMode ? cv::tempfile(".tif").c_str() : path; + m_mat = mat; + if (mode == Mode::MemoryMode) + save(mat); +} + +G4Tiff::~G4Tiff() +{ + if (m_mode == Mode::MemoryMode) + { + if (_access(m_tmppath.c_str(), 0) == 0) + { + if (!std::remove(m_tmppath.c_str())) {}//ɾɹ + else + throw std::runtime_error("File is not exist"); + } + } +} + +uchar* G4Tiff::load_mini_file(const char* file, size_t* bytes, void* (*mem_alloc)(size_t, const char*)) +{ + uchar* buf = nullptr; + + if (bytes) + *bytes = 0; + + FILE* src = fopen(file, "rb"); + if (src) + { + int filesize = _lseek(_fileno(src), 0, SEEK_END); // seek to EOF + fseek(src, 0, SEEK_SET); + std::vector ifh(8, 0); + fread(ifh.data(), 1, ifh.size(), src); + int size = (int)(*(int*)(ifh.data() + 4)); + fseek(src, 8, SEEK_SET); + if (filesize) + { + if (bytes) + *bytes = size; + buf = (uchar*)mem_alloc(size, ""); + if (buf) + fread(buf, 1, size, src); + } + fclose(src); + } + + return buf; +} + +void G4Tiff::GetCompressedData(std::vector& cmpeddata) +{ + if (m_tmppath.empty()) + throw std::runtime_error("file is not exist"); + FILE* file = fopen(m_tmppath.c_str(), "rb"); + if (file) + { + + int filesize = _lseek(_fileno(file), 0, SEEK_END); // seek to EOF + fseek(file, 0, SEEK_SET); + std::vector ifh(8, 0); + fread(ifh.data(), 1, ifh.size(), file); + int size = (int)(*(int*)(ifh.data() + 4)); + fseek(file, 8, SEEK_SET); + if (filesize) + { + cmpeddata.resize(size); + fread(cmpeddata.data(), 1, size, file); + } + } + fclose(file); +} +uchar* G4Tiff::get_compressed_data(size_t* bytes, void* (*mem_alloc)(size_t, const char*)) +{ + if (m_tmppath.empty()) + throw std::runtime_error("file is not exist"); + + return G4Tiff::load_mini_file(m_tmppath.c_str(), bytes, mem_alloc); +} +void G4Tiff::SaveG4Tiff() +{ + save(m_mat); +} + +void G4Tiff::save(cv::Mat& mat) +{ + if (compression_ == COMPRESSION_CCITT_T6 && mat.channels() != 1) + throw std::runtime_error("mat channel error"); + TIFF* pTiffHandle = TIFFOpen(m_tmppath.c_str(), "w"); + if (!pTiffHandle) + { + printf("can't open TIFF descriptor\n"); + } + int width = mat.cols; + int height = mat.rows; + try + { + except(TIFFSetField(pTiffHandle, TIFFTAG_IMAGEWIDTH, width), "width"); + except(TIFFSetField(pTiffHandle, TIFFTAG_IMAGELENGTH, height), "length"); + if (compression_ == COMPRESSION_CCITT_T6) + { + except(TIFFSetField(pTiffHandle, TIFFTAG_BITSPERSAMPLE, 1), "bits per sample"); + except(TIFFSetField(pTiffHandle, TIFFTAG_SAMPLESPERPIXEL, 1), "samples per pixel"); + } + else + { + except(TIFFSetField(pTiffHandle, TIFFTAG_BITSPERSAMPLE, /*mat.depth()*/8), "bits per sample"); + except(TIFFSetField(pTiffHandle, TIFFTAG_SAMPLESPERPIXEL, mat.channels()), "samples per pixel"); + } + except(TIFFSetField(pTiffHandle, TIFFTAG_ROWSPERSTRIP, height), "rows per strip"); + except(TIFFSetField(pTiffHandle, TIFFTAG_COMPRESSION, compression_), "compression"); + except(TIFFSetField(pTiffHandle, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISWHITE), "photometric"); + except(TIFFSetField(pTiffHandle, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB), "photometric"); + except(TIFFSetField(pTiffHandle, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG), "planar config"); + // not necessary + except(TIFFSetField(pTiffHandle, TIFFTAG_XRESOLUTION, (float)m_res), "res x"); + except(TIFFSetField(pTiffHandle, TIFFTAG_YRESOLUTION, (float)m_res), "res y"); + except(TIFFSetField(pTiffHandle, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH), "res unit"); + + if (compression_ == COMPRESSION_CCITT_T6) + { + std::vector _buffer(width / 8 + 8, 0); + //std::vector _buffer(width / 8 + 1, 0); + uchar* buffer = &_buffer[0]; + //int bytes = int(width / 8.0 + 0.5); + for (int y = 0; y < height; ++y) + { + uint8_t* src_row = mat.ptr(y); + for (int x = 0; x < width; ++x, ++src_row) + { + uint8_t eight_pixels = buffer[x / 8]; + eight_pixels = eight_pixels << 1; + if (*src_row < m_threshold) + eight_pixels = eight_pixels | 1; // + buffer[x / 8] = eight_pixels; + } + except(TIFFWriteScanline(pTiffHandle, buffer, y, 0) != -1, "write scanline"); + } + } + else + { + int l = mat.total() / mat.rows * mat.channels(); + for (int y = 0; y < height; ++y) + { + uint8_t* src = mat.ptr(y); + except(TIFFWriteScanline(pTiffHandle, src, y, 0) != -1, "write scanline"); + } + } + } + catch (const std::runtime_error& e) + { + printf("TIFF writing: %s\n", e.what()); + // TIFFClose(pTiffHandle); + } + TIFFClose(pTiffHandle); +} + +void G4Tiff::except(bool condition, const std::string & message) +{ + if (!condition) + throw std::runtime_error("Error " + message); +} diff --git a/hgdriver/ImageProcess/G4Tiff.h b/hgdriver/ImageProcess/G4Tiff.h new file mode 100644 index 0000000..f94e884 --- /dev/null +++ b/hgdriver/ImageProcess/G4Tiff.h @@ -0,0 +1,41 @@ +#ifndef HUAGO_TIFF_H +#define HUAGO_TIFF_H +#include +#include +#include + +class G4Tiff +{ +public: + enum class Mode + { + FileMode, + MemoryMode + }; + G4Tiff(cv::Mat& mat, Mode mode, std::string path, int threshold=120,int res=200, int compression = COMPRESSION_CCITT_T6); + ~G4Tiff(); + + static uchar* load_mini_file(const char* file, size_t* bytes, void* (*mem_alloc)(size_t, const char*)); + +public: + /* + *ڴ洫ģʽʱѹͼȥ + */ + void GetCompressedData(std::vector& cmpeddata); + uchar* get_compressed_data(size_t* bytes, void* (*mem_alloc)(size_t, const char*)); + /* + * ļģʽʱʹ + */ + void SaveG4Tiff(); +private: + void save(cv::Mat& mat); +private: + void except(bool condition, const std::string& message = ""); + std::string m_tmppath; + int m_threshold; + int m_res; + int compression_; + Mode m_mode; + cv::Mat m_mat; +}; +#endif // !HUAGO_TIFF_H diff --git a/hgdriver/hgdev/hg_ipc.cpp b/hgdriver/hgdev/hg_ipc.cpp index 75a7156..9d8e258 100644 --- a/hgdriver/hgdev/hg_ipc.cpp +++ b/hgdriver/hgdev/hg_ipc.cpp @@ -12,6 +12,24 @@ #include #endif + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// memory management ... +void* allocate_memory(size_t bytes, const char* log_msg) +{ + bytes += 7; + bytes /= 8; + bytes *= 8; + + return new char[bytes]; +} +void free_memory(void* ptr) +{ + if (ptr) + delete[] ptr; +} + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // windows event ... #ifdef WIN32 diff --git a/hgdriver/hgdev/hg_ipc.h b/hgdriver/hgdev/hg_ipc.h index d5a0e7d..dcbb933 100644 --- a/hgdriver/hgdev/hg_ipc.h +++ b/hgdriver/hgdev/hg_ipc.h @@ -24,6 +24,13 @@ #include +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// memory management ... +void* allocate_memory(size_t bytes, const char* log_msg = ""); +void free_memory(void* ptr); + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + class platform_event { sem_t sem_; diff --git a/hgdriver/hgdev/hg_scanner.cpp b/hgdriver/hgdev/hg_scanner.cpp index 600de38..e8200c7 100644 --- a/hgdriver/hgdev/hg_scanner.cpp +++ b/hgdriver/hgdev/hg_scanner.cpp @@ -13,28 +13,25 @@ static int ui_default_callback(scanner_handle, int, void*, unsigned int*, void*) { return 0; } -static std::string bmp_821(unsigned char* bits/*bits data*/, int w, int h, int* lbytes, bool line_align_4,int black_white_image_threshold) +static std::string bmp_821(unsigned char* bits/*bits data*/, int w, int h, int* lbytes, bool line_align_4, int threashold) { - if (black_white_image_threshold <=0) - black_white_image_threshold =128; - static unsigned int g_bmp8_pallete[] = { - 0x00000000, 0x00800000, 0x00008000, 0x00808000, 0x00000080, 0x00800080, 0x00008080, 0x00c0c0c0, 0x00c0dcc0, 0x00a6caf0, 0x00402000, 0x00602000, 0x00802000, 0x00a02000, 0x00c02000, 0x00e02000 - , 0x00004000, 0x00204000, 0x00404000, 0x00604000, 0x00804000, 0x00a04000, 0x00c04000, 0x00e04000, 0x00006000, 0x00206000, 0x00406000, 0x00606000, 0x00806000, 0x00a06000, 0x00c06000, 0x00e06000 - , 0x00008000, 0x00208000, 0x00408000, 0x00608000, 0x00808000, 0x00a08000, 0x00c08000, 0x00e08000, 0x0000a000, 0x0020a000, 0x0040a000, 0x0060a000, 0x0080a000, 0x00a0a000, 0x00c0a000, 0x00e0a000 - , 0x0000c000, 0x0020c000, 0x0040c000, 0x0060c000, 0x0080c000, 0x00a0c000, 0x00c0c000, 0x00e0c000, 0x0000e000, 0x0020e000, 0x0040e000, 0x0060e000, 0x0080e000, 0x00a0e000, 0x00c0e000, 0x00e0e000 - , 0x00000040, 0x00200040, 0x00400040, 0x00600040, 0x00800040, 0x00a00040, 0x00c00040, 0x00e00040, 0x00002040, 0x00202040, 0x00402040, 0x00602040, 0x00802040, 0x00a02040, 0x00c02040, 0x00e02040 - , 0x00004040, 0x00204040, 0x00404040, 0x00604040, 0x00804040, 0x00a04040, 0x00c04040, 0x00e04040, 0x00006040, 0x00206040, 0x00406040, 0x00606040, 0x00806040, 0x00a06040, 0x00c06040, 0x00e06040 - , 0x00008040, 0x00208040, 0x00408040, 0x00608040, 0x00808040, 0x00a08040, 0x00c08040, 0x00e08040, 0x0000a040, 0x0020a040, 0x0040a040, 0x0060a040, 0x0080a040, 0x00a0a040, 0x00c0a040, 0x00e0a040 - , 0x0000c040, 0x0020c040, 0x0040c040, 0x0060c040, 0x0080c040, 0x00a0c040, 0x00c0c040, 0x00e0c040, 0x0000e040, 0x0020e040, 0x0040e040, 0x0060e040, 0x0080e040, 0x00a0e040, 0x00c0e040, 0x00e0e040 - , 0x00000080, 0x00200080, 0x00400080, 0x00600080, 0x00800080, 0x00a00080, 0x00c00080, 0x00e00080, 0x00002080, 0x00202080, 0x00402080, 0x00602080, 0x00802080, 0x00a02080, 0x00c02080, 0x00e02080 - , 0x00004080, 0x00204080, 0x00404080, 0x00604080, 0x00804080, 0x00a04080, 0x00c04080, 0x00e04080, 0x00006080, 0x00206080, 0x00406080, 0x00606080, 0x00806080, 0x00a06080, 0x00c06080, 0x00e06080 - , 0x00008080, 0x00208080, 0x00408080, 0x00608080, 0x00808080, 0x00a08080, 0x00c08080, 0x00e08080, 0x0000a080, 0x0020a080, 0x0040a080, 0x0060a080, 0x0080a080, 0x00a0a080, 0x00c0a080, 0x00e0a080 - , 0x0000c080, 0x0020c080, 0x0040c080, 0x0060c080, 0x0080c080, 0x00a0c080, 0x00c0c080, 0x00e0c080, 0x0000e080, 0x0020e080, 0x0040e080, 0x0060e080, 0x0080e080, 0x00a0e080, 0x00c0e080, 0x00e0e080 - , 0x000000c0, 0x002000c0, 0x004000c0, 0x006000c0, 0x008000c0, 0x00a000c0, 0x00c000c0, 0x00e000c0, 0x000020c0, 0x002020c0, 0x004020c0, 0x006020c0, 0x008020c0, 0x00a020c0, 0x00c020c0, 0x00e020c0 - , 0x000040c0, 0x002040c0, 0x004040c0, 0x006040c0, 0x008040c0, 0x00a040c0, 0x00c040c0, 0x00e040c0, 0x000060c0, 0x002060c0, 0x004060c0, 0x006060c0, 0x008060c0, 0x00a060c0, 0x00c060c0, 0x00e060c0 - , 0x000080c0, 0x002080c0, 0x004080c0, 0x006080c0, 0x008080c0, 0x00a080c0, 0x00c080c0, 0x00e080c0, 0x0000a0c0, 0x0020a0c0, 0x0040a0c0, 0x0060a0c0, 0x0080a0c0, 0x00a0a0c0, 0x00c0a0c0, 0x00e0a0c0 - , 0x0000c0c0, 0x0020c0c0, 0x0040c0c0, 0x0060c0c0, 0x0080c0c0, 0x00a0c0c0, 0x00fffbf0, 0x00a0a0a4, 0x00808080, 0x00ff0000, 0x0000ff00, 0x00ffff00, 0x000000ff, 0x00ff00ff, 0x0000ffff, 0x00ffffff + 0x00000000, 0x00800000, 0x00008000, 0x00808000, 0x00000080, 0x00800080, 0x00008080, 0x00c0c0c0, 0x00c0dcc0, 0x00a6caf0, 0x00402000, 0x00602000, 0x00802000, 0x00a02000, 0x00c02000, 0x00e02000 + , 0x00004000, 0x00204000, 0x00404000, 0x00604000, 0x00804000, 0x00a04000, 0x00c04000, 0x00e04000, 0x00006000, 0x00206000, 0x00406000, 0x00606000, 0x00806000, 0x00a06000, 0x00c06000, 0x00e06000 + , 0x00008000, 0x00208000, 0x00408000, 0x00608000, 0x00808000, 0x00a08000, 0x00c08000, 0x00e08000, 0x0000a000, 0x0020a000, 0x0040a000, 0x0060a000, 0x0080a000, 0x00a0a000, 0x00c0a000, 0x00e0a000 + , 0x0000c000, 0x0020c000, 0x0040c000, 0x0060c000, 0x0080c000, 0x00a0c000, 0x00c0c000, 0x00e0c000, 0x0000e000, 0x0020e000, 0x0040e000, 0x0060e000, 0x0080e000, 0x00a0e000, 0x00c0e000, 0x00e0e000 + , 0x00000040, 0x00200040, 0x00400040, 0x00600040, 0x00800040, 0x00a00040, 0x00c00040, 0x00e00040, 0x00002040, 0x00202040, 0x00402040, 0x00602040, 0x00802040, 0x00a02040, 0x00c02040, 0x00e02040 + , 0x00004040, 0x00204040, 0x00404040, 0x00604040, 0x00804040, 0x00a04040, 0x00c04040, 0x00e04040, 0x00006040, 0x00206040, 0x00406040, 0x00606040, 0x00806040, 0x00a06040, 0x00c06040, 0x00e06040 + , 0x00008040, 0x00208040, 0x00408040, 0x00608040, 0x00808040, 0x00a08040, 0x00c08040, 0x00e08040, 0x0000a040, 0x0020a040, 0x0040a040, 0x0060a040, 0x0080a040, 0x00a0a040, 0x00c0a040, 0x00e0a040 + , 0x0000c040, 0x0020c040, 0x0040c040, 0x0060c040, 0x0080c040, 0x00a0c040, 0x00c0c040, 0x00e0c040, 0x0000e040, 0x0020e040, 0x0040e040, 0x0060e040, 0x0080e040, 0x00a0e040, 0x00c0e040, 0x00e0e040 + , 0x00000080, 0x00200080, 0x00400080, 0x00600080, 0x00800080, 0x00a00080, 0x00c00080, 0x00e00080, 0x00002080, 0x00202080, 0x00402080, 0x00602080, 0x00802080, 0x00a02080, 0x00c02080, 0x00e02080 + , 0x00004080, 0x00204080, 0x00404080, 0x00604080, 0x00804080, 0x00a04080, 0x00c04080, 0x00e04080, 0x00006080, 0x00206080, 0x00406080, 0x00606080, 0x00806080, 0x00a06080, 0x00c06080, 0x00e06080 + , 0x00008080, 0x00208080, 0x00408080, 0x00608080, 0x00808080, 0x00a08080, 0x00c08080, 0x00e08080, 0x0000a080, 0x0020a080, 0x0040a080, 0x0060a080, 0x0080a080, 0x00a0a080, 0x00c0a080, 0x00e0a080 + , 0x0000c080, 0x0020c080, 0x0040c080, 0x0060c080, 0x0080c080, 0x00a0c080, 0x00c0c080, 0x00e0c080, 0x0000e080, 0x0020e080, 0x0040e080, 0x0060e080, 0x0080e080, 0x00a0e080, 0x00c0e080, 0x00e0e080 + , 0x000000c0, 0x002000c0, 0x004000c0, 0x006000c0, 0x008000c0, 0x00a000c0, 0x00c000c0, 0x00e000c0, 0x000020c0, 0x002020c0, 0x004020c0, 0x006020c0, 0x008020c0, 0x00a020c0, 0x00c020c0, 0x00e020c0 + , 0x000040c0, 0x002040c0, 0x004040c0, 0x006040c0, 0x008040c0, 0x00a040c0, 0x00c040c0, 0x00e040c0, 0x000060c0, 0x002060c0, 0x004060c0, 0x006060c0, 0x008060c0, 0x00a060c0, 0x00c060c0, 0x00e060c0 + , 0x000080c0, 0x002080c0, 0x004080c0, 0x006080c0, 0x008080c0, 0x00a080c0, 0x00c080c0, 0x00e080c0, 0x0000a0c0, 0x0020a0c0, 0x0040a0c0, 0x0060a0c0, 0x0080a0c0, 0x00a0a0c0, 0x00c0a0c0, 0x00e0a0c0 + , 0x0000c0c0, 0x0020c0c0, 0x0040c0c0, 0x0060c0c0, 0x0080c0c0, 0x00a0c0c0, 0x00fffbf0, 0x00a0a0a4, 0x00808080, 0x00ff0000, 0x0000ff00, 0x00ffff00, 0x000000ff, 0x00ff00ff, 0x0000ffff, 0x00ffffff }; int l = (w + 31) / 32 * 4, size = l * h, @@ -61,7 +58,7 @@ static std::string bmp_821(unsigned char* bits/*bits data*/, int w, int h, int* v <<= 1; unsigned char pixel = ((pallete[bits[j]] & 0x0ff) + ((pallete[bits[j]] >> 8) & 0x0ff) + ((pallete[bits[j]] >> 16) & 0x0ff)) / 3; - if (pixel >= 128) + if (pixel >= threashold) v |= 1; if ((j + 1) % 8 == 0) { @@ -69,7 +66,7 @@ static std::string bmp_821(unsigned char* bits/*bits data*/, int w, int h, int* v = 0; } } - if (v) + if (w % 8) { v <<= 8 - (w % 8); *dst++ = v; @@ -95,7 +92,7 @@ hg_scanner::hg_scanner(ScannerSerial serial , fractate_level_(50), ui_ev_cb_(ui_default_callback), scan_life_(NULL) , notify_setting_result_(false), user_cancel_(false), cb_mem_(true), test_1_paper_(false) , setting_count_(0),img_type_(""), online_(false),is_quality_(-1),is_color_fill(false),is_multiout(false),save_multiout(OPTION_VALUE_DLSC_CS_HD_HB) - , final_img_index_(0), custom_area_(false),save_sizecheck(false) + , final_img_index_(0), custom_area_(false),save_sizecheck(false), bw_threshold_(128) { final_path_ = hg_log::ini_get("paths", "final_img"); if(final_path_.empty()) @@ -113,9 +110,6 @@ hg_scanner::hg_scanner(ScannerSerial serial custom_gamma_val_ = new SANE_Gamma; memset(custom_gamma_val_, 0, sizeof(SANE_Gamma)); -#ifdef MAPPING_FUNCTION_IN_BASE - init_setting_map(setting_map_, ARRAY_SIZE(setting_map_)); -#endif paper_size_mm_.cx = 210; paper_size_mm_.cy = 297; @@ -226,11 +220,6 @@ int hg_scanner::save_2_tempory_file(std::shared_ptr> data, std return ret; } -void hg_scanner::init_setting_map(int* setting_map, int count) -{ - for (int i = 0; i < count; ++i) - setting_map[i] = -1; -} void hg_scanner::set_setting_map(int sn, const char* title) { std::string val(title); @@ -243,118 +232,123 @@ void hg_scanner::set_setting_map(int sn, const char* title) //VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "title: '%s', val: '%s'\n", title, val.c_str()); if (val == OPTION_TITLE_HFMRSZ) - setting_map_[HG_BASE_SETTING_INDEX_RESTORE_DEFAULT_SETTINGS] = sn; + setting_map_[sn] = &hg_scanner::setting_restore; else if (val == OPTION_TITLE_BZ) - setting_map_[HG_BASE_SETTING_INDEX_HELP] = sn; + setting_map_[sn] = &hg_scanner::setting_help; else if (val == OPTION_TITLE_YSMS) - setting_map_[HG_BASE_SETTING_INDEX_COLOR_MODE] = sn; + setting_map_[sn] = &hg_scanner::setting_color_mode; else if (val == OPTION_TITLE_DLSC) - setting_map_[HG_BASE_SETTING_INDEX_MULTI_OUT] = sn; + setting_map_[sn] = &hg_scanner::setting_multi_out; else if (val == OPTION_TITLE_DLSCLX) - setting_map_[HG_BASE_SETTING_INDEX_MULTI_OUT_TYPE] = sn; + setting_map_[sn] = &hg_scanner::setting_multi_out_type; else if (val == OPTION_TITLE_HDHHBTX_CS) - setting_map_[HG_BASE_SETTING_INDEX_ERASE_COLOR] = sn; + setting_map_[sn] = &hg_scanner::setting_rid_color; else if (val == OPTION_TITLE_24WCSTX_DLSCCH) - setting_map_[HG_BASE_SETTING_INDEX_ERASE_MULTI_OUT_RED] = sn; + setting_map_[sn] = &hg_scanner::setting_rid_multi_red; else if (val == OPTION_TITLE_24WCSTX_DTKCH) - setting_map_[HG_BASE_SETTING_INDEX_ERASE_ANSWER_RED] = sn; + setting_map_[sn] = &hg_scanner::setting_rid_answer_red; else if (val == OPTION_TITLE_BJYC) - setting_map_[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND] = sn; + setting_map_[sn] = &hg_scanner::setting_erase_background; else if (val == OPTION_TITLE_BJSCFDFW) - setting_map_[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND_RANGE] = sn; + setting_map_[sn] = &hg_scanner::setting_erase_background_range; else if (val == OPTION_TITLE_HBTXZDYH) - setting_map_[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE] = sn; + setting_map_[sn] = &hg_scanner::setting_noise_optimize; else if (val == OPTION_TITLE_ZDYHCC) - setting_map_[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE_SIZE] = sn; + setting_map_[sn] = &hg_scanner::setting_noise_optimize_range; else if (val == OPTION_TITLE_ZZCC) - setting_map_[HG_BASE_SETTING_INDEX_PAPER] = sn; + setting_map_[sn] = &hg_scanner::setting_paper; else if (val == OPTION_TITLE_CCJC) - setting_map_[HG_BASE_SETTING_INDEX_PAPER_SIZE_CHECK] = sn; + setting_map_[sn] = &hg_scanner::setting_paper_check; else if (val == OPTION_TITLE_ZDYSMQY) - setting_map_[HG_BASE_SETTING_INDEX_IS_CUSTOM_AREA] = sn; + setting_map_[sn] = &hg_scanner::setting_is_custom_area; else if (val == OPTION_TITLE_SMQYZCmm) - setting_map_[HG_BASE_SETTING_INDEX_CUSTOM_AREA_LEFT] = sn; + setting_map_[sn] = &hg_scanner::setting_custom_area_left; else if (val == OPTION_TITLE_SMQYYCmm) - setting_map_[HG_BASE_SETTING_INDEX_CUSTOM_AREA_RIGHT] = sn; + setting_map_[sn] = &hg_scanner::setting_custom_area_right; else if (val == OPTION_TITLE_SMQYSCmm) - setting_map_[HG_BASE_SETTING_INDEX_CUSTOM_AREA_TOP] = sn; + setting_map_[sn] = &hg_scanner::setting_custom_area_top; else if (val == OPTION_TITLE_SMQYXCmm) - setting_map_[HG_BASE_SETTING_INDEX_CUSTOM_AREA_BOTTOM] = sn; + setting_map_[sn] = &hg_scanner::setting_custom_area_bottom; else if (val == OPTION_TITLE_SMYM) - setting_map_[HG_BASE_SETTING_INDEX_PAGE] = sn; + setting_map_[sn] = &hg_scanner::setting_page; else if (val == OPTION_TITLE_TGKBYLMD) - setting_map_[HG_BASE_SETTING_INDEX_PAGE_OMIT_EMPTY_LEVEL] = sn; + setting_map_[sn] = &hg_scanner::setting_page_omit_empty; else if (val == OPTION_TITLE_FBL) - setting_map_[HG_BASE_SETTING_INDEX_RESOLUTION] = sn; + setting_map_[sn] = &hg_scanner::setting_resolution; else if (val == OPTION_TITLE_HZ) - setting_map_[HG_BASE_SETTING_INDEX_IMG_QUALITY] = sn; + setting_map_[sn] = &hg_scanner::setting_img_quality; else if (val == OPTION_TITLE_JHZFM) - setting_map_[HG_BASE_SETTING_INDEX_EXCHANGE] = sn; + setting_map_[sn] = &hg_scanner::setting_exchagnge; else if (val == OPTION_TITLE_TXCF) - setting_map_[HG_BASE_SETTING_INDEX_SPLIT] = sn; + setting_map_[sn] = &hg_scanner::setting_split_image; else if (val == OPTION_TITLE_ZDJP) - setting_map_[HG_BASE_SETTING_INDEX_AUTO_CORRECT] = sn; + setting_map_[sn] = &hg_scanner::setting_automatic_skew; else if (val == OPTION_TITLE_CKYC) - setting_map_[HG_BASE_SETTING_INDEX_RID_HOLE] = sn; + setting_map_[sn] = &hg_scanner::setting_rid_hole; else if (val == OPTION_TITLE_CKSSFWZFMBL) - setting_map_[HG_BASE_SETTING_INDEX_RID_HOLE_RANGE] = sn; + setting_map_[sn] = &hg_scanner::setting_rid_hoe_range; else if (val == OPTION_TITLE_QYSDQX) - setting_map_[HG_BASE_SETTING_INDEX_IS_CUSTOM_GAMMA] = sn; + setting_map_[sn] = &hg_scanner::setting_is_custom_gamma; else if (val == OPTION_TITLE_LDZ) - setting_map_[HG_BASE_SETTING_INDEX_BRIGHT] = sn; + setting_map_[sn] = &hg_scanner::setting_bright; else if (val == OPTION_TITLE_DBD) - setting_map_[HG_BASE_SETTING_INDEX_CONTRAST] = sn; + setting_map_[sn] = &hg_scanner::setting_contrast; else if (val == OPTION_TITLE_GMZ) - setting_map_[HG_BASE_SETTING_INDEX_GAMMA] = sn; + setting_map_[sn] = &hg_scanner::setting_gamma; else if (val == OPTION_TITLE_RHYMH) - setting_map_[HG_BASE_SETTING_INDEX_SHARPEN] = sn; + setting_map_[sn] = &hg_scanner::setting_sharpen; else if (val == OPTION_TITLE_SSYZ) - setting_map_[HG_BASE_SETTING_INDEX_DARK_SAMPLE] = sn; + setting_map_[sn] = &hg_scanner::setting_dark_sample; else if (val == OPTION_TITLE_XCHK) - setting_map_[HG_BASE_SETTING_INDEX_ERASE_BLACK_FRAME] = sn; + setting_map_[sn] = &hg_scanner::setting_erase_black_frame; else if (val == OPTION_TITLE_YZ) - setting_map_[HG_BASE_SETTING_INDEX_THRESHOLD] = sn; + setting_map_[sn] = &hg_scanner::setting_threshold; else if (val == OPTION_TITLE_BJKZDJ) - setting_map_[HG_BASE_SETTING_INDEX_ANTI_NOISE_LEVEL] = sn; + setting_map_[sn] = &hg_scanner::setting_anti_noise; else if (val == OPTION_TITLE_BYSJ) - setting_map_[HG_BASE_SETTING_INDEX_MARGIN] = sn; + setting_map_[sn] = &hg_scanner::setting_margin; else if (val == OPTION_TITLE_BJTCFS) - setting_map_[HG_BASE_SETTING_INDEX_FILL_BACKGROUND] = sn; + setting_map_[sn] = &hg_scanner::setting_filling_background; else if (val == OPTION_TITLE_FZST) - setting_map_[HG_BASE_SETTING_INDEX_PERMEATE] = sn; + setting_map_[sn] = &hg_scanner::setting_is_permeate; else if (val == OPTION_TITLE_FZSTDJ) - setting_map_[HG_BASE_SETTING_INDEX_PERMEATE_LV] = sn; + setting_map_[sn] = &hg_scanner::setting_is_permeate_lv; else if (val == OPTION_TITLE_QCMW) - setting_map_[HG_BASE_SETTING_INDEX_REMOVE_MORR] = sn; + setting_map_[sn] = &hg_scanner::setting_remove_morr; else if (val == OPTION_TITLE_CWKS) - setting_map_[HG_BASE_SETTING_INDEX_ERROR_EXTENTION] = sn; + setting_map_[sn] = &hg_scanner::setting_error_extention; else if (val == OPTION_TITLE_CWW) - setting_map_[HG_BASE_SETTING_INDEX_REMOVE_TXTTURE] = sn; + setting_map_[sn] = &hg_scanner::setting_remove_texture; else if (val == OPTION_TITLE_CSBJC) - setting_map_[HG_BASE_SETTING_INDEX_ULTRASONIC_CHECK] = sn; + setting_map_[sn] = &hg_scanner::setting_ultrasonic_check; else if (val == OPTION_TITLE_ZDJC) - setting_map_[HG_BASE_SETTING_INDEX_STAPLE_CHECK] = sn; + setting_map_[sn] = &hg_scanner::setting_staple_check; else if (val == OPTION_TITLE_SMZS) - setting_map_[HG_BASE_SETTING_INDEX_SCAN_MODE] = sn; + { + setting_map_[sn] = &hg_scanner::setting_scan_mode; + id_scan_mode_ = sn; + } else if (val == OPTION_TITLE_SMSL) - setting_map_[HG_BASE_SETTING_INDEX_SCAN_COUNT] = sn; + { + setting_map_[sn] = &hg_scanner::setting_scan_count; + id_scan_count_ = sn; + } else if (val == OPTION_TITLE_WGFX) - setting_map_[HG_BASE_SETTING_INDEX_TEXT_DIRECTION] = sn; + setting_map_[sn] = &hg_scanner::setting_text_direction; else if (val == OPTION_TITLE_BMXZ180) - setting_map_[HG_BASE_SETTING_INDEX_ROTATE_BKG_180] = sn; + setting_map_[sn] = &hg_scanner::setting_rotate_bkg_180; else if (val == OPTION_TITLE_ZJJC) - setting_map_[HG_BASE_SETTING_INDEX_FRACTATE_CHECK] = sn; + setting_map_[sn] = &hg_scanner::setting_fractate_check; else if (val == OPTION_TITLE_ZJDX) - setting_map_[HG_BASE_SETTING_INDEX_FRACTATE_CHECK_LEVEL] = sn; + setting_map_[sn] = &hg_scanner::setting_fractate_check_level; else if (val == OPTION_TITLE_WXJC) - setting_map_[HG_BASE_SETTING_INDEX_SKEW_CHECK] = sn; + setting_map_[sn] = &hg_scanner::setting_skew_check; else if (val == OPTION_TITLE_WXRRD) - setting_map_[HG_BASE_SETTING_INDEX_SKEW_CHECK_LEVEL] = sn; + setting_map_[sn] = &hg_scanner::setting_skew_check_level; else if (val == OPTION_TITLE_SCTC) - setting_map_[HG_BASE_SETTING_INDEX_COLOR_FILL] = sn; - else if (val ==OPTION_TITLE_HBTXYZ) - setting_map_[HG_BASE_SETTING_INDEX_BLACK_WGITE_THRESHOLD] = sn; - + setting_map_[sn] = &hg_scanner::setting_color_fill; + else if(val == OPTION_TITLE_HBTXYZ) + setting_map_[sn] = &hg_scanner::setting_black_white_threshold; } void hg_scanner::thread_handle_usb(void) { @@ -872,7 +866,24 @@ int hg_scanner::set_color_change(void) return SCANNER_ERR_OK; } -int hg_scanner::setting_restore(void* data) +int hg_scanner::invoke_setting_xxx(int(hg_scanner::*func)(int, void*), void* data) +{ + int ret = SCANNER_ERR_DEVICE_NOT_SUPPORT; + + map::iterator it = setting_map_.begin(); + while (it != setting_map_.end()) + { + if (it->second == &hg_scanner::setting_restore) + { + ret = (this->*it->second)(it->first, data); + break; + } + } + + return ret; +} + +int hg_scanner::setting_restore(int sn, void* data) { // restore ... int count = 0; @@ -885,7 +896,7 @@ int hg_scanner::setting_restore(void* data) return SCANNER_ERR_CONFIGURATION_CHANGED; } -int hg_scanner::setting_help(void* data) +int hg_scanner::setting_help(int sn, void* data) { int ret = SCANNER_ERR_OK; std::string helpfile = helpfile_; @@ -914,14 +925,14 @@ int hg_scanner::setting_help(void* data) VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"App_Help_pdf path is:%s system is:%d\r\n",helpfile.c_str()); return ret; } -int hg_scanner::setting_color_mode(void* data) +int hg_scanner::setting_color_mode(int sn, void* data) { std::string str((char*)data); int old = image_prc_param_.bits.color_mode, sub = SCANNER_ERR_OK, val = 0, ret = SCANNER_ERR_OK; - bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_COLOR_MODE], str); + bool exact = check_range(sn, str); val = image_prc_param_.bits.color_mode = match_best_color_mode(str, NULL); @@ -953,7 +964,7 @@ int hg_scanner::setting_color_mode(void* data) return ret; } -int hg_scanner::setting_multi_out(void *data) +int hg_scanner::setting_multi_out(int sn, void*data) { is_multiout = *((bool*)data); int val = image_prc_param_.bits.color_mode; @@ -970,13 +981,13 @@ int hg_scanner::setting_multi_out(void *data) return SCANNER_ERR_OK; } -int hg_scanner::setting_multi_out_type(void *data) +int hg_scanner::setting_multi_out_type(int sn, void*data) { int ret = SCANNER_ERR_OK; std::string str((char*)data); - bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_MULTI_OUT], str); + bool exact = check_range(sn, str); int color; image_prc_param_.bits.multi_out = match_best_multi_out(str,NULL); @@ -991,13 +1002,13 @@ int hg_scanner::setting_multi_out_type(void *data) on_color_mode_changed(color); return ret; } -int hg_scanner::setting_rid_color(void* data) +int hg_scanner::setting_rid_color(int sn, void* data) { std::string str((char*)data); int ret = SCANNER_ERR_OK, color = -1, old = image_prc_param_.bits.rid_color; - bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_ERASE_COLOR], str); + bool exact = check_range(sn, str); image_prc_param_.bits.rid_color = match_best_rid_color(str, NULL); @@ -1012,30 +1023,30 @@ int hg_scanner::setting_rid_color(void* data) return ret; } -int hg_scanner::setting_rid_multi_red(void* data) +int hg_scanner::setting_rid_multi_red(int sn, void* data) { image_prc_param_.bits.rid_red = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_rid_answer_red(void* data) +int hg_scanner::setting_rid_answer_red(int sn, void* data) { image_prc_param_.bits.rid_answer_red = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_erase_background(void* data) +int hg_scanner::setting_erase_background(int sn, void* data) { image_prc_param_.bits.erase_bakground = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_erase_background_range(void* data) +int hg_scanner::setting_erase_background_range(int sn, void* data) { int ret = SCANNER_ERR_OK; erase_bkg_range_ = *((int*)data); - if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND_RANGE], erase_bkg_range_)) + if (!check_range(sn, erase_bkg_range_)) { ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = erase_bkg_range_; @@ -1043,18 +1054,18 @@ int hg_scanner::setting_erase_background_range(void* data) return ret; } -int hg_scanner::setting_noise_optimize(void* data) +int hg_scanner::setting_noise_optimize(int sn, void* data) { image_prc_param_.bits.noise_optimize = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_noise_optimize_range(void* data) +int hg_scanner::setting_noise_optimize_range(int sn, void* data) { int ret = SCANNER_ERR_OK; noise_range_ = *((int*)data); - if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE_SIZE], noise_range_)) + if (!check_range(sn, noise_range_)) { ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = noise_range_; @@ -1062,10 +1073,10 @@ int hg_scanner::setting_noise_optimize_range(void* data) return ret; } -int hg_scanner::setting_paper(void* data) +int hg_scanner::setting_paper(int sn, void* data) { std::string paper((char*)data); - bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_PAPER], paper); + bool exact = check_range(sn, paper); int ret = SCANNER_ERR_OK, sub = SCANNER_ERR_OK, val = 0, old = image_prc_param_.bits.paper; @@ -1088,7 +1099,7 @@ int hg_scanner::setting_paper(void* data) if (save_sizecheck) { - setting_paper_check(&save_sizecheck); + invoke_setting_xxx(&hg_scanner::setting_paper_check, &save_sizecheck); } VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change paper from %s to %s = %s\n", paper_string(old).c_str(), (char*)data, hg_scanner_err_name(ret)); @@ -1100,7 +1111,7 @@ int hg_scanner::setting_paper(void* data) return ret; } -int hg_scanner::setting_paper_check(void* data) +int hg_scanner::setting_paper_check(int sn, void* data) { bool use = *((bool*)data); @@ -1113,10 +1124,10 @@ int hg_scanner::setting_paper_check(void* data) return ret; } -int hg_scanner::setting_page(void* data) +int hg_scanner::setting_page(int sn, void* data) { std::string val((char*)data); - bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_PAGE], val); + bool exact = check_range(sn, val); int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change page from %s to %s = %s\n", page_string(image_prc_param_.bits.page).c_str(), (char*)data, hg_scanner_err_name(ret)); @@ -1126,12 +1137,12 @@ int hg_scanner::setting_page(void* data) return ret; } -int hg_scanner::setting_page_omit_empty(void* data) +int hg_scanner::setting_page_omit_empty(int sn, void* data) { int ret = SCANNER_ERR_OK; omit_empty_level_ = *((int*)data); - if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_PAGE_OMIT_EMPTY_LEVEL], omit_empty_level_)) + if (!check_range(sn, omit_empty_level_)) { ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = omit_empty_level_; @@ -1139,14 +1150,14 @@ int hg_scanner::setting_page_omit_empty(void* data) return ret; } -int hg_scanner::setting_resolution(void* data) +int hg_scanner::setting_resolution(int sn, void* data) { int ret = SCANNER_ERR_OK, old = resolution_, sub = SCANNER_ERR_OK; resolution_ = *((int*)data); - if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_RESOLUTION], resolution_)) + if (!check_range(sn, resolution_)) ret = SCANNER_ERR_NOT_EXACT; sub = on_resolution_changed(resolution_); if (sub == SCANNER_ERR_NOT_EXACT) @@ -1159,37 +1170,37 @@ int hg_scanner::setting_resolution(void* data) return ret; } -int hg_scanner::setting_exchagnge(void* data) +int hg_scanner::setting_exchagnge(int sn, void* data) { image_prc_param_.bits.exchange = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_split_image(void* data) +int hg_scanner::setting_split_image(int sn, void* data) { image_prc_param_.bits.split = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_automatic_skew(void* data) +int hg_scanner::setting_automatic_skew(int sn, void* data) { // automatic_skew_detection_ = *((bool*)data); image_prc_param_.bits.automatic_skew = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_rid_hole(void* data) +int hg_scanner::setting_rid_hole(int sn, void* data) { image_prc_param_.bits.rid_hole = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_rid_hoe_range(void* data) +int hg_scanner::setting_rid_hoe_range(int sn, void* data) { int ret = SCANNER_ERR_OK; rid_hole_range_ = *((double*)data); - if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_RID_HOLE_RANGE], rid_hole_range_)) + if (!check_range(sn, rid_hole_range_)) { ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = rid_hole_range_; @@ -1199,12 +1210,12 @@ int hg_scanner::setting_rid_hoe_range(void* data) return ret; } -int hg_scanner::setting_bright(void* data) +int hg_scanner::setting_bright(int sn, void* data) { int ret = SCANNER_ERR_OK; bright_ = *((int*)data); - if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_BRIGHT], bright_)) + if (!check_range(sn, bright_)) { ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = bright_; @@ -1212,12 +1223,12 @@ int hg_scanner::setting_bright(void* data) return ret; } -int hg_scanner::setting_contrast(void* data) +int hg_scanner::setting_contrast(int sn, void* data) { int ret = SCANNER_ERR_OK; contrast_ = *((int*)data); - if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_CONTRAST], contrast_)) + if (!check_range(sn, contrast_)) { ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = contrast_; @@ -1225,12 +1236,12 @@ int hg_scanner::setting_contrast(void* data) return ret; } -int hg_scanner::setting_gamma(void* data) +int hg_scanner::setting_gamma(int sn, void* data) { int ret = SCANNER_ERR_OK; gamma_ = *((double*)data); - if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_GAMMA], gamma_)) + if (!check_range(sn, gamma_)) { ret = SCANNER_ERR_NOT_EXACT; *((double*)data) = gamma_; @@ -1238,11 +1249,11 @@ int hg_scanner::setting_gamma(void* data) return ret; } -int hg_scanner::setting_sharpen(void* data) +int hg_scanner::setting_sharpen(int sn, void* data) { std::string str((char*)data); int ret = SCANNER_ERR_OK; - bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_SHARPEN], str); + bool exact = check_range(sn, str); VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Change sharpen from %s to %s = ", sharpen_string(image_prc_param_.bits.sharpen).c_str(), (char*)data); @@ -1256,24 +1267,24 @@ int hg_scanner::setting_sharpen(void* data) return ret; } -int hg_scanner::setting_dark_sample(void* data) +int hg_scanner::setting_dark_sample(int sn, void* data) { image_prc_param_.bits.dark_sample = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_erase_black_frame(void* data) +int hg_scanner::setting_erase_black_frame(int sn, void* data) { image_prc_param_.bits.erase_black_frame = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_threshold(void* data) +int hg_scanner::setting_threshold(int sn, void* data) { int ret = SCANNER_ERR_OK; threshold_ = *((int*)data); - if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_THRESHOLD], threshold_)) + if (!check_range(sn, threshold_)) { ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = threshold_; @@ -1281,12 +1292,12 @@ int hg_scanner::setting_threshold(void* data) return ret; } -int hg_scanner::setting_anti_noise(void* data) +int hg_scanner::setting_anti_noise(int sn, void* data) { int ret = SCANNER_ERR_OK; anti_noise_ = *((int*)data); - if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_ANTI_NOISE_LEVEL], anti_noise_)) + if (!check_range(sn, anti_noise_)) { ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = anti_noise_; @@ -1294,12 +1305,12 @@ int hg_scanner::setting_anti_noise(void* data) return ret; } -int hg_scanner::setting_margin(void* data) +int hg_scanner::setting_margin(int sn, void* data) { int ret = SCANNER_ERR_OK; margin_ = *((int*)data); - if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_MARGIN], margin_)) + if (!check_range(sn, margin_)) { ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = margin_; @@ -1307,10 +1318,10 @@ int hg_scanner::setting_margin(void* data) return ret; } -int hg_scanner::setting_filling_background(void* data) +int hg_scanner::setting_filling_background(int sn, void* data) { std::string str((char*)data); - bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_FILL_BACKGROUND], str); + bool exact = check_range(sn, str); int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; image_prc_param_.bits.fill_background = match_best_fill_background(str, NULL); @@ -1322,16 +1333,16 @@ int hg_scanner::setting_filling_background(void* data) return ret; } -int hg_scanner::setting_is_permeate(void* data) +int hg_scanner::setting_is_permeate(int sn, void* data) { image_prc_param_.bits.is_permeate = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_is_permeate_lv(void* data) +int hg_scanner::setting_is_permeate_lv(int sn, void* data) { int ret = SCANNER_ERR_OK; std::string str((char*)data); - bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_PERMEATE_LV], str); + bool exact = check_range(sn, str); VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Change is_permeate_lv from %s to %s = ", is_permaeate_string(image_prc_param_.bits.is_permeate_lv_).c_str(), (char*)data); image_prc_param_.bits.is_permeate_lv_ = match_best_permaeate_lv(str, NULL); @@ -1346,25 +1357,25 @@ int hg_scanner::setting_is_permeate_lv(void* data) return ret; } -int hg_scanner::setting_remove_morr(void* data) +int hg_scanner::setting_remove_morr(int sn, void* data) { image_prc_param_.bits.remove_morr = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_error_extention(void* data) +int hg_scanner::setting_error_extention(int sn, void* data) { image_prc_param_.bits.error_extention = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_remove_texture(void* data) +int hg_scanner::setting_remove_texture(int sn, void* data) { image_prc_param_.bits.remove_txtture = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_ultrasonic_check(void* data) +int hg_scanner::setting_ultrasonic_check(int sn, void* data) { bool use = *((bool*)data); int ret = on_ultrasonic_check_changed(use); @@ -1374,7 +1385,7 @@ int hg_scanner::setting_ultrasonic_check(void* data) return ret; } -int hg_scanner::setting_staple_check(void* data) +int hg_scanner::setting_staple_check(int sn, void* data) { bool use = *((bool*)data); int ret = on_staple_check_changed(use); @@ -1384,10 +1395,10 @@ int hg_scanner::setting_staple_check(void* data) return ret; } -int hg_scanner::setting_scan_mode(void* data) +int hg_scanner::setting_scan_mode(int sn, void* data) { std::string str((char*)data); - bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_SCAN_MODE], str); + bool exact = check_range(sn, str); int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; if (strcmp(str.c_str(), OPTION_VALUE_SMZS_LXSM) == 0) @@ -1397,7 +1408,7 @@ int hg_scanner::setting_scan_mode(void* data) else { char key[20]; - sprintf(key, "%d", setting_map_[HG_BASE_SETTING_INDEX_SCAN_COUNT]); + sprintf(key, "%d", id_scan_count_); setting_jsn_.at(key).at("cur").get_to(scan_count_); } @@ -1405,14 +1416,18 @@ int hg_scanner::setting_scan_mode(void* data) return ret; } -int hg_scanner::setting_scan_count(void* data) +int hg_scanner::setting_scan_count(int sn, void* data) { int ret = SCANNER_ERR_OK; - char key[20]; std::string val(""); - sprintf(key, "%d", setting_map_[HG_BASE_SETTING_INDEX_SCAN_MODE]); - setting_jsn_.at(key).at("cur").get_to(val); + if (id_scan_mode_ != -1) + { + char key[20]; + + sprintf(key, "%d", id_scan_mode_); + setting_jsn_.at(key).at("cur").get_to(val); + } if (val == OPTION_VALUE_SMZS_LXSM) { scan_count_ = -1; @@ -1426,10 +1441,10 @@ int hg_scanner::setting_scan_count(void* data) return ret; } -int hg_scanner::setting_text_direction(void* data) +int hg_scanner::setting_text_direction(int sn, void* data) { std::string str((char*)data); - bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_TEXT_DIRECTION], str); + bool exact = check_range(sn, str); int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change text direction from '%s' to '%s' = %s\n", text_direction_string(image_prc_param_.bits.text_direction).c_str() @@ -1440,24 +1455,24 @@ int hg_scanner::setting_text_direction(void* data) return ret; } -int hg_scanner::setting_rotate_bkg_180(void* data) +int hg_scanner::setting_rotate_bkg_180(int sn, void* data) { image_prc_param_.bits.rotate_back_180 = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_fractate_check(void* data) +int hg_scanner::setting_fractate_check(int sn, void* data) { image_prc_param_.bits.fractate_check = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_fractate_check_level(void* data) +int hg_scanner::setting_fractate_check_level(int sn, void* data) { int ret = SCANNER_ERR_OK; fractate_level_ = *((int*)data); - if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_FRACTATE_CHECK_LEVEL], fractate_level_)) + if (!check_range(sn, fractate_level_)) { ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = fractate_level_; @@ -1465,7 +1480,7 @@ int hg_scanner::setting_fractate_check_level(void* data) return ret; } -int hg_scanner::setting_skew_check(void* data) +int hg_scanner::setting_skew_check(int sn, void* data) { bool use = *((bool*)data); int ret = on_skew_check_changed(use); @@ -1475,10 +1490,10 @@ int hg_scanner::setting_skew_check(void* data) return ret; } -int hg_scanner::setting_skew_check_level(void* data) +int hg_scanner::setting_skew_check_level(int sn, void* data) { int level = *((int*)data); - bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_SKEW_CHECK_LEVEL], level); + bool exact = check_range(sn, level); int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT, sub = on_skew_check_level_changed(level); @@ -1491,13 +1506,13 @@ int hg_scanner::setting_skew_check_level(void* data) return ret; } -int hg_scanner::setting_is_custom_gamma(void* data) +int hg_scanner::setting_is_custom_gamma(int sn, void* data) { custom_gamma_ = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_custom_gamma_data(void* data) +int hg_scanner::setting_custom_gamma_data(int sn, void* data) { SANE_Gamma* gamma = (SANE_Gamma*)data; @@ -1505,13 +1520,13 @@ int hg_scanner::setting_custom_gamma_data(void* data) return SCANNER_ERR_OK; } -int hg_scanner::setting_is_custom_area(void* data) +int hg_scanner::setting_is_custom_area(int sn, void* data) { custom_area_ = *((bool*)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_custom_area_left(void* data) +int hg_scanner::setting_custom_area_left(int sn, void* data) { SANE_Fixed* v = (SANE_Fixed*)data; @@ -1519,7 +1534,7 @@ int hg_scanner::setting_custom_area_left(void* data) return SCANNER_ERR_OK; } -int hg_scanner::setting_custom_area_top(void* data) +int hg_scanner::setting_custom_area_top(int sn, void* data) { SANE_Fixed* v = (SANE_Fixed*)data; @@ -1527,7 +1542,7 @@ int hg_scanner::setting_custom_area_top(void* data) return SCANNER_ERR_OK; } -int hg_scanner::setting_custom_area_right(void* data) +int hg_scanner::setting_custom_area_right(int sn, void* data) { SANE_Fixed* v = (SANE_Fixed*)data; @@ -1535,7 +1550,7 @@ int hg_scanner::setting_custom_area_right(void* data) return SCANNER_ERR_OK; } -int hg_scanner::setting_custom_area_bottom(void* data) +int hg_scanner::setting_custom_area_bottom(int sn, void* data) { SANE_Fixed* v = (SANE_Fixed*)data; @@ -1545,10 +1560,10 @@ int hg_scanner::setting_custom_area_bottom(void* data) return SCANNER_ERR_OK; } -int hg_scanner::setting_img_quality(void *data) +int hg_scanner::setting_img_quality(int sn, void *data) { std::string str((char*)data); - bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_IMG_QUALITY], str); + bool exact = check_range(sn, str); int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change quality from '%s' to '%s' = %s\n", is_img_quality(is_quality_).c_str() , (char*)data, hg_scanner_err_name(ret)); @@ -1557,14 +1572,15 @@ int hg_scanner::setting_img_quality(void *data) return SCANNER_ERR_OK; } -int hg_scanner::setting_color_fill(void *data) +int hg_scanner::setting_color_fill(int sn, void*data) { is_color_fill = *((bool *)data); return SCANNER_ERR_OK; } -int hg_scanner::setting_black_white_threshold(void *data) +int hg_scanner::setting_black_white_threshold(int sn, void* data) { - black_white_image_threshold_ = *((int *)data); + bw_threshold_ = (unsigned char)(*(SANE_Int*)data); + return SCANNER_ERR_OK; } int hg_scanner::on_color_mode_changed(int& color_mode) @@ -1905,11 +1921,11 @@ int hg_scanner::save_final_image(hg_imgproc::LPIMGHEAD head, void* buf) if (img_conf_.pixtype == 0 || (is_1bit && is_multiout)) { int old = head->line_bytes; - bw = bmp_821((unsigned char*)buf, head->width, head->height, &head->line_bytes, async_io_,black_white_image_threshold_); + bw = bmp_821((unsigned char*)buf, head->width, head->height, &head->line_bytes, async_io_, bw_threshold_); buf = &bw[0]; head->channels = head->bits = 1; head->total_bytes = head->line_bytes * head->height; - VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "convert to 1-bit bmp(%d * %d), total = %u, len = %u , black_white_image_threshold_ =%d\n", head->width, head->height, head->total_bytes, bw.length(),black_white_image_threshold_); + VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "convert to 1-bit bmp(%d * %d), total = %u, len = %u , black_white_image_threshold_ =%d\n", head->width, head->height, head->total_bytes, bw.length(), bw_threshold_); } if (async_io_) @@ -2026,81 +2042,16 @@ int hg_scanner::close(bool force) } int hg_scanner::set_setting(int setting_no, void* data, int len) { - // NOTE: the array of 'func' must be ONE to ONE of the HG_BASE_SETTING_INDEX_xxx - int(hg_scanner:: * func[])(void*) = { &hg_scanner::setting_restore - , &hg_scanner::setting_help - , &hg_scanner::setting_multi_out - , &hg_scanner::setting_multi_out_type - , &hg_scanner::setting_color_mode - , &hg_scanner::setting_black_white_threshold - , &hg_scanner::setting_rid_color - , &hg_scanner::setting_rid_multi_red - , &hg_scanner::setting_rid_answer_red - , &hg_scanner::setting_erase_background - , &hg_scanner::setting_erase_background_range - , &hg_scanner::setting_noise_optimize - , &hg_scanner::setting_noise_optimize_range - , &hg_scanner::setting_paper - , &hg_scanner::setting_paper_check - , &hg_scanner::setting_is_custom_area - , &hg_scanner::setting_custom_area_left - , &hg_scanner::setting_custom_area_right - , &hg_scanner::setting_custom_area_top - , &hg_scanner::setting_custom_area_bottom - , &hg_scanner::setting_page - , &hg_scanner::setting_page_omit_empty - , &hg_scanner::setting_resolution - , &hg_scanner::setting_img_quality - , &hg_scanner::setting_exchagnge - , &hg_scanner::setting_split_image - , &hg_scanner::setting_automatic_skew - , &hg_scanner::setting_rid_hole - , &hg_scanner::setting_rid_hoe_range - , &hg_scanner::setting_is_custom_gamma // 2022-05-05 - , &hg_scanner::setting_bright - , &hg_scanner::setting_contrast - , &hg_scanner::setting_gamma - , &hg_scanner::setting_custom_gamma_data - , &hg_scanner::setting_sharpen - , &hg_scanner::setting_dark_sample - , &hg_scanner::setting_erase_black_frame - , &hg_scanner::setting_threshold - , &hg_scanner::setting_anti_noise - , &hg_scanner::setting_margin - , &hg_scanner::setting_filling_background - , &hg_scanner::setting_is_permeate - , &hg_scanner::setting_is_permeate_lv - , &hg_scanner::setting_color_fill - , &hg_scanner::setting_remove_morr - , &hg_scanner::setting_error_extention - , &hg_scanner::setting_remove_texture - , &hg_scanner::setting_ultrasonic_check - , &hg_scanner::setting_staple_check - , &hg_scanner::setting_scan_mode - , &hg_scanner::setting_scan_count - , &hg_scanner::setting_text_direction - , &hg_scanner::setting_rotate_bkg_180 - , &hg_scanner::setting_fractate_check - , &hg_scanner::setting_fractate_check_level - , &hg_scanner::setting_skew_check - , &hg_scanner::setting_skew_check_level - }; - - bool hit = false; + bool hit = setting_map_.count(setting_no) > 0; int ret = SCANNER_ERR_OUT_OF_RANGE; char sn[20]; - sprintf(sn, "%d", setting_no); - for (size_t i = 0; i < ARRAY_SIZE(func); ++i) + if (hit) { - if (setting_map_[i] == setting_no) - { - ret = (this->*func[i])(data); - hit = true; - break; - } + ret = (this->*setting_map_[setting_no])(setting_no, data); + sprintf(sn, "%d", setting_no); } - if (!hit) + else { VLOG_MINI_1(LOG_LEVEL_WARNING, "Setting %d is not found in base setting functions.\n", setting_no); ret = set_setting_value(setting_no, data, len); @@ -2365,9 +2316,12 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) { if (code == IO_CTRL_CODE_RESTORE_SETTINGS) { - setting_restore(data); + int ret = invoke_setting_xxx(&hg_scanner::setting_restore, data); - return SCANNER_ERR_CONFIGURATION_CHANGED; + if (ret == SCANNER_ERR_OK) + ret = SCANNER_ERR_CONFIGURATION_CHANGED; + + return ret; } else if (code == IO_CTRL_CODE_GET_DEFAULT_VALUE) { @@ -2470,7 +2424,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) *len = ser.size(); return SCANNER_ERR_INSUFFICIENT_MEMORY; } - if (data) + if(data) strcpy((char*)data, ser.c_str()); return SCANNER_ERR_OK; @@ -2483,7 +2437,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) *len = ip.size(); return SCANNER_ERR_INSUFFICIENT_MEMORY; } - if (data) + if(data) strcpy((char*)data, ip.c_str()); return SCANNER_ERR_OK; @@ -2582,6 +2536,24 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) *len = (size.cx & 0x0ffff) | ((size.cy & 0x0ffff) << 16); } + else if (code == IO_CTRL_CODE_CONVERT_IMAGE_FORMAT) + { + SANE_ImageFormatConvert *conv = (SANE_ImageFormatConvert*)data; + void* threshold = conv->dst.fmt.compress.detail; + int ret = SCANNER_ERR_OK; + + conv->dst.fmt.compress.detail = (void*)bw_threshold_; + ret = hg_imgproc::convert_image_file(conv); + conv->dst.fmt.compress.detail = threshold; + + return ret; + } + else if (code == IO_CTRL_CODE_FREE_MEMORY) + { + free_memory(data); + + return SCANNER_ERR_OK; + } return SCANNER_ERR_DEVICE_NOT_SUPPORT; } diff --git a/hgdriver/hgdev/hg_scanner.h b/hgdriver/hgdev/hg_scanner.h index 225386d..026d958 100644 --- a/hgdriver/hgdev/hg_scanner.h +++ b/hgdriver/hgdev/hg_scanner.h @@ -25,70 +25,7 @@ #else #include #endif -enum -{ - HG_BASE_SETTING_INDEX_RESTORE_DEFAULT_SETTINGS = 0, // 恢复默认设置 - HG_BASE_SETTING_INDEX_HELP, // 帮助 - HG_BASE_SETTING_INDEX_MULTI_OUT, // 多流输出 - HG_BASE_SETTING_INDEX_MULTI_OUT_TYPE, // 多流输出类型 - HG_BASE_SETTING_INDEX_COLOR_MODE, // 颜色模式 - HG_BASE_SETTING_INDEX_BLACK_WGITE_THRESHOLD, // 黑白图像阈值 - HG_BASE_SETTING_INDEX_ERASE_COLOR, // 除色 - HG_BASE_SETTING_INDEX_ERASE_MULTI_OUT_RED, // 多流输出除红 - HG_BASE_SETTING_INDEX_ERASE_ANSWER_RED, // 答题卡除红 - HG_BASE_SETTING_INDEX_ERASE_BACKGROUND, // 移除背景 - HG_BASE_SETTING_INDEX_ERASE_BACKGROUND_RANGE, // 移除背景范围 - HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE, // 黑白图像噪点优化 - HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE_SIZE, // 噪点优化尺寸 - HG_BASE_SETTING_INDEX_PAPER, // 纸张尺寸 - HG_BASE_SETTING_INDEX_PAPER_SIZE_CHECK, // 尺寸检测 - HG_BASE_SETTING_INDEX_IS_CUSTOM_AREA, // 是否启用自定义区域 - HG_BASE_SETTING_INDEX_CUSTOM_AREA_LEFT, // 自定义区域左侧（mm） - HG_BASE_SETTING_INDEX_CUSTOM_AREA_RIGHT, // 自定义区域右侧（mm） - HG_BASE_SETTING_INDEX_CUSTOM_AREA_TOP, // 自定义区域上侧（mm） - HG_BASE_SETTING_INDEX_CUSTOM_AREA_BOTTOM, // 自定义区域下侧（mm） - HG_BASE_SETTING_INDEX_PAGE, // 扫描页面 - HG_BASE_SETTING_INDEX_PAGE_OMIT_EMPTY_LEVEL, // 跳过空白页灵敏度 - HG_BASE_SETTING_INDEX_RESOLUTION, // 分辨率 - HG_BASE_SETTING_INDEX_IMG_QUALITY, // 图像质量 - HG_BASE_SETTING_INDEX_EXCHANGE, // 交换正反面 - HG_BASE_SETTING_INDEX_SPLIT, // 图像拆分 - HG_BASE_SETTING_INDEX_AUTO_CORRECT, // 自动纠偏 - HG_BASE_SETTING_INDEX_RID_HOLE, // 穿孔移除 - HG_BASE_SETTING_INDEX_RID_HOLE_RANGE, // 穿孔搜索范围占幅面比例 - HG_BASE_SETTING_INDEX_IS_CUSTOM_GAMMA, // 是否启用自定义伽玛 - HG_BASE_SETTING_INDEX_BRIGHT, // 亮度 - HG_BASE_SETTING_INDEX_CONTRAST, // 对比度 - HG_BASE_SETTING_INDEX_GAMMA, // 伽玛 - HG_BASE_SETTING_INDEX_CUSTOM_GAMMA_DATA, // 自定义伽玛数据 - HG_BASE_SETTING_INDEX_SHARPEN, // 锐化与模糊 - HG_BASE_SETTING_INDEX_DARK_SAMPLE, // 深色样张 - HG_BASE_SETTING_INDEX_ERASE_BLACK_FRAME, // 消除黑框 - HG_BASE_SETTING_INDEX_THRESHOLD, // 阈值 - HG_BASE_SETTING_INDEX_ANTI_NOISE_LEVEL, // 背景抗噪等级 - HG_BASE_SETTING_INDEX_MARGIN, // 边缘缩进 - HG_BASE_SETTING_INDEX_FILL_BACKGROUND, // 背景填充方式 - HG_BASE_SETTING_INDEX_PERMEATE, // 防止渗透 - HG_BASE_SETTING_INDEX_PERMEATE_LV, // 防止渗透等级 - HG_BASE_SETTING_INDEX_COLOR_FILL, // 色彩填充 - HG_BASE_SETTING_INDEX_REMOVE_MORR, // 去除摩尔纹 - HG_BASE_SETTING_INDEX_ERROR_EXTENTION, // 错误扩散 - HG_BASE_SETTING_INDEX_REMOVE_TXTTURE, // 除网纹 - HG_BASE_SETTING_INDEX_ULTRASONIC_CHECK, // 超声波检测 - HG_BASE_SETTING_INDEX_STAPLE_CHECK, // 装订检测 - HG_BASE_SETTING_INDEX_SCAN_MODE, // 连续扫描或扫描指定张数 - HG_BASE_SETTING_INDEX_SCAN_COUNT, // 扫描张数 - HG_BASE_SETTING_INDEX_TEXT_DIRECTION, // 文稿方向 - HG_BASE_SETTING_INDEX_ROTATE_BKG_180, // 背面旋转180° - HG_BASE_SETTING_INDEX_FRACTATE_CHECK, // 折角检测 - HG_BASE_SETTING_INDEX_FRACTATE_CHECK_LEVEL, // 折角检测复杂度 - HG_BASE_SETTING_INDEX_SKEW_CHECK, // 歪斜检测 - HG_BASE_SETTING_INDEX_SKEW_CHECK_LEVEL, // 歪斜检测复杂度 - - // 常规的功能索引声明必须在此之前 - HG_BASE_SETTING_INDEX_MAX, -}; #define MAPPING_FUNCTION_IN_BASE // 定义该标志，各子类不必再初始化setting_map_数组 #ifdef OEM_HANWANG @@ -129,6 +66,12 @@ class hg_scanner void reset_custom_area_range(int paper); int set_color_change(void); + ///////////////////////////////////////// + // ids ... + int id_scan_mode_ = -1; + int id_scan_count_ = -1; + ///////////////////////////////////////// + // 设置接口 protected: @@ -136,70 +79,73 @@ protected: // 比如： 某型设备的“颜色模式”功能号为1，则 setting_map_[HG_BASE_SETTING_INDEX_COLOR_MODE] = 1 // 如果设备的“颜色模式”配置逻辑与基类预定义的不同， // 则 setting_map_[HG_BASE_SETTING_INDEX_COLOR_MODE] = -1，在子类重载的set_setting_value方法中处理 - int setting_map_[HG_BASE_SETTING_INDEX_MAX]; - virtual void init_setting_map(int* setting_map, int count); + // + // 2022-06-28: 属性处理函数改用map结构存储，只须处理set_setting_map函数即可 + // int setting_map_[HG_BASE_SETTING_INDEX_MAX]; + //virtual void init_setting_map(int* setting_map, int count); + map setting_map_; + int invoke_setting_xxx(int(hg_scanner::* func)(int, void*), void* data); void set_setting_map(int sn, const char* title); - int setting_restore(void* data); - int setting_help(void* data); - int setting_color_mode(void* data); + int setting_restore(int sn, void* data); + int setting_help(int sn, void* data); + int setting_color_mode(int sn, void* data); - int setting_multi_out(void *data); - int setting_multi_out_type(void *data); + int setting_multi_out(int sn, void*data); + int setting_multi_out_type(int sn, void*data); - int setting_rid_color(void* data); - int setting_rid_multi_red(void* data); - int setting_rid_answer_red(void* data); - int setting_erase_background(void* data); - int setting_erase_background_range(void* data); - int setting_noise_optimize(void* data); - int setting_noise_optimize_range(void* data); - int setting_paper(void* data); - int setting_paper_check(void* data); - int setting_page(void* data); - int setting_page_omit_empty(void* data); - int setting_resolution(void* data); - int setting_exchagnge(void* data); - int setting_split_image(void* data); - int setting_automatic_skew(void* data); - int setting_rid_hole(void* data); - int setting_rid_hoe_range(void* data); - int setting_bright(void* data); - int setting_contrast(void* data); - int setting_gamma(void* data); - int setting_sharpen(void* data); - int setting_dark_sample(void* data); - int setting_erase_black_frame(void* data); - int setting_threshold(void* data); - int setting_anti_noise(void* data); - int setting_margin(void* data); - int setting_filling_background(void* data); - int setting_is_permeate(void *data); - int setting_is_permeate_lv(void *data); - int setting_remove_morr(void* data); - int setting_error_extention(void* data); - int setting_remove_texture(void* data); - int setting_ultrasonic_check(void* data); - int setting_staple_check(void* data); - int setting_scan_mode(void* data); - int setting_scan_count(void* data); - int setting_text_direction(void* data); - int setting_rotate_bkg_180(void* data); - int setting_fractate_check(void* data); - int setting_fractate_check_level(void* data); - int setting_skew_check(void* data); - int setting_skew_check_level(void* data); - int setting_is_custom_gamma(void* data); - int setting_custom_gamma_data(void* data); - int setting_is_custom_area(void* data); - int setting_custom_area_left(void* data); - int setting_custom_area_top(void* data); - int setting_custom_area_right(void* data); - int setting_custom_area_bottom(void* data); - int setting_img_quality(void *data); - int setting_color_fill(void *data); - int setting_black_white_threshold(void *data); - + int setting_rid_color(int sn, void* data); + int setting_rid_multi_red(int sn, void* data); + int setting_rid_answer_red(int sn, void* data); + int setting_erase_background(int sn, void* data); + int setting_erase_background_range(int sn, void* data); + int setting_noise_optimize(int sn, void* data); + int setting_noise_optimize_range(int sn, void* data); + int setting_paper(int sn, void* data); + int setting_paper_check(int sn, void* data); + int setting_page(int sn, void* data); + int setting_page_omit_empty(int sn, void* data); + int setting_resolution(int sn, void* data); + int setting_exchagnge(int sn, void* data); + int setting_split_image(int sn, void* data); + int setting_automatic_skew(int sn, void* data); + int setting_rid_hole(int sn, void* data); + int setting_rid_hoe_range(int sn, void* data); + int setting_bright(int sn, void* data); + int setting_contrast(int sn, void* data); + int setting_gamma(int sn, void* data); + int setting_sharpen(int sn, void* data); + int setting_dark_sample(int sn, void* data); + int setting_erase_black_frame(int sn, void* data); + int setting_threshold(int sn, void* data); + int setting_anti_noise(int sn, void* data); + int setting_margin(int sn, void* data); + int setting_filling_background(int sn, void* data); + int setting_is_permeate(int sn, void*data); + int setting_is_permeate_lv(int sn, void*data); + int setting_remove_morr(int sn, void* data); + int setting_error_extention(int sn, void* data); + int setting_remove_texture(int sn, void* data); + int setting_ultrasonic_check(int sn, void* data); + int setting_staple_check(int sn, void* data); + int setting_scan_mode(int sn, void* data); + int setting_scan_count(int sn, void* data); + int setting_text_direction(int sn, void* data); + int setting_rotate_bkg_180(int sn, void* data); + int setting_fractate_check(int sn, void* data); + int setting_fractate_check_level(int sn, void* data); + int setting_skew_check(int sn, void* data); + int setting_skew_check_level(int sn, void* data); + int setting_is_custom_gamma(int sn, void* data); + int setting_custom_gamma_data(int sn, void* data); + int setting_is_custom_area(int sn, void* data); + int setting_custom_area_left(int sn, void* data); + int setting_custom_area_top(int sn, void* data); + int setting_custom_area_right(int sn, void* data); + int setting_custom_area_bottom(int sn, void* data); + int setting_img_quality(int sn, void*data); + int setting_color_fill(int sn, void*data); + int setting_black_white_threshold(int sn, void* data); virtual int on_color_mode_changed(int& color_mode); // COLOR_MODE_xxx virtual int on_paper_changed(int& paper); // PAPER_xxx @@ -253,8 +199,9 @@ protected: int is_quality_; // 画质设置 bool is_color_fill; // 色彩填充 bool is_multiout; // 多流输出 - int black_white_image_threshold_; //黑白图像阈值 + int bw_threshold_; // 黑白图像阈值 （added on 2022-06-28） + SCANCONF img_conf_; //此参数外部不做任何改变，请在writedown_image_configuration做修改 std::string img_type_; diff --git a/hgdriver/hgdev/hg_scanner_200.cpp b/hgdriver/hgdev/hg_scanner_200.cpp index b93263b..00414a9 100644 --- a/hgdriver/hgdev/hg_scanner_200.cpp +++ b/hgdriver/hgdev/hg_scanner_200.cpp @@ -253,69 +253,6 @@ void hg_scanner_200::discard_prev(void) VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "discard prev-scanning %d packets and %d images.\n", packets, imgs); } -void hg_scanner_200::init_setting_map(int* setting_map, int count) -{ - setting_map[HG_BASE_SETTING_INDEX_RESTORE_DEFAULT_SETTINGS] = HG_239_SETTING_RESTORE; - setting_map[HG_BASE_SETTING_INDEX_HELP] = HG_239_SETTING_HELP; - - setting_map[HG_BASE_SETTING_INDEX_COLOR_MODE] = HG_239_SETTING_COLOR_MODE; - setting_map[HG_BASE_SETTING_INDEX_MULTI_OUT] = HG_239_SETTING_MULTI_OUT; - setting_map[HG_BASE_SETTING_INDEX_ERASE_COLOR] = HG_239_SETTING_ERASE_COLOR; - setting_map[HG_BASE_SETTING_INDEX_ERASE_MULTI_OUT_RED] = HG_239_SETTING_ERASE_MULTI_RED; - setting_map[HG_BASE_SETTING_INDEX_ERASE_ANSWER_RED] = HG_239_SETTING_ERASE_ANSWER_RED; - setting_map[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND] = HG_239_SETTING_ERASE_BACKGROUND; - setting_map[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND_RANGE] = HG_239_SETTING_ERASE_BKG_RANGE; - setting_map[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE] = HG_239_SETTING_NOISE; - setting_map[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE_SIZE] = HG_239_SETTING_NOISE_SIZE; - setting_map[HG_BASE_SETTING_INDEX_PAPER] = HG_239_SETTING_PAPER_SIZE; - //setting_map[HG_BASE_SETTING_INDEX_PAPER_SIZE_CHECK] = HG_239_SETTING_PAPER_SIZE_CHECK; - setting_map[HG_BASE_SETTING_INDEX_IS_CUSTOM_AREA] = HG_200_SETTING_CUSTOM_AREA; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_LEFT] = HG_200_SETTING_CUSTOM_AREA_LEFT; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_RIGHT] = HG_200_SETTING_CUSTOM_AREA_RIGHT; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_TOP] = HG_200_SETTING_CUSTOM_AREA_TOP; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_BOTTOM] = HG_200_SETTING_CUSTOM_AREA_BOTTOM; - - setting_map[HG_BASE_SETTING_INDEX_PAGE] = HG_239_SETTING_PAGE; - setting_map[HG_BASE_SETTING_INDEX_PAGE_OMIT_EMPTY_LEVEL] = HG_239_SETTING_SKIP_NILL; - setting_map[HG_BASE_SETTING_INDEX_RESOLUTION] = HG_239_SETTING_RESOLUTION; - setting_map[HG_BASE_SETTING_INDEX_EXCHANGE] = HG_239_SETTING_REVERSE; - setting_map[HG_BASE_SETTING_INDEX_SPLIT] = HG_239_SETTING_SPLIT; - setting_map[HG_BASE_SETTING_INDEX_AUTO_CORRECT] = HG_239_SETTING_CORRECT; - setting_map[HG_BASE_SETTING_INDEX_RID_HOLE] = HG_239_SETTING_ERASE_HOLE; - setting_map[HG_BASE_SETTING_INDEX_RID_HOLE_RANGE] = HG_239_SETTING_HOLE_SEARCH; - - setting_map[HG_BASE_SETTING_INDEX_IS_CUSTOM_GAMMA] = HG_200_SETTING_CUSTOM_GAMMA; - setting_map[HG_BASE_SETTING_INDEX_BRIGHT] = HG_239_SETTING_LIGHT; - setting_map[HG_BASE_SETTING_INDEX_CONTRAST] = HG_239_SETTING_CONTRAST; - setting_map[HG_BASE_SETTING_INDEX_GAMMA] = HG_239_SETTING_GAMMA; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_GAMMA_DATA] = HG_239_SETTING_END + 1; // HG_200_SETTING_CUSTOM_GAMMA_DATA; - - setting_map[HG_BASE_SETTING_INDEX_SHARPEN] = HG_239_SETTING_SHARP; - setting_map[HG_BASE_SETTING_INDEX_DARK_SAMPLE] = HG_239_SETTING_SAMPLE; - setting_map[HG_BASE_SETTING_INDEX_ERASE_BLACK_FRAME] = HG_239_SETTING_ERASE_BLACK_BORDER; - setting_map[HG_BASE_SETTING_INDEX_THRESHOLD] = HG_239_SETTING_THRESHOLD; - setting_map[HG_BASE_SETTING_INDEX_ANTI_NOISE_LEVEL] = HG_239_SETTING_ANTI_NOISE; - setting_map[HG_BASE_SETTING_INDEX_MARGIN] = HG_239_SETTING_MARGIN; - setting_map[HG_BASE_SETTING_INDEX_FILL_BACKGROUND] = HG_239_SETTING_FILLING; - setting_map[HG_BASE_SETTING_INDEX_PERMEATE] = HG_239_SETTING_PERMEATE; - setting_map[HG_BASE_SETTING_INDEX_PERMEATE_LV] = HG_239_SETTING_PERMEATE_lv; - setting_map[HG_BASE_SETTING_INDEX_REMOVE_MORR] = HG_239_SETTING_REMOVE_MORR; - setting_map[HG_BASE_SETTING_INDEX_ERROR_EXTENTION] = HG_239_SETTING_ERROR_EXTENTION; - setting_map[HG_BASE_SETTING_INDEX_REMOVE_TXTTURE] = HG_239_SETTING_REMOVE_TXTTURE; - - setting_map[HG_BASE_SETTING_INDEX_ULTRASONIC_CHECK] = HG_239_SETTING_ULTRASONIC; - setting_map[HG_BASE_SETTING_INDEX_STAPLE_CHECK] = HG_239_SETTING_STAPLE; - setting_map[HG_BASE_SETTING_INDEX_SCAN_MODE] = HG_239_SETTING_SCAN_METHOD; - setting_map[HG_BASE_SETTING_INDEX_SCAN_COUNT] = HG_239_SETTING_SCAN_COUNT; - setting_map[HG_BASE_SETTING_INDEX_TEXT_DIRECTION] = HG_239_SETTING_DIRECTION; - setting_map[HG_BASE_SETTING_INDEX_ROTATE_BKG_180] = HG_239_SETTING_ROTATE; - //setting_map[HG_BASE_SETTING_INDEX_FRACTATE_CHECK] = HG_239_SETTING_FRACTATE; 暂时屏蔽 - //setting_map[HG_BASE_SETTING_INDEX_FRACTATE_CHECK_LEVEL] = HG_239_SETTING_FRACTATE_COMPLEX; - setting_map[HG_BASE_SETTING_INDEX_SKEW_CHECK] = HG_239_SETTING_SCREW; - setting_map[HG_BASE_SETTING_INDEX_SKEW_CHECK_LEVEL] = HG_239_SETTING_SCREW_COMPLEX; - - } - int hg_scanner_200::on_scanner_closing(bool force) { return SCANNER_ERR_OK; diff --git a/hgdriver/hgdev/hg_scanner_200.h b/hgdriver/hgdev/hg_scanner_200.h index 74833c9..234af8d 100644 --- a/hgdriver/hgdev/hg_scanner_200.h +++ b/hgdriver/hgdev/hg_scanner_200.h @@ -45,7 +45,6 @@ public: public: virtual int start(void)override; virtual int stop(void)override; - void init_setting_map(int* setting_map, int count)override; private: int initdevice(); diff --git a/hgdriver/hgdev/hg_scanner_239.cpp b/hgdriver/hgdev/hg_scanner_239.cpp index ac9c78c..936eed4 100644 --- a/hgdriver/hgdev/hg_scanner_239.cpp +++ b/hgdriver/hgdev/hg_scanner_239.cpp @@ -1175,70 +1175,6 @@ void hg_scanner_239::discard_all_images(void) VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "prev-connection has left %d interrupt packet(s) && %d image(s).\n", pre_int, pre_img); } -void hg_scanner_239::init_setting_map(int* setting_map, int count) -{ - setting_map[HG_BASE_SETTING_INDEX_RESTORE_DEFAULT_SETTINGS] = HG_239_SETTING_RESTORE; - setting_map[HG_BASE_SETTING_INDEX_HELP] = HG_239_SETTING_HELP; - - setting_map[HG_BASE_SETTING_INDEX_COLOR_MODE] = HG_239_SETTING_COLOR_MODE; - setting_map[HG_BASE_SETTING_INDEX_MULTI_OUT] = HG_239_SETTING_MULTI_OUT; - setting_map[HG_BASE_SETTING_INDEX_ERASE_COLOR] = HG_239_SETTING_ERASE_COLOR; - setting_map[HG_BASE_SETTING_INDEX_ERASE_MULTI_OUT_RED] = HG_239_SETTING_ERASE_MULTI_RED; - setting_map[HG_BASE_SETTING_INDEX_ERASE_ANSWER_RED] = HG_239_SETTING_ERASE_ANSWER_RED; - setting_map[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND] = HG_239_SETTING_ERASE_BACKGROUND; - setting_map[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND_RANGE] = HG_239_SETTING_ERASE_BKG_RANGE; - setting_map[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE] = HG_239_SETTING_NOISE; - setting_map[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE_SIZE] = HG_239_SETTING_NOISE_SIZE; - setting_map[HG_BASE_SETTING_INDEX_PAPER] = HG_239_SETTING_PAPER_SIZE; - - setting_map[HG_BASE_SETTING_INDEX_IS_CUSTOM_AREA] = HG_239_SETTING_CUSTOM_AREA; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_LEFT] = HG_239_SETTING_CUSTOM_AREA_LEFT; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_RIGHT] = HG_239_SETTING_CUSTOM_AREA_RIGHT; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_TOP] = HG_239_SETTING_CUSTOM_AREA_TOP; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_BOTTOM] = HG_239_SETTING_CUSTOM_AREA_BOTTOM; - - setting_map[HG_BASE_SETTING_INDEX_PAPER_SIZE_CHECK] = HG_239_SETTING_PAPER_SIZE_CHECK; - setting_map[HG_BASE_SETTING_INDEX_PAGE] = HG_239_SETTING_PAGE; - setting_map[HG_BASE_SETTING_INDEX_PAGE_OMIT_EMPTY_LEVEL] = HG_239_SETTING_SKIP_NILL; - setting_map[HG_BASE_SETTING_INDEX_RESOLUTION] = HG_239_SETTING_RESOLUTION; - setting_map[HG_BASE_SETTING_INDEX_IMG_QUALITY] = HG_239_SETTING_IMG_QUALITY; - setting_map[HG_BASE_SETTING_INDEX_EXCHANGE] = HG_239_SETTING_REVERSE; - setting_map[HG_BASE_SETTING_INDEX_SPLIT] = HG_239_SETTING_SPLIT; - setting_map[HG_BASE_SETTING_INDEX_AUTO_CORRECT] = HG_239_SETTING_CORRECT; - setting_map[HG_BASE_SETTING_INDEX_RID_HOLE] = HG_239_SETTING_ERASE_HOLE; - setting_map[HG_BASE_SETTING_INDEX_RID_HOLE_RANGE] = HG_239_SETTING_HOLE_SEARCH; - - setting_map[HG_BASE_SETTING_INDEX_IS_CUSTOM_GAMMA] = HG_239_SETTING_CUSTOM_GAMMA; - setting_map[HG_BASE_SETTING_INDEX_BRIGHT] = HG_239_SETTING_LIGHT; - setting_map[HG_BASE_SETTING_INDEX_CONTRAST] = HG_239_SETTING_CONTRAST; - setting_map[HG_BASE_SETTING_INDEX_GAMMA] = HG_239_SETTING_GAMMA; - - setting_map[HG_BASE_SETTING_INDEX_SHARPEN] = HG_239_SETTING_SHARP; - setting_map[HG_BASE_SETTING_INDEX_DARK_SAMPLE] = HG_239_SETTING_SAMPLE; - setting_map[HG_BASE_SETTING_INDEX_ERASE_BLACK_FRAME] = HG_239_SETTING_ERASE_BLACK_BORDER; - setting_map[HG_BASE_SETTING_INDEX_THRESHOLD] = HG_239_SETTING_THRESHOLD; - setting_map[HG_BASE_SETTING_INDEX_ANTI_NOISE_LEVEL] = HG_239_SETTING_ANTI_NOISE; - setting_map[HG_BASE_SETTING_INDEX_MARGIN] = HG_239_SETTING_MARGIN; - setting_map[HG_BASE_SETTING_INDEX_FILL_BACKGROUND] = HG_239_SETTING_FILLING; - setting_map[HG_BASE_SETTING_INDEX_PERMEATE] = HG_239_SETTING_PERMEATE; - setting_map[HG_BASE_SETTING_INDEX_PERMEATE_LV] = HG_239_SETTING_PERMEATE_lv; - setting_map[HG_BASE_SETTING_INDEX_REMOVE_MORR] = HG_239_SETTING_REMOVE_MORR; - setting_map[HG_BASE_SETTING_INDEX_ERROR_EXTENTION] = HG_239_SETTING_ERROR_EXTENTION; - setting_map[HG_BASE_SETTING_INDEX_REMOVE_TXTTURE] = HG_239_SETTING_REMOVE_TXTTURE; - - setting_map[HG_BASE_SETTING_INDEX_ULTRASONIC_CHECK] = HG_239_SETTING_ULTRASONIC; - setting_map[HG_BASE_SETTING_INDEX_STAPLE_CHECK] = HG_239_SETTING_STAPLE; - setting_map[HG_BASE_SETTING_INDEX_SCAN_MODE] = HG_239_SETTING_SCAN_METHOD; - setting_map[HG_BASE_SETTING_INDEX_SCAN_COUNT] = HG_239_SETTING_SCAN_COUNT; - setting_map[HG_BASE_SETTING_INDEX_TEXT_DIRECTION] = HG_239_SETTING_DIRECTION; - setting_map[HG_BASE_SETTING_INDEX_ROTATE_BKG_180] = HG_239_SETTING_ROTATE; - setting_map[HG_BASE_SETTING_INDEX_FRACTATE_CHECK] = HG_239_SETTING_FRACTATE; - setting_map[HG_BASE_SETTING_INDEX_FRACTATE_CHECK_LEVEL] = HG_239_SETTING_FRACTATE_COMPLEX; - setting_map[HG_BASE_SETTING_INDEX_SKEW_CHECK] = HG_239_SETTING_SCREW; - setting_map[HG_BASE_SETTING_INDEX_SKEW_CHECK_LEVEL] = HG_239_SETTING_SCREW_COMPLEX; - -} - //color_mode =-1 除色选项 int hg_scanner_239::on_color_mode_changed(int& color_mode) { @@ -1769,7 +1705,7 @@ int hg_scanner_239::device_io_control(unsigned long code, void* data, unsigned* if (opten->opt_num == HG_239_SETTING_CORRECT && !opten->enabled) // for BUG-20 modified by Gongbing on 2022-03-12 { bool enable = true; - setting_automatic_skew(&enable); + setting_automatic_skew(opten->opt_num, &enable); } } else if (IO_CTRL_CODE_TEST_SINGLE == code) diff --git a/hgdriver/hgdev/hg_scanner_239.h b/hgdriver/hgdev/hg_scanner_239.h index 12adf37..c5c3e5c 100644 --- a/hgdriver/hgdev/hg_scanner_239.h +++ b/hgdriver/hgdev/hg_scanner_239.h @@ -57,8 +57,6 @@ class hg_scanner_239 : public hg_scanner void discard_all_images(void); protected: - virtual void init_setting_map(int* setting_map, int count) override; - int on_color_mode_changed(int& color_mode) override; virtual int on_paper_changed(int& paper) override; virtual int on_paper_check_changed(bool& check) override; @@ -85,6 +83,7 @@ public: virtual int stop(void) override; virtual int reset(void) override; virtual int device_io_control(unsigned long code, void* data, unsigned* len) override; + public: virtual int set_leaflet_scan(void);//单张扫描 virtual int get_abuot_info(void);//获取软件关于信息 (基类实现) diff --git a/hgdriver/hgdev/hg_scanner_300.cpp b/hgdriver/hgdev/hg_scanner_300.cpp index 47d058f..1fc4a22 100644 --- a/hgdriver/hgdev/hg_scanner_300.cpp +++ b/hgdriver/hgdev/hg_scanner_300.cpp @@ -204,66 +204,6 @@ hg_scanner_300::~hg_scanner_300() {} -void hg_scanner_300::init_setting_map(int* setting_map, int count) -{ - setting_map[HG_BASE_SETTING_INDEX_RESTORE_DEFAULT_SETTINGS] = HG_239_SETTING_RESTORE; - setting_map[HG_BASE_SETTING_INDEX_HELP] = HG_239_SETTING_HELP; - - setting_map[HG_BASE_SETTING_INDEX_COLOR_MODE] = HG_239_SETTING_COLOR_MODE; - setting_map[HG_BASE_SETTING_INDEX_MULTI_OUT] = HG_239_SETTING_MULTI_OUT; - setting_map[HG_BASE_SETTING_INDEX_ERASE_COLOR] = HG_239_SETTING_ERASE_COLOR; - setting_map[HG_BASE_SETTING_INDEX_ERASE_MULTI_OUT_RED] = HG_239_SETTING_ERASE_MULTI_RED; - setting_map[HG_BASE_SETTING_INDEX_ERASE_ANSWER_RED] = HG_239_SETTING_ERASE_ANSWER_RED; - setting_map[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND] = HG_239_SETTING_ERASE_BACKGROUND; - setting_map[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND_RANGE] = HG_239_SETTING_ERASE_BKG_RANGE; - setting_map[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE] = HG_239_SETTING_NOISE; - setting_map[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE_SIZE] = HG_239_SETTING_NOISE_SIZE; - setting_map[HG_BASE_SETTING_INDEX_PAPER] = HG_239_SETTING_PAPER_SIZE; - - setting_map[HG_BASE_SETTING_INDEX_IS_CUSTOM_AREA] = HG_300_SETTING_CUSTOM_AREA; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_LEFT] = HG_300_SETTING_CUSTOM_AREA_LEFT; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_RIGHT] = HG_300_SETTING_CUSTOM_AREA_RIGHT; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_TOP] = HG_300_SETTING_CUSTOM_AREA_TOP; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_BOTTOM] = HG_300_SETTING_CUSTOM_AREA_BOTTOM; - - //setting_map[HG_BASE_SETTING_INDEX_PAPER_SIZE_CHECK] = HG_239_SETTING_PAPER_SIZE_CHECK; - setting_map[HG_BASE_SETTING_INDEX_PAGE] = HG_239_SETTING_PAGE; - setting_map[HG_BASE_SETTING_INDEX_PAGE_OMIT_EMPTY_LEVEL] = HG_239_SETTING_SKIP_NILL; - setting_map[HG_BASE_SETTING_INDEX_RESOLUTION] = HG_239_SETTING_RESOLUTION; - setting_map[HG_BASE_SETTING_INDEX_EXCHANGE] = HG_239_SETTING_REVERSE; - setting_map[HG_BASE_SETTING_INDEX_SPLIT] = HG_239_SETTING_SPLIT; - setting_map[HG_BASE_SETTING_INDEX_AUTO_CORRECT] = HG_239_SETTING_CORRECT; - setting_map[HG_BASE_SETTING_INDEX_RID_HOLE] = HG_239_SETTING_ERASE_HOLE; - setting_map[HG_BASE_SETTING_INDEX_RID_HOLE_RANGE] = HG_239_SETTING_HOLE_SEARCH; - - setting_map[HG_BASE_SETTING_INDEX_IS_CUSTOM_GAMMA] = HG_300_SETTING_CUSTOM_GAMMA; - setting_map[HG_BASE_SETTING_INDEX_BRIGHT] = HG_239_SETTING_LIGHT; - setting_map[HG_BASE_SETTING_INDEX_CONTRAST] = HG_239_SETTING_CONTRAST; - setting_map[HG_BASE_SETTING_INDEX_GAMMA] = HG_239_SETTING_GAMMA; - - setting_map[HG_BASE_SETTING_INDEX_SHARPEN] = HG_239_SETTING_SHARP; - setting_map[HG_BASE_SETTING_INDEX_DARK_SAMPLE] = HG_239_SETTING_SAMPLE; - setting_map[HG_BASE_SETTING_INDEX_ERASE_BLACK_FRAME] = HG_239_SETTING_ERASE_BLACK_BORDER; - setting_map[HG_BASE_SETTING_INDEX_THRESHOLD] = HG_239_SETTING_THRESHOLD; - setting_map[HG_BASE_SETTING_INDEX_ANTI_NOISE_LEVEL] = HG_239_SETTING_ANTI_NOISE; - setting_map[HG_BASE_SETTING_INDEX_MARGIN] = HG_239_SETTING_MARGIN; - setting_map[HG_BASE_SETTING_INDEX_FILL_BACKGROUND] = HG_239_SETTING_FILLING; - setting_map[HG_BASE_SETTING_INDEX_PERMEATE] = HG_239_SETTING_PERMEATE; - setting_map[HG_BASE_SETTING_INDEX_PERMEATE_LV] = HG_239_SETTING_PERMEATE_lv; - setting_map[HG_BASE_SETTING_INDEX_REMOVE_MORR] = HG_239_SETTING_REMOVE_MORR; - setting_map[HG_BASE_SETTING_INDEX_ERROR_EXTENTION] = HG_239_SETTING_ERROR_EXTENTION; - setting_map[HG_BASE_SETTING_INDEX_REMOVE_TXTTURE] = HG_239_SETTING_REMOVE_TXTTURE; - - setting_map[HG_BASE_SETTING_INDEX_ULTRASONIC_CHECK] = HG_239_SETTING_ULTRASONIC; - setting_map[HG_BASE_SETTING_INDEX_SCAN_MODE] = HG_239_SETTING_SCAN_METHOD; - setting_map[HG_BASE_SETTING_INDEX_SCAN_COUNT] = HG_239_SETTING_SCAN_COUNT; - setting_map[HG_BASE_SETTING_INDEX_TEXT_DIRECTION] = HG_239_SETTING_DIRECTION; - setting_map[HG_BASE_SETTING_INDEX_ROTATE_BKG_180] = HG_239_SETTING_ROTATE; - - - } - - int hg_scanner_300::on_scanner_closing(bool force) { return SCANNER_ERR_OK; diff --git a/hgdriver/hgdev/hg_scanner_300.h b/hgdriver/hgdev/hg_scanner_300.h index 8b16ab4..b6c0909 100644 --- a/hgdriver/hgdev/hg_scanner_300.h +++ b/hgdriver/hgdev/hg_scanner_300.h @@ -45,7 +45,6 @@ public: public: virtual int start(void)override; virtual int stop(void)override; - void init_setting_map(int* setting_map, int count)override; private: int agreement(); diff --git a/hgdriver/hgdev/hg_scanner_400.cpp b/hgdriver/hgdev/hg_scanner_400.cpp index a3b140e..31820cc 100644 --- a/hgdriver/hgdev/hg_scanner_400.cpp +++ b/hgdriver/hgdev/hg_scanner_400.cpp @@ -202,66 +202,6 @@ hg_scanner_400::~hg_scanner_400() {} -void hg_scanner_400::init_setting_map(int* setting_map, int count) -{ - setting_map[HG_BASE_SETTING_INDEX_RESTORE_DEFAULT_SETTINGS] = HG_239_SETTING_RESTORE; - setting_map[HG_BASE_SETTING_INDEX_HELP] = HG_239_SETTING_HELP; - - setting_map[HG_BASE_SETTING_INDEX_COLOR_MODE] = HG_239_SETTING_COLOR_MODE; - setting_map[HG_BASE_SETTING_INDEX_MULTI_OUT] = HG_239_SETTING_MULTI_OUT; - setting_map[HG_BASE_SETTING_INDEX_ERASE_COLOR] = HG_239_SETTING_ERASE_COLOR; - setting_map[HG_BASE_SETTING_INDEX_ERASE_MULTI_OUT_RED] = HG_239_SETTING_ERASE_MULTI_RED; - setting_map[HG_BASE_SETTING_INDEX_ERASE_ANSWER_RED] = HG_239_SETTING_ERASE_ANSWER_RED; - setting_map[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND] = HG_239_SETTING_ERASE_BACKGROUND; - setting_map[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND_RANGE] = HG_239_SETTING_ERASE_BKG_RANGE; - setting_map[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE] = HG_239_SETTING_NOISE; - setting_map[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE_SIZE] = HG_239_SETTING_NOISE_SIZE; - setting_map[HG_BASE_SETTING_INDEX_PAPER] = HG_239_SETTING_PAPER_SIZE; - - setting_map[HG_BASE_SETTING_INDEX_IS_CUSTOM_AREA] = HG_400_SETTING_CUSTOM_AREA; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_LEFT] = HG_400_SETTING_CUSTOM_AREA_LEFT; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_RIGHT] = HG_400_SETTING_CUSTOM_AREA_RIGHT; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_TOP] = HG_400_SETTING_CUSTOM_AREA_TOP; - setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_BOTTOM] = HG_400_SETTING_CUSTOM_AREA_BOTTOM; - - //setting_map[HG_BASE_SETTING_INDEX_PAPER_SIZE_CHECK] = HG_239_SETTING_PAPER_SIZE_CHECK; - setting_map[HG_BASE_SETTING_INDEX_PAGE] = HG_239_SETTING_PAGE; - setting_map[HG_BASE_SETTING_INDEX_PAGE_OMIT_EMPTY_LEVEL] = HG_239_SETTING_SKIP_NILL; - setting_map[HG_BASE_SETTING_INDEX_RESOLUTION] = HG_239_SETTING_RESOLUTION; - setting_map[HG_BASE_SETTING_INDEX_EXCHANGE] = HG_239_SETTING_REVERSE; - setting_map[HG_BASE_SETTING_INDEX_SPLIT] = HG_239_SETTING_SPLIT; - setting_map[HG_BASE_SETTING_INDEX_AUTO_CORRECT] = HG_239_SETTING_CORRECT; - setting_map[HG_BASE_SETTING_INDEX_RID_HOLE] = HG_239_SETTING_ERASE_HOLE; - setting_map[HG_BASE_SETTING_INDEX_RID_HOLE_RANGE] = HG_239_SETTING_HOLE_SEARCH; - - setting_map[HG_BASE_SETTING_INDEX_IS_CUSTOM_GAMMA] = HG_400_SETTING_CUSTOM_GAMMA; - setting_map[HG_BASE_SETTING_INDEX_BRIGHT] = HG_239_SETTING_LIGHT; - setting_map[HG_BASE_SETTING_INDEX_CONTRAST] = HG_239_SETTING_CONTRAST; - setting_map[HG_BASE_SETTING_INDEX_GAMMA] = HG_239_SETTING_GAMMA; - - setting_map[HG_BASE_SETTING_INDEX_SHARPEN] = HG_239_SETTING_SHARP; - setting_map[HG_BASE_SETTING_INDEX_DARK_SAMPLE] = HG_239_SETTING_SAMPLE; - setting_map[HG_BASE_SETTING_INDEX_ERASE_BLACK_FRAME] = HG_239_SETTING_ERASE_BLACK_BORDER; - setting_map[HG_BASE_SETTING_INDEX_THRESHOLD] = HG_239_SETTING_THRESHOLD; - setting_map[HG_BASE_SETTING_INDEX_ANTI_NOISE_LEVEL] = HG_239_SETTING_ANTI_NOISE; - setting_map[HG_BASE_SETTING_INDEX_MARGIN] = HG_239_SETTING_MARGIN; - setting_map[HG_BASE_SETTING_INDEX_FILL_BACKGROUND] = HG_239_SETTING_FILLING; - setting_map[HG_BASE_SETTING_INDEX_PERMEATE] = HG_239_SETTING_PERMEATE; - setting_map[HG_BASE_SETTING_INDEX_PERMEATE_LV] = HG_239_SETTING_PERMEATE_lv; - setting_map[HG_BASE_SETTING_INDEX_REMOVE_MORR] = HG_239_SETTING_REMOVE_MORR; - setting_map[HG_BASE_SETTING_INDEX_ERROR_EXTENTION] = HG_239_SETTING_ERROR_EXTENTION; - setting_map[HG_BASE_SETTING_INDEX_REMOVE_TXTTURE] = HG_239_SETTING_REMOVE_TXTTURE; - - setting_map[HG_BASE_SETTING_INDEX_ULTRASONIC_CHECK] = HG_239_SETTING_ULTRASONIC; - setting_map[HG_BASE_SETTING_INDEX_SCAN_MODE] = HG_239_SETTING_SCAN_METHOD; - setting_map[HG_BASE_SETTING_INDEX_SCAN_COUNT] = HG_239_SETTING_SCAN_COUNT; - setting_map[HG_BASE_SETTING_INDEX_TEXT_DIRECTION] = HG_239_SETTING_DIRECTION; - setting_map[HG_BASE_SETTING_INDEX_ROTATE_BKG_180] = HG_239_SETTING_ROTATE; - - - } - - int hg_scanner_400::on_scanner_closing(bool force) { return SCANNER_ERR_OK; diff --git a/hgdriver/hgdev/hg_scanner_400.h b/hgdriver/hgdev/hg_scanner_400.h index 866ee0c..062360b 100644 --- a/hgdriver/hgdev/hg_scanner_400.h +++ b/hgdriver/hgdev/hg_scanner_400.h @@ -45,7 +45,6 @@ public: public: virtual int start(void)override; virtual int stop(void)override; - void init_setting_map(int* setting_map, int count)override; private: int agreement(TwSS tw,int align); diff --git a/hgdriver/hgdev/image_process.cpp b/hgdriver/hgdev/image_process.cpp index 702a459..76a3000 100644 --- a/hgdriver/hgdev/image_process.cpp +++ b/hgdriver/hgdev/image_process.cpp @@ -5,6 +5,29 @@ #include #ifndef WIN32 #include +typedef struct BITMAPFILEHEADER +{ + u_int16_t bfType; + u_int32_t bfSize; + u_int16_t bfReserved1; + u_int16_t bfReserved2; + u_int32_t bfOffBits; +}BITMAPFILEHEADER; + +typedef struct BITMAPINFOHEADER +{ + u_int32_t biSize; + u_int32_t biWidth; + u_int32_t biHeight; + u_int16_t biPlanes; + u_int16_t biBitCount; + u_int32_t biCompression; + u_int32_t biSizeImage; + u_int32_t biXPelsPerMeter; + u_int32_t biYPelsPerMeter; + u_int32_t biClrUsed; + u_int32_t biClrImportant; +}BITMAPINFODEADER; #else #include #include @@ -28,6 +51,7 @@ extern "C" } #endif #include "hg_ipc.h" +#include "../ImageProcess/G4Tiff.h" using namespace std; #define GET_BYTE(a) ((a) & 0x0ff) @@ -1014,6 +1038,160 @@ namespace hg_imgproc delete obj; } + + // seperate utilites ... +#include +#define CV_MAT_DEPTH_SET(flags, depth) (((flags) & ~(CV_MAT_DEPTH_MASK)) | (depth & CV_MAT_DEPTH_MASK)) + static cv::Mat from_bmp_file_bits(const BITMAPINFOHEADER& bih, unsigned char* data, bool tiff) + { + cv::Mat m; + int bytes = 0, align = 0; + unsigned char *dst = NULL; + + m.create(bih.biHeight, bih.biWidth, bih.biBitCount > 8 ? CV_8UC3 : CV_8UC1); + dst = m.ptr(); + bytes = (bih.biBitCount + 7) / 8; + bytes *= bih.biWidth; + align = (bytes + 3) / 4 * 4; + if (tiff) + { + data += align * (bih.biHeight - 1); + align *= -1; + } + for (int i = 0; i < bih.biHeight; ++i) + { + memcpy(dst, data, bytes); + dst += bytes; + data += align; + } + + return m; + } + int convert_image_file(SANE_ImageFormatConvert* conv) + { + if (conv->src.fmt.img_format != SANE_IMAGE_TYPE_BMP && + conv->src.fmt.compress.compression != SANE_COMPRESSION_NONE) + return SCANNER_ERR_DEVICE_NOT_SUPPORT; + if(conv->dst.fmt.img_format != SANE_IMAGE_TYPE_JFIF && + conv->dst.fmt.img_format != SANE_IMAGE_TYPE_TIFF && + conv->dst.fmt.compress.compression != SANE_COMPRESSION_NONE && + conv->dst.fmt.compress.compression != SANE_COMPRESSION_GROUP4) + return SCANNER_ERR_DEVICE_NOT_SUPPORT; + + int fh = sizeof(BITMAPFILEHEADER); + BITMAPINFOHEADER bih = { 0 }; + unsigned char *bits = NULL; + std::shared_ptr> data; + + if (conv->src.is_file) + { + FILE* src = fopen(conv->src.data, "rb"); + long len = 0; + if (!src) + return SCANNER_ERR_OPEN_FILE_FAILED; + + fseek(src, 0, SEEK_END); + len = ftell(src) - fh; + if (len <= 0) + { + fclose(src); + + return SCANNER_ERR_DATA_DAMAGED; + } + + fseek(src, fh, SEEK_SET); + fread(&bih, sizeof(bih), 1, src); + len -= sizeof(bih); + data.reset(new std::vector(len)); + fread(&(*data.get())[0], 1, len, src); + fclose(src); + bits = data.get()->data(); + } + else + { + memcpy(&bih, conv->src.data + fh, sizeof(bih)); + bits = (unsigned char*)conv->src.data + fh + sizeof(bih); + } + + bool tiff = conv->dst.fmt.img_format == SANE_IMAGE_TYPE_TIFF; + int resolution = bih.biXPelsPerMeter / 39.37f + .5f, + threshold = (int)(long)conv->dst.fmt.compress.detail; + cv::Mat imsg = from_bmp_file_bits(bih, data->data(), tiff); + data.reset(); + if (tiff) + { + if (bih.biBitCount == 24) + { + if (conv->dst.fmt.compress.compression == SANE_COMPRESSION_GROUP4) + cvtColor(imsg, imsg, cv::COLOR_RGB2GRAY); + else + { + for (int y = 0; y < bih.biHeight; ++y) + { + uint8_t* row = imsg.ptr(y); + for (int x = 0; x < bih.biWidth; ++x) + { + uint8_t t = row[x * 3 + 0]; + row[x * 3 + 0] = row[x * 3 + 2]; + row[x * 3 + 2] = t; + } + } + } + } + int compression = conv->dst.fmt.compress.compression == SANE_COMPRESSION_GROUP4 ? COMPRESSION_CCITT_T6 : COMPRESSION_NONE; + if (conv->dst.is_file) + { + G4Tiff tiff(imsg, G4Tiff::Mode::FileMode, conv->dst.data, threshold, resolution, compression); + tiff.SaveG4Tiff(); + } + else + { + G4Tiff tiff(imsg, G4Tiff::Mode::MemoryMode, "", threshold, resolution, compression); + size_t bytes = 0; + conv->dst.data = (SANE_String_Const)tiff.get_compressed_data(&bytes, allocate_memory); + conv->dst.data_len = bytes; + } + } + else if (conv->dst.fmt.img_format == SANE_IMAGE_TYPE_JFIF) + { + std::vector cpr; + cpr.push_back(CV_IMWRITE_JPEG_QUALITY); + cpr.push_back((int)(long)conv->dst.fmt.detail); + if (conv->dst.is_file) + cv::imwrite(conv->dst.data, imsg, cpr); + else + { + std::string tmpf(hg_log::temporary_path() + PATH_SEPARATOR + "imgtrans.tmp"); + cv::imwrite(tmpf.c_str(), imsg, cpr); + size_t bytes = 0; + conv->dst.data = (SANE_String_Const)G4Tiff::load_mini_file(tmpf.c_str(), &bytes, allocate_memory); + conv->dst.data_len = bytes; + remove(tmpf.c_str()); + } + } + else if (conv->dst.fmt.compress.compression == SANE_COMPRESSION_GROUP4) + { + std::vector cmp; + + if (bih.biBitCount == 24) + cvtColor(imsg, imsg, cv::COLOR_RGB2GRAY); + + if (conv->dst.is_file) + { + G4Tiff tiff(imsg, G4Tiff::Mode::FileMode, conv->dst.data, threshold, resolution); + tiff.SaveG4Tiff(); + } + else + { + G4Tiff tiff(imsg, G4Tiff::Mode::MemoryMode, "", threshold, resolution); + size_t bytes = 0; + conv->dst.data = (SANE_String_Const)tiff.get_compressed_data(&bytes, allocate_memory); + conv->dst.data_len = bytes; + } + } + return SCANNER_ERR_OK; + } + } diff --git a/hgdriver/hgdev/image_process.h b/hgdriver/hgdev/image_process.h index 7b5faf4..7cc0f7d 100644 --- a/hgdriver/hgdev/image_process.h +++ b/hgdriver/hgdev/image_process.h @@ -8,6 +8,7 @@ #include "common_setting.h" #include #include +#include class tiny_buffer; namespace hg_imgproc @@ -209,4 +210,8 @@ namespace hg_imgproc int get_final_data(HIMGPRC himg, LPIMGHEAD pimh, void** buf, int index = 0); int get_final_data(HIMGPRC himg, LPIMGHEAD pimh, std::vector* buf, int index); void release(HIMGPRC himg); + + + // seperate utilites ... + int convert_image_file(SANE_ImageFormatConvert* conv); }