|
|
/*++
Copyright (c) 1990-1999 Microsoft Corporation
Module Name:
ht.h
Abstract:
This module contains all the public defines, constants, structures and functions declarations for accessing the DLL.
Author:
15-Jan-1991 Tue 21:13:21 created -by- Daniel Chou (danielc)
[Environment:]
GDI Device Driver - Halftone.
[Notes:]
Revision History:
29-Oct-1991 Tue 14:33:43 updated -by- Daniel Chou (danielc)
1) Change HALFTONEPATTERN data structure.
a) 'Flags' field from WORD to BYTE b) 'MaximumHTDensityIndex' from WORD to BYTE c) Change the field order.
2) Remove ReferenceWhite/ReferenceBlack from HTCOLORADJUSTMENT data structure.
3)
--*/
#ifndef _HT_
#define _HT_
//
// For compilers that don't support nameless unions
//
#ifndef DUMMYUNIONNAME
#ifdef NONAMELESSUNION
#define DUMMYUNIONNAME u
#define DUMMYUNIONNAME2 u2
#define DUMMYUNIONNAME3 u3
#define DUMMYUNIONNAME4 u4
#else
#define DUMMYUNIONNAME
#define DUMMYUNIONNAME2
#define DUMMYUNIONNAME3
#define DUMMYUNIONNAME4
#endif
#endif
#ifndef far
#define far
#endif
#ifndef FAR
#define FAR far
#endif
typedef CHAR FAR *LPCHAR;typedef SHORT FAR *LPSHORT;typedef UINT FAR *LPUINT;
//
// The DECI4/UDECI4 is a special number used in halftone DLL, this number
// just like regular short, unsigned short number, except it using lower
// four decimal digits as right side of the decimal point, that is
// 10000 is as 1.0000, and -12345 will be -1.2345.
//
typedef short DECI4;typedef unsigned short UDECI4;typedef DECI4 FAR *PDECI4;typedef UDECI4 FAR *PUDECI4;
#define DECI4_0 (DECI4)0
#define DECI4_1 (DECI4)10000
#define DECI4_Neg1 (DECI4)-10000
#define UDECI4_0 (UDECI4)0
#define UDECI4_1 (UDECI4)10000
#define SIZE_BYTE sizeof(BYTE)
#define SIZE_CHAR sizeof(CHAR)
#define SIZE_WORD sizeof(WORD)
#define SIZE_SHORT sizeof(SHORT)
#define SIZE_LONG sizeof(LONG)
#define SIZE_DWORD sizeof(DWORD)
#define SIZE_UINT sizeof(UINT)
#define SIZE_INT sizeof(INT)
#define SIZE_UDECI4 sizeof(UDECI4)
#define SIZE_DECI4 sizeof(DECI4)
#define COUNT_ARRAY(array) (sizeof(array) / sizeof(array[0]))
#define B_BITPOS(x) ((BYTE)(1 << (x)))
#define W_BITPOS(x) ((WORD)(1 << (x)))
#define DW_BITPOS(x) ((DWORD)(1 << (x)))
#define BIT_IF(b,t) (((t)) ? (b) : ((b)-(b)))
#define SET_BIT(x,b) ((x) |= (b))
#define CLR_BIT(x,b) ((x) &= ~(b))
#define INV_BIT(x,b) ((x) ^= (b))
#define HAS_BIT(x,b) ((x) & (b))
//
// The following are the error return values for the HTHalftoneBitmap() call.
//
#define HTERR_WRONG_VERSION_HTINITINFO -1
#define HTERR_INSUFFICIENT_MEMORY -2
#define HTERR_CANNOT_DEALLOCATE_MEMORY -3
#define HTERR_COLORTABLE_TOO_BIG -4
#define HTERR_QUERY_SRC_BITMAP_FAILED -5
#define HTERR_QUERY_DEST_BITMAP_FAILED -6
#define HTERR_QUERY_SRC_MASK_FAILED -7
#define HTERR_SET_DEST_BITMAP_FAILED -8
#define HTERR_INVALID_SRC_FORMAT -9
#define HTERR_INVALID_SRC_MASK_FORMAT -10
#define HTERR_INVALID_DEST_FORMAT -11
#define HTERR_INVALID_DHI_POINTER -12
#define HTERR_SRC_MASK_BITS_TOO_SMALL -13
#define HTERR_INVALID_HTPATTERN_INDEX -14
#define HTERR_INVALID_HALFTONE_PATTERN -15
#define HTERR_HTPATTERN_SIZE_TOO_BIG -16
#define HTERR_NO_SRC_COLORTRIAD -17
#define HTERR_INVALID_COLOR_TABLE -18
#define HTERR_INVALID_COLOR_TYPE -29
#define HTERR_INVALID_COLOR_TABLE_SIZE -20
#define HTERR_INVALID_PRIMARY_SIZE -21
#define HTERR_INVALID_PRIMARY_VALUE_MAX -22
#define HTERR_INVALID_PRIMARY_ORDER -23
#define HTERR_INVALID_COLOR_ENTRY_SIZE -24
#define HTERR_INVALID_FILL_SRC_FORMAT -25
#define HTERR_INVALID_FILL_MODE_INDEX -26
#define HTERR_INVALID_STDMONOPAT_INDEX -27
#define HTERR_INVALID_DEVICE_RESOLUTION -28
#define HTERR_INVALID_TONEMAP_VALUE -29
#define HTERR_NO_TONEMAP_DATA -30
#define HTERR_TONEMAP_VALUE_IS_SINGULAR -31
#define HTERR_INVALID_BANDRECT -32
#define HTERR_STRETCH_RATIO_TOO_BIG -33
#define HTERR_CHB_INV_COLORTABLE_SIZE -34
#define HTERR_HALFTONE_INTERRUPTTED -35
#define HTERR_NO_SRC_HTSURFACEINFO -36
#define HTERR_NO_DEST_HTSURFACEINFO -37
#define HTERR_8BPP_PATSIZE_TOO_BIG -38
#define HTERR_16BPP_555_PATSIZE_TOO_BIG -39
#define HTERR_INVALID_ABINFO -40
#define HTERR_INTERNAL_ERRORS_START -10000
#define COLOR_TYPE_RGB 0
#define COLOR_TYPE_XYZ 1
#define COLOR_TYPE_YIQ 2
#define COLOR_TYPE_MAX 2
#define PRIMARY_ORDER_123 0
#define PRIMARY_ORDER_132 1
#define PRIMARY_ORDER_213 2
#define PRIMARY_ORDER_231 3
#define PRIMARY_ORDER_321 4
#define PRIMARY_ORDER_312 5
#define PRIMARY_ORDER_MAX 5
#define PRIMARY_ORDER_RGB PRIMARY_ORDER_123
#define PRIMARY_ORDER_RBG PRIMARY_ORDER_132
#define PRIMARY_ORDER_GRB PRIMARY_ORDER_213
#define PRIMARY_ORDER_GBR PRIMARY_ORDER_231
#define PRIMARY_ORDER_BGR PRIMARY_ORDER_321
#define PRIMARY_ORDER_BRG PRIMARY_ORDER_312
#define PRIMARY_ORDER_CMY PRIMARY_ORDER_123
#define PRIMARY_ORDER_CYM PRIMARY_ORDER_132
#define PRIMARY_ORDER_MCY PRIMARY_ORDER_213
#define PRIMARY_ORDER_MYC PRIMARY_ORDER_231
#define PRIMARY_ORDER_YMC PRIMARY_ORDER_321
#define PRIMARY_ORDER_YCM PRIMARY_ORDER_312
#define PRIMARY_ORDER_XYZ PRIMARY_ORDER_123
#define PRIMARY_ORDER_XZY PRIMARY_ORDER_132
#define PRIMARY_ORDER_YXZ PRIMARY_ORDER_213
#define PRIMARY_ORDER_YZX PRIMARY_ORDER_231
#define PRIMARY_ORDER_ZYX PRIMARY_ORDER_321
#define PRIMARY_ORDER_ZXY PRIMARY_ORDER_312
#define PRIMARY_ORDER_YIQ PRIMARY_ORDER_123
#define PRIMARY_ORDER_YQI PRIMARY_ORDER_132
#define PRIMARY_ORDER_IYQ PRIMARY_ORDER_213
#define PRIMARY_ORDER_IQY PRIMARY_ORDER_231
#define PRIMARY_ORDER_QIY PRIMARY_ORDER_321
#define PRIMARY_ORDER_QYI PRIMARY_ORDER_312
//
// COLORTRIAD
//
// This data structure describe the source color informations
//
// Type - One of the following type may be specified.
//
// COLOR_TYPE_RGB - primaries are RGB.
// COLOR_TYPE_XYZ - primaries are CIE XYZ.
// COLOR_TYPE_YIQ - primaries are NTSC YIQ.
//
// BytesPerPrimary - Specified how many bytes used per primary color, it
// must be one of the following
//
// 1 - BYTE
// 2 - WORD
// 4 - DWORD
//
// All 3 primaries must be consecutive in memory.
//
// BytesPerEntry - Specified how many bytes used for color table entry,
// each entry specified 3 primaries colors.
//
// PrimaryOrder - The primaries order in the color table, it can be
// one of the defined PRIMARY_ORDER_abc, for each entry
// in the memory it defined as
//
// PRIMARY_ORDER_abc
// |||
// ||+-- highest memory location
// ||
// |+--- middle
// |
// +---- Lowest memory location
//
// All 3 primaries must be consecutive in memory.
//
// PrimaryValueMax - The maximum value for the primary color, this is used
// to nomalized the input colors, for example a 8-bit
// RGB color table will specified 255.
//
// ColorTableEntries - Total entries of the color table pointed by the
// pColorTable.
//
// pColorTable - Pointer to the start of color table, the size of the
// this color table must at least (BytesPerEntry *
// ColorTableEntries).
//
// If the first primary color in the color table entry
// is not at first byte of the pColorTable, then caller
// must specified the pColorTable at first primary
// color. (pColorTable += Offset(first primary).
//
//
typedef struct _COLORTRIAD { BYTE Type; BYTE BytesPerPrimary; BYTE BytesPerEntry; BYTE PrimaryOrder; LONG PrimaryValueMax; DWORD ColorTableEntries; LPVOID pColorTable;} COLORTRIAD, FAR *PCOLORTRIAD;
//
// HTSURFACEINFO
//
// This data structure describe the the input/output surface in order for
// halftone function to render the output, this data structure only used for
// the memory device.
//
// hSurface - This is 32-bits handle which will be passed back
// to the caller's callback function.
//
// Flags - One or more following flags may be defined
//
// HTSIF_SCANLINES_TOPDOWN
//
// This flag is ignored
//
// SurfaceFormat - Following formats are defined
//
// BMF_1BPP
//
// 1-bit per pel format, this is the index
// number (0 or 1) for the color table/palette.
//
// BMF_4BPP
//
// 4-bit per pel and pack two pels to a byte
// starting from high nibble (bit 4-7) format,
// this is the index number (0-7) for the
// color table/palette. (ONLY LOW 3 bits of
// the nibble is used)
//
// BMF_4BPP_VGA16
//
// 4-bit per pel and pack two pels to a byte
// starting from high nibble (bit 4-7) format,
// this is the index number (0-15) for the
// standard VGA 16 colors table/palette.
//
// The different from BMF_4BPP is this indices
// are fixed to standard VGA 16 colors as
//
// Index# Colors Lightness
// ---------------------------------
// 0 Black 0%
// 1 Red 50%
// 2 Green 50%
// 3 Yellow 50%
// 4 Blue 50%
// 5 Magenata 50%
// 6 Cyan 50%
// 7 Gray 50%
// 8 Gray 75%
// 9 Red 100%
// 10 Green 100%
// 11 Yellow 100%
// 12 Blue 100%
// 13 Magenata 100%
// 14 Cyan 100%
// 15 White 100%
//
// Notice that the color order is
//
// Bit 2 = Blue, Bit 1 = Green, Bit 0 = Red
//
// This format can only be used as destination
// surface, when used as destination surface
// the halftone dll automatically set it to
// USE_ADDITIVE_PRIMS and set the primaries
// order as PRIMARY_ORDER_BGR.
//
// BMF_8BPP
//
// 8-bit per pel format (1 byte each), this is
// the index number (0-255) for the color
// table/palette. The format is not allowed
// for the destination surface.
//
// BMF_8BPP_VGA256
//
// 8-bit per pel format (1 byte each), this is
// the index number (0-255) for the color
// table/palette.
//
// The different from BMF_8BPP is this indices
// are fixed to halftone special colors.
//
// The color table (palette) is defined by
// halftone.dll, the display should call
// HT_Get8BPPFormatPalette() api call to get
// the current palette used by the halftone.
//
// The HT_GetBPPFormatPalette() will only need
// to called once until next time the display
// caliberation occurred.
//
// Halftone.dll will not used all 256 colors
// in the system palette, it will leave some
// 20 or more entries for the system colors.
//
// BMF_16BPP
//
// 16-bit per pel format (16 bits each), this
// is the index number (0-65535) for the color
// table/palette. The format is not allowed
// for the destination surface.
//
// BMF_16BPP_555
//
// 16-bit per pel format (only 15 bits used),
// each primary occupy 5 bits, the layout of
// bits as follow
//
// bit 10-15 - Primary A
// bit 5- 9 - Primary B
// bit 0- 4 - Primary C
//
// The order of the Primary A, B and C is
// specfied by PRIMARY_ORDER_xxx.
//
// for each primary there are 32 gradations,
// and halftone.dll output is assume to be
// linear. (non-gamma corrected), this format
// only allowed for destination surface.
//
// BMF_24BPP
//
// 24-bit per pel format (8-bit per color),
// the order of RGB color stored in the source
// bitmap or color table.
//
// BMF_32BPP
//
// Same as BMF_24BPP but with extra byte
// packing, if the extra byte is packed at
// begining (the first color is starting from
// second byte of that 4 bytes) then caller
// must set the pColorTable = pColorTable + 1
// or set pPlane = pPlane + 1, to skip first
// unused byte.
//
// NOTE: Allowed source formats are
//
// 1) BMF_1BPP
// 2) BMF_4BPP
// 3) BMF_8BPP
// 4) BMF_16BPP
// 5) BMF_24BPP
// 6) BMF_32BPP
//
// Allowed destination formats are
//
// 1) BMF_1BPP
// 2) BMF_4BPP
// 3) BMF_4BPP_VGA16
// 4) BMF_8BPP_VGA256
// 5) BMF_16BPP_555
//
// Any other mismatch cause error returned.
//
// ScanLineAlignBytes - Total bytes needed to aligned for each scan line
// in the surface bitmap, it can be any unsigned
// 8-bit number, the common ones are defined as
//
// BMF_ALIGN_BYTE ( 8-bit aligned)
// BMF_ALIGN_WORD (16-bit aligned)
// BMF_ALIGN_DWORD (32-bit aligned)
// BMF_ALIGN_QWORD (64-bit aligned)
//
// Width - The width of the surface in pels.
//
// Height - The height of the surface in scan lines.
//
// ScanLineDelta - Specified scan lines Delta in bytes, this member
// indicate how many bytes to be added for advanced
// to next scan line
//
// pPlane - This pointer points to the first scan line in
// the defined surface, Scan #0 that is.
//
// pColorTriad - Pointe to the COLORTRIAD data structure to
// specified the source color table, this pointer
// only examined by the halftone.dll for source
// surface.
//
#if !defined( BMF_DEVICE ) && \
!defined( BMF_1BPP ) && \ !defined( BMF_4BPP ) && \ !defined( BMF_8BPP ) && \ !defined( BMF_16BPP ) && \ !defined( BMF_24BPP ) && \ !defined( BMF_32BPP )
#define BMF_1BPP 1
#define BMF_4BPP 2
#define BMF_8BPP 3
#define BMF_16BPP 4
#define BMF_24BPP 5
#define BMF_32BPP 6
#endif
#define BMF_4BPP_VGA16 255
#define BMF_8BPP_VGA256 254
#define BMF_16BPP_555 253
#define BMF_16BPP_565 252
#define BMF_HT_LAST BMF_16BPP_565
//
// Following are common used alignment bytes for the bitmap
//
#define BMF_ALIGN_BYTE 1 // 8 bits = 1 byte
#define BMF_ALIGN_WORD 2 // 16 bits = 2 bytes
#define BMF_ALIGN_DWORD 4 // 32 bits = 4 bytes
#define BMF_ALIGN_QWORD 8 // 64 bits = 8 bytes
#define HTSIF_SCANLINES_TOPDOWN W_BITPOS(0)
typedef struct _HTSURFACEINFO { ULONG_PTR hSurface; WORD Flags; BYTE SurfaceFormat; BYTE ScanLineAlignBytes; LONG Width; LONG Height; LONG ScanLineDelta; LPBYTE pPlane; PCOLORTRIAD pColorTriad; } HTSURFACEINFO;
typedef HTSURFACEINFO FAR *PHTSURFACEINFO;
//
// HTCALLBACKPARAMS
//
// This is structure is used durning the bitmap halftone process to obtains
// the source or destination bitmap surface pointers.
//
//
// hSurface - This is the handle which passed to the
// halftone DLL, durning the HTHalftoneBitmap() call,
// (in HTSURFACEINFO data structure) it may be
// handle to source or destination depends on the
// nature of the callback.
//
// CallBackMode - Specified the nature of the callback.
//
// HTCALLBACK_QUERY_SRC
//
// The callback is quering the source bitmap
// pointer.
//
// HTCALLBACK_QUERY_SRC_MASK
//
// The callback is quering the source mask
// bitmap pointer.
//
// HTCALLBACK_QUERY_DEST
//
// The callback is quering the destination
// bitmap pointer(s).
//
// HTCALLBACK_SET_DEST
//
// The callback is used to release halftoned
// destination. It will called in following
// conditions:
//
// 1) Before HTCALLBACK_QUERY_DEST call
// except for the very first query
// destination.
//
// 2) After the halftone process is
// completed. This give the chance for
// the caller to process the last
// halftoned destination block.
//
// SurfaceFormat - This is the surface format specified in the
// original HTSURFACEINFO.
//
// Flags - This is the copy of HTSURFACEINFO.Flags.
//
// BytesPerScanLine - This is the total bytes per scan line for the
// surface bitmap which computed by the halftone
// DLL according to the 'ScanLineAlignBytes' in the
// HTSURFACEINFO data structure, it can be used by
// the caller to calculate source/destination
// pointers information.
//
// ScanStart - Requested starting scan line number, the scan
// lines are number from 0 up, this number will
// guaranteed has following propertites:
//
// 1) It always greater than or equal to zero.
// 2) It will never greater than or equal to the
// 'height' field specified in the
// HTSURFACEINFO.
//
// NOTE: for banding destination surface it
// will never greater than or equal to
// the (rclBand.bottom - rclBand.top).
//
// 3) The scan line number 0 always refer to the
// physical lowest bitmap memory location
// regardless HTSIF_SCANLINES_TOPDOWN flag set
// or not, durning callback the caller only
// need to compute array like bitmap buffer,
// halftone DLL will compute the correct
// ScanStart if the bitmap is not TOPDOWN.
//
// ScanCount - Total scan lines requested starting from
// ScanStart, this number will guaranteed has
// following propertites:
//
// 1) It always greater than zero.
// 2) Never greater then the MaximumQueryScanLines
// specified for the surface (in HTSURFACEINFO
// data structure).
//
// NOTE: for banding destination surface it
// will never greater than the
// (rclBand.bottom - rclBand.top).
//
// NOTE: 1) ScanStart/ScanCount
//
// If the flags HTSURFACEINFO data
// structure HTSIF_SCANLINES_TOPDOWN is not
// specified then halftone DLL automatically
// calculate the correct ScanStart/ScanCount
// for read/write the up-side-down bitmap.
//
// For example:
//
// If the surface bitmap is up-side-down
// type DIB) and has 100 scan lines height
// (scan line #99 is the top of the bitmap),
// if halftone DLL need to get to scan line
// 10-14 (Start from scan line 10 and 5
// lines) then halftone DLL will flip Y,
// and passed ScanStart = 85 and ScanCount
// = 5, but if the HTSIF_SCANLINES_TOPDOWN
// flag is set (Non DIB type format) then
// callback parameters will then be
// ScanStart = 10 and ScanCount = 5.
//
// 2) The ScanStart for the callback function
// always consider the lowest bitmap in the
// memory as scan line 0, that is when
// callback fucntion received control, it
// only need to consider the ScanStart as
// physical scan line location which the
// Scan line #0 always starting from lowest
// bitmap memory location.
//
// 3) The width of the destination buffer is
// considered as 'Width' field specified
// for the destination HTSURFACEINFO, if
// destination is BANDed (horizontal or
// vertical) then its width is computed as
// Band.right - Band.left. and the result
// always Band.left/Band.top aligned.
//
// 4) If caller return 'ScanCount' diff from
// the one requested then caller must check
//
// HTSIF_SCANLINES_TOPDOWN flag is SET
//
// 1. Process 'ScanStart' and
// 'ScanCount' fields as normal.
//
// 2. Set New ScanCount to passed
// callback data structure.
// (ie. HTCallBackParam.ScanCount)
//
//
// HTSIF_SCANLINES_TOPDOWN flag is CLEAR
//
// 1. Re-compute 'ScanStart' before
// compute pPlane as
//
// ScanStart = ScanStart -
// (NewScanCount -
// RequsetedScanCount)
//
// 2. Process 'ScanStart' and
// 'ScanCount' fields as normal.
//
// 3. Set New ScanStart to passed
// callback data structure.
// (ie. HTCallBackParam.ScanStart)
//
// 4. Set New ScanCount to passed
// callback data structure.
// (ie. HTCallBackParam.ScanCount)
//
// The returned new 'ScanCount' must not
// greater then the 'RemainedSize' field.
//
// MaximumQueryScanLines - This is the copy of the MaximumQueryScanLines
// field from the HTSURFACEINFO data structure which
// passed to the the HT_HaltoneBitmap() calls.
// Depends on the nature of the callback, it may be
// source or destination.
//
// NOTE: for banding surface, it will be limited to
// (rclBand.bottom - rclBand.top) if it is
// greater than that number.
//
// RemainedSize - This field specified how many scan lines remained
// to be queried, the remainded scan lines are not
// include current call.
//
// pPlane - pointer points to the begining of first plane of
// the surface. If the callback is quering the
// source then this is the only pointer which need
// to be updated by the callback function.
//
// NOTE: The pPlane must points to the first byte
// of the 'ScanStart' scan line number.
//
// Field(s) returned from callback
//
// 1) HTCALLBACK_QUERY_SRC - pPlane (Options: ScanStart/ScanCount)
// 2) HTCALLBACK_QUERY_SRC_MASK - pPlane (Options: ScanStart/ScanCount)
// 2) HTCALLBACK_QUERY_DEST - pPlane (Options: ScanStart/ScanCount)
// 4) HTCALLBACK_SET_DEST - none.
//
#define HTCALLBACK_QUERY_SRC 0
#define HTCALLBACK_QUERY_SRC_MASK 1
#define HTCALLBACK_QUERY_DEST 2
#define HTCALLBACK_SET_DEST 3
#define HTCALLBACK_MODE_MAX HTCALLBACK_SET_DEST
typedef struct _HTCALLBACKPARAMS { ULONG_PTR hSurface; BYTE CallBackMode; BYTE SurfaceFormat; WORD Flags; LONG BytesPerScanLine; LONG ScanStart; WORD ScanCount; WORD MaximumQueryScanLines; LONG RemainedSize; LPBYTE pPlane; } HTCALLBACKPARAMS;
typedef HTCALLBACKPARAMS FAR *PHTCALLBACKPARAMS;
//
// _HTCALLBACKFUNC
//
// The callback function is used to obtain the source and/destination bitmap
// surface durning the halftone process, the halftone DLL will using call
// back function is following sequences.
//
// 1) Callback to obtain block of the source bitmap, it depensds on
// the maximum query scan lines limit by the caller. (in HTSURFACEINFO)
//
// 3) Callback to obtain block of the destination bitmap, it depends on
// the maximum query scan lines limit by the caller. (in HTSURFACEINFO)
//
// 4) Repeat 1), 2), 3) until destination maximum queried scan lines are
// processed then callback to the caller to release the processed
// destination.
//
// 5) Repat 1), 2), 3) and 4) unitil all source/destination scan lines are
// processed.
//
// The return value of the callback is a boolean value, if false the halftone
// processed is interrupted and an erro code is returned, if callback function
// return true then halftone DLL assume that all queried scan lines are
// reachable by the return pointer (in the HTCALLBACKPARAMS data structure).
//
// NOTE: 1) If the callback function query for 100 lines and return value is
// ture then there must all 100 scan lines can be accessable by the
// halftone dll through the pointer(s).
//
// 2) If the caller has all the bitmap in the memory it should set the
// maximum query scan lines count to the bitmap height to reduced the
// callback calls.
//
// 3) If the caller do not need to released the halftoned destination
// then it should not set the HTCBPF_NEED_SET_DEST_CALLBACK flag
// to reduces callback calls.
//
// The callback function must be
//
// 1) Must return a 16-bit 'BOOLEAN' (TRUE/FALSE)
// 2) Must 32-bit far function
// 3) _loadds if you using your data segment at all from callback fuction
//
typedef BOOL (APIENTRY *_HTCALLBACKFUNC)(PHTCALLBACKPARAMS pHTCBParams);#define HTCALLBACKFUNCTION BOOL APIENTRY
//
// HALFTONEPATTERN
//
// The HALFTONEPATTERN data structure is used to describe the halftone
// pattern which will be used by a particular device, if the device choosed
// to used halftone DLL's default pattern then following data structure will
// be automatically calculated by the halftone DLL.
//
// Flags - Various halftone flags for the cell, can be one
// of the following:
//
// Width - Specified the width of the pattern in pels, this
// field must not greater than MAX_HTPATTERN_WIDTH.
//
// Height - Specified the Width of the pattern in scan line,
// this field only must not greater than
// MAX_HTPATTERN_HEIGHT.
//
// pHTPatA
// pHTPatB
// pHTPatC - Specified caller defined pattern. The data items
// points by these pointer must have minimum of
// (Width * Height) bytes.
//
// These are the pointers to BYTE array contains
// threshold data, the size of the array must be
// 'Width * Height' in bytes. The data in the
// array should range from 1 to 255, a zero (0)
// indicate the pixel location is ignored.
//
// All thresholds values are indicate additive
// intensities, a zero indicate black pixel always.
// a 255 threshold value indicate the pixel always
// turn on to white.
//
// Halftone DLL use this thresholds array with
// device X, Y, PEL resolution and specified input/
// output relationship to compute color
// transformation
//
#define MAX_HTPATTERN_WIDTH 256
#define MAX_HTPATTERN_HEIGHT 256
//
// Following are the predefined halftone pattern sizes for 'HTPatternIndex'
//
#define HTPAT_SIZE_2x2 0
#define HTPAT_SIZE_2x2_M 1
#define HTPAT_SIZE_4x4 2
#define HTPAT_SIZE_4x4_M 3
#define HTPAT_SIZE_6x6 4
#define HTPAT_SIZE_6x6_M 5
#define HTPAT_SIZE_8x8 6
#define HTPAT_SIZE_8x8_M 7
#define HTPAT_SIZE_10x10 8
#define HTPAT_SIZE_10x10_M 9
#define HTPAT_SIZE_12x12 10
#define HTPAT_SIZE_12x12_M 11
#define HTPAT_SIZE_14x14 12
#define HTPAT_SIZE_14x14_M 13
#define HTPAT_SIZE_16x16 14
#define HTPAT_SIZE_16x16_M 15
#define HTPAT_SIZE_SUPERCELL 16
#define HTPAT_SIZE_SUPERCELL_M 17
#define HTPAT_SIZE_USER 18
#define HTPAT_SIZE_MAX_INDEX HTPAT_SIZE_USER
#define HTPAT_SIZE_DEFAULT HTPAT_SIZE_SUPERCELL_M
typedef struct _HALFTONEPATTERN { WORD cbSize; WORD Flags; WORD Width; WORD Height; LPBYTE pHTPatA; LPBYTE pHTPatB; LPBYTE pHTPatC; } HALFTONEPATTERN, FAR *PHALFTONEPATTERN;
//
// CIECOORD
//
// This data structure defined a C.I.E color space coordinate point, the
// coordinate is in DECI4 format.
//
// x - x coordinate in C.I.E color space
//
// y - y coordinate in C.I.E color space.
//
// Y - The liminance for the color
//
//
#define CIE_x_MIN (UDECI4)10
#define CIE_x_MAX (UDECI4)8000
#define CIE_y_MIN (UDECI4)10
#define CIE_y_MAX (UDECI4)8500
typedef struct _CIECOORD { UDECI4 x; UDECI4 y; UDECI4 Y; } CIECOORD;
typedef CIECOORD FAR *PCIECOORD;
//
// CIEINFO
//
// This data structure describe the red, green, blue, cyan, magenta, yellow
// and alignment white coordinate in the C.I.E color space plus the Luminance
// factor, these are used to calculate the C.I.E. transform matrix and its
// inversion.
//
// Red - Red primary color in CIRCOORD format.
//
// Green - Green primary color in CIRCOORD format.
//
// Blue - Blue primary color in CIRCOORD format.
//
// Cyan - Cyan primary color in CIRCOORD format.
//
// Magenta - Magenta primary color in CIRCOORD format.
//
// Yellow - Yellow primary color in CIRCOORD format.
//
// AlignmentWhite - Alignment white in CIECOORD format.
//
typedef struct _CIEINFO { CIECOORD Red; CIECOORD Green; CIECOORD Blue; CIECOORD Cyan; CIECOORD Magenta; CIECOORD Yellow; CIECOORD AlignmentWhite; } CIEINFO;
typedef CIEINFO FAR *PCIEINFO;
//
// SOLIDDYESINFO
//
// This data structure specified device cyan, magenta and yellow dyes
// concentration.
//
// MagentaInCyanDye - Mangenta component proportion in Cyan dye.
//
// YellowInCyanDye - Yellow component proportion in Cyan dye.
//
// CyanInMagentaDye - Cyan component proportion in Magenta dye.
//
// YellowInMagentaDye - Yellow component proportion in Magenta dye.
//
// CyanInYellowDye - Yellow component proportion in Cyan dye.
//
// MagentaInYellowDye - Magenta component proportion in Cyan dye.
//
// NOTE: all fields in this data structure is UDECI4 number, range from
// UDECI4_0 to UDECI_4, ie,; 0.0 to 1.0, this a inpurity proportion
// percentge in primary dye, for example a MagentaInCyanDye=1200
// mean a 0.12% of magenta component is in device Cyan dye.
//
typedef struct _SOLIDDYESINFO { UDECI4 MagentaInCyanDye; UDECI4 YellowInCyanDye; UDECI4 CyanInMagentaDye; UDECI4 YellowInMagentaDye; UDECI4 CyanInYellowDye; UDECI4 MagentaInYellowDye; } SOLIDDYESINFO, FAR *PSOLIDDYESINFO;
//
// HTCOLORADJUSTMENT
//
// This data structure is a collection of the device color adjustments, it
// can be changed at any calls.
//
// Flags - CLRADJF_NEGATIVE
//
// Produced negative picture
//
// CLRADJF_LOG_FILTER
//
// Specified a relative logarithm should
// used to calculate the final density.
//
// IlluminantIndex - Specified the default illuminant of the light
// source which the object will be view under.
// The predefined value has ILLUMINANT_xxxx
// form.
//
// RedPowerGamma - The n-th power applied to the red color
// before any other color tramsformations,
// this is an UDECI4 value.
//
// For example if the RED = 0.8 (DECI4=8000)
// and the RedPowerGammaAdjustment = 0.7823
// (DECI4 = 7823) then the red is equal to
//
// 0.7823
// 0.8 = 0.8398
//
// GreenPowerGamma - The n-th power applied to the green color
// before any other color transformations, this
// is an UDECI4 value.
//
// BluePowerGamma - The n-th power applied to the blue color
// before any other color transformations, this
// is an UDECI4 value.
//
// NOTE: RedPowerGamma/GreenPowerGamma/BluePoweGamma are
// UDECI4 values and range from 100 to 65535 if any
// one of these values is less than 100 (0.01) then
// halftone dll automatically set all power gamma
// adjustments to selected default.
//
// ReferenceBlack - The black shadow reference for the colors
// passed to the halftone dll, if a color's
// lightness is darker than the reference black
// then halftone dll will treated as completed
// blackness and render it with device maximum
// density.
//
// ReferenceWhite - The white hightlight reference for the colors
// passed to the halftone dll, if a color's
// lightness is lighter than the reference white
// then halftone will treated as a specular
// hightlight and redner with device maximum
// intensity.
//
// NOTE: ReferenceBlack Range: 0.0000 - 0.4000
// ReferenceWhite Range: 0.6000 - 1.0000
//
// Contrast - Primary color contrast adjustment, this is
// a SHORT number range from -100 to 100, this
// is the black to white ratio, -100 is the
// lowest contrast, 100 is the highest and 0
// indicate no adjustment.
//
// Brightness - The brightness adjustment, this is a SHORT
// number range from -100 to 100, the brightness
// is adjusted by apply to change the overall
// saturations for the image, -100 is lowest
// brightness, 100 is the hightest and a zero
// indicate no adjustment.
//
// Colorfulness - The primary color are so adjusted that it
// will either toward or away from black/white
// colors, this is a SHORT number range from
// -100 to 100. -100 has less colorful, 100 is
// most colorfull, and a zero indicate no
// adjustment.
//
// RedGreenTint - Tint adjustment between Red/Green primary
// color, the value is a SHORT range from -100
// to 100, it adjust color toward Red if number
// is positive, adjust toward Green if number
// is negative, and a zero indicate no
// adjustment.
//
// NOTE: For Contrast/Brightness/Colorfulness/RedGreenTint adjustments, if its
// value is outside of the range (-100 to 100) then halftone DLL
// automatically set its to selected default value.
//
#ifndef _WINGDI_
// in WinGDI.H
//
// The following are predefined alignment white for 'IlluminantIndex'.
//
// If ILLUMINANT_DEFAULT is specified
//
// 1) if pDeviceCIEInfo is NULL or pDeviceCIEInfo->Red.x eqaul to 0 then
// halftone DLL automatically choosed approx. illuminant for the output
// device.
//
// 2) if pDeviceCIEInfo is NOT null and pDeviceCIEInf->Red.x not equal to 0
// then the 'White' field is used as illuminant alignment white.
//
// If other ILLUMINANT_xxxx is specified it will be used as alignment white
// even pDeviceCIEInfo is not null.
//
// If the IlluminantIndex is > ILLUMINANT_MAX_INDEX then halftone DLL will
// automatically choosed approx. illuminant even pDeviceCIEInfo is not NULL.
//
#define ILLUMINANT_DEVICE_DEFAULT 0
#define ILLUMINANT_A 1
#define ILLUMINANT_B 2
#define ILLUMINANT_C 3
#define ILLUMINANT_D50 4
#define ILLUMINANT_D55 5
#define ILLUMINANT_D65 6
#define ILLUMINANT_D75 7
#define ILLUMINANT_F2 8
#define ILLUMINANT_MAX_INDEX ILLUMINANT_F2
#define ILLUMINANT_TUNGSTEN ILLUMINANT_A
#define ILLUMINANT_DAYLIGHT ILLUMINANT_C
#define ILLUMINANT_FLUORESCENT ILLUMINANT_F2
#define ILLUMINANT_NTSC ILLUMINANT_C
#endif
#define MIN_COLOR_ADJ COLOR_ADJ_MIN
#define MAX_COLOR_ADJ COLOR_ADJ_MAX
#define MIN_POWER_GAMMA RGB_GAMMA_MIN
#define NTSC_POWER_GAMMA (UDECI4)22000
//
// The following is the default value
//
#define REFLECT_DENSITY_DEFAULT REFLECT_DENSITY_LOG
#define ILLUMINANT_DEFAULT 0
#define HT_DEF_RGB_GAMMA UDECI4_1
#define REFERENCE_WHITE_DEFAULT UDECI4_1
#define REFERENCE_BLACK_DEFAULT UDECI4_0
#define CONTRAST_ADJ_DEFAULT 0
#define BRIGHTNESS_ADJ_DEFAULT 0
#define COLORFULNESS_ADJ_DEFAULT 0
#define REDGREENTINT_ADJ_DEFAULT 0
#define CLRADJF_NEGATIVE CA_NEGATIVE
#define CLRADJF_LOG_FILTER CA_LOG_FILTER
#define CLRADJF_FLAGS_MASK (CLRADJF_NEGATIVE | \
CLRADJF_LOG_FILTER)
#ifndef _WINGDI_
//
// In WinGDI.H
//
#define REFERENCE_WHITE_MIN (UDECI4)6000
#define REFERENCE_WHITE_MAX UDECI4_1
#define REFERENCE_BLACK_MIN UDECI4_0
#define REFERENCE_BLACK_MAX (UDECI4)4000
typedef struct tagCOLORADJUSTMENT { WORD caSize; WORD caFlags; WORD caIlluminantIndex; WORD caRedGamma; WORD caGreenGamma; WORD caBlueGamma; WORD caReferenceBlack; WORD caReferenceWhite; SHORT caContrast; SHORT caBrightness; SHORT caColorfulness; SHORT caRedGreenTint;} COLORADJUSTMENT, *PCOLORADJUSTMENT, FAR *LPCOLORADJUSTMENT;
#endif
#define HTCOLORADJUSTMENT COLORADJUSTMENT
typedef HTCOLORADJUSTMENT *PHTCOLORADJUSTMENT;
//
// HTINITINFO
//
// This data structure is a collection of the device characteristics and
// will used by the halftone DLL to carry out the color composition for the
// designated device.
//
// Version - Specified the version number of HTINITINFO data
// structure. for this version it should set to the
// HTINITINFO_VERSION
//
// Flags - Various flag defined the initialization
// requirements.
//
// HIF_SQUARE_DEVICE_PEL
//
// Specified that the device pel is square
// rather then round object. this only make
// differences when the field
// 'PelResolutionRatio' is greater than 0.01
// and it is not 1.0000.
//
// HIF_HAS_BLACK_DYE
//
// Indicate the device has separate black dye
// instead of mix cyan/magenta/yellow dyes to
// procduced black, this flag will be ignored
// if HIF_ADDITIVE_PRIMS is defined.
//
// HIF_ADDITIVE_PRIMS
//
// Specified that final device primaries are
// additively, that is adding device primaries
// will produce lighter result. (this is true
// for monitor devices and certainly false for
// the reflect devices such as printers).
//
// HIF_USE_8BPP_BITMASK
//
// Specified use CMYBitMask8BPP field is used,
// when destination surface is BMF_8BPP_VGA256
// see CMYBitMask8BPP field for more detail
//
// HIF_INVERT_8BPP_BITMASK_IDX
// Render the 8bpp mask mode with inversion of
// its indices. This is implemented for fix
// Windows GDI rop problem, it will render as
// RGB additive indices. The caller must
// do a inversion of final image's Indices
// (Idx = ~Idx or Idx ^= 0xFF) to get the
// correct CMY332 data. When this bit is
// set, the HT_Get8BPPMaskPalette must have
// its pPaletteEntry[0] Initialized to as
//
// pPaletteEntry[0].peRed = 'R';
// pPaletteEntry[0].peGreen = 'G';
// pPaletteEntry[0].peBlue = 'B';
// pPaletteEntry[0].peFlags = '0';
//
// to indicate that a RGB indices inverted
// palette should be returned and not the
// standard CMY palette (Index 0 is white and
// Index 255 is black).
//
// The inverted palette has is first entry as
// BLACK and last entry as WHITE
//
// pPaletteEntry[0].peRed = 0x00;
// pPaletteEntry[0].peGreen = 0x00;
// pPaletteEntry[0].peBlue = 0x00;
// pPaletteEntry[0].peFlags = 0x00;
//
// Notice that this setting WILL NOT work on
// earlier version of halftone (Windows 2000
// and earlier), so the caller must check the
// OS version or check the returned palette
// to ensure that first palette entry is
// BLACk rather than WHITE. If first
// entries is WHITE after initialized to
// 'R', 'G', 'B', '0' then this is a older
// version of system that does not recongnized
// the initialzed value. In this case the
// caller should not invert (Idx ^= 0xFF) the
// halftoned imaged indices when render it
// to the devices, because the halftone
// images in this case is CMY based already.
//
//
// HTPatternIndex - Default halftone pattern index number, the
// indices is predefine as HTPAT_SIZE_xxxx, this
// field only used if pHTalftonePattern pointer is
// not NULL.
//
// DevicePowerGamma - This field is used to adjust halftone pattern
// cell's gamma, the gamma applied to all the rgb
// colors, see gamma description in
// HTCOLORADJUSTMENT above.
//
// HTCallBackFunction - a 32-bit pointer to the caller supplied callback
// function which used by the halftone DLL to
// obtained the source/destination bitmap pointer
// durning the halftone process, if this pointer is
// NULL then halftone dll assume that caller does
// not need any callback and generate an error if a
// callback is needed.
//
// pHalftonePattern - pointer to HALFTONEPATTERN data structure, see
// descriptions above, if this pointer is NULL then
// halftone using HTPatternIndex field to select
// default halftone dll's pattern.
//
// pInputRGBInfo - Specified input's rgb color' coordinates within
// the C.I.E. color spaces. If this pointer is NULL
// or pInputRGBInfo->Red.x is 0 (UDECI4_0) then it
// default using NTSC standard to convert the input
// colors.
//
// pDeviceCIEInfo - Specified device primary color coordinates within
// the C.I.E. color space, see CIEINFO data
// structure, if the pointer is NULL or
// pDeviceCIEInfo->Red.x is 0 (UDECI4_0) then
// halftone DLL choose the default for the output
// device.
//
// pDeviceSolidDyesInfo - Specified device solid dyes concentrations, this
// field will be ignored if HIF_ADDITIVE_PRIMS flag
// is defined, if HIF_ADDITIVE_PRIMS is not set and
// this pointer is NULL then halftone dll choose
// approximate default for the output device.
//
// DeviceResXDPI - Specified the device horizontal (x direction)
// resolution in 'dots per inch' measurement.
//
// DeviceResYDPI - Specified the device vertical (y direction)
// resolution in 'dots per inch' measurement.
//
// DevicePelsDPI - Specified the device pel/dot/nozzle diameter
// (if rounded) or width/height (if squared) in
// 'dots per inch' measurement.
//
// This value is measure as if each pel only touch
// each other at edge of the pel.
//
// If this value is 0, then it assume that each
// device pel is rectangular shape and has
// DeviceResXDPI in X direction and DeviceResYDPI
// in Y direction.
//
// DefHTColorAdjustment - Specified the default color adjustment for
// this device. see HTCOLORADJUSTMENT data
// structure above for detail.
//
// DeviceRGamma
// DeviceGGamma
// DeviceBGamma - Red, Green, Blue gammas for the device
//
// CMYBitMask8BPP - only used for the BMF_8BPP_VGA256 destination
// surface. It indicate the how the device surface
// color are translated, when HTF_USE_8BPP_BITMASK
// bit is turn on, this byte is the CYAN. MAGENTA
// YELLOW dye levels indicator.
//
// This byte indicate how many levels for each cyan,
// magenta and yellow color, and this is how the
// halftone write to the destination surface.
//
//
// Bit 7 6 5 4 3 2 1 0
// | | | | | |
// +---+ +---+ +=+
// | | |
// | | +-- Yellow 0-3 (4 levels)
// | |
// | +-- Magenta 0-7 (8 levels)
// |
// +-- Cyan 0-7 (8 levels)
//
//
// The maximum in the bits configuration is 3:3:2,
// Other invalid combination generate different
// output as
//
// 0 - Indicate a gray scale output, the output
// byte is a 0-255 of 256 levels gray
//
// 1 - a 5x5x5 cube output, each cyan, magenta
// and yellow color are 0-4 of 5 levels and
// each color is in 25% increment.
//
// 2 - a 6x6x6 cube output, each cyan, magenta
// and yellow color are 0-5 of 6 levels and
// each color is in 20% increment.
//
// Other value that have 0 level in one of cyan,
// magenta or yellow will generate an error.
//
// To obtain a palette for each of configuration
// you can call HT_Get8BPPMaskPalette()
//
#define HTINITINFO_VERSION2 (DWORD)0x48546902 // 'HTi\02'
#define HTINITINFO_VERSION (DWORD)0x48546903 // 'HTi\03'
#define HTINITINFO_V3_CB_EXTRA 8
#define HIF_SQUARE_DEVICE_PEL 0x0001
#define HIF_HAS_BLACK_DYE 0x0002
#define HIF_ADDITIVE_PRIMS 0x0004
#define HIF_USE_8BPP_BITMASK 0x0008
#define HIF_INK_HIGH_ABSORPTION 0x0010
#define HIF_INK_ABSORPTION_INDICES 0x0060
#define HIF_DO_DEVCLR_XFORM 0x0080
#define HIF_USED_BY_DDI 0x0100
#define HIF_PRINT_DRAFT_MODE 0x0200
#define HIF_INVERT_8BPP_BITMASK_IDX 0x0400
#define HIF_BIT_MASK (HIF_SQUARE_DEVICE_PEL | \
HIF_HAS_BLACK_DYE | \ HIF_ADDITIVE_PRIMS | \ HIF_USE_8BPP_BITMASK | \ HIF_INK_HIGH_ABSORPTION | \ HIF_INK_ABSORPTION_INDICES | \ HIF_DO_DEVCLR_XFORM | \ HIF_PRINT_DRAFT_MODE | \ HIF_INVERT_8BPP_BITMASK_IDX)
#define HIF_INK_ABSORPTION_IDX0 0x0000
#define HIF_INK_ABSORPTION_IDX1 0x0020
#define HIF_INK_ABSORPTION_IDX2 0x0040
#define HIF_INK_ABSORPTION_IDX3 0x0060
#define HIF_HIGHEST_INK_ABSORPTION (HIF_INK_HIGH_ABSORPTION | \
HIF_INK_ABSORPTION_IDX3)#define HIF_HIGHER_INK_ABSORPTION (HIF_INK_HIGH_ABSORPTION | \
HIF_INK_ABSORPTION_IDX2)#define HIF_HIGH_INK_ABSORPTION (HIF_INK_HIGH_ABSORPTION | \
HIF_INK_ABSORPTION_IDX1)#define HIF_NORMAL_INK_ABSORPTION HIF_INK_ABSORPTION_IDX0
#define HIF_LOW_INK_ABSORPTION (HIF_INK_ABSORPTION_IDX1)
#define HIF_LOWER_INK_ABSORPTION (HIF_INK_ABSORPTION_IDX2)
#define HIF_LOWEST_INK_ABSORPTION (HIF_INK_ABSORPTION_IDX3)
#define HTBITMASKPALRGB_DW (DWORD)'0BGR'
#define SET_HTBITMASKPAL2RGB(pPal) (*((LPDWORD)(pPal)) = HTBITMASKPALRGB_DW)
#define IS_HTBITMASKPALRGB(pPal) (*((LPDWORD)(pPal)) == (DWORD)0)
//
// This defined the minimum acceptable device resolutions
//
#define MIN_DEVICE_DPI 12
typedef struct _HTINITINFO { DWORD Version; WORD Flags; WORD HTPatternIndex; _HTCALLBACKFUNC HTCallBackFunction; PHALFTONEPATTERN pHalftonePattern; PCIEINFO pInputRGBInfo; PCIEINFO pDeviceCIEInfo; PSOLIDDYESINFO pDeviceSolidDyesInfo; UDECI4 DevicePowerGamma; WORD DeviceResXDPI; WORD DeviceResYDPI; WORD DevicePelsDPI; HTCOLORADJUSTMENT DefHTColorAdjustment; UDECI4 DeviceRGamma; UDECI4 DeviceGGamma; UDECI4 DeviceBGamma; BYTE CMYBitMask8BPP; BYTE bReserved; } HTINITINFO, FAR *PHTINITINFO;
//
// BITBLTPARAMS
//
// This data structure is used when calling the HT_HalftoneBitmap(), it
// defined where to halftone from the source bitmap to the destination
// bitmap.
//
// Flags - Various flags defined how the source, destination and
// source mask should be calculated.
//
// BBPF_HAS_DEST_CLIPRECT
//
// Indicate that there is a clipping
// rectangle for the destination and it is
// specified by DestClipXLeft, DestClipXRight,
// DestClipYTop and DestClipYBottom
//
// BBPF_USE_ADDITIVE_PRIMS
//
// Specified if the halftone result will be
// using Red/Green/Blue primary color or
// using Cyan/Magenta/Yellow primary color, depends
// on the destination surface format as
//
// BMF_1BPP:
//
// Additive Prims: 0=Black, 1=White
// Substractive Prims: 0=White, 1=Black
//
// BMF_4BPP_VGA16:
//
// Always using RED, GREEN, BLUE primaries, and
// ignored this flag.
//
// BMF_4BPP:
//
// Additive Prims: RED, GREEN. BLUE
// Substractive Prims: CYAN, MAGENTA, YELLOW
//
// The order of the RGB, or CMY is specified by
// DestPrimaryOrder field. (see below)
//
// BMF_8BPP_VGA256:
// BMF_16BPP_555:
// BMF_16BPP_565:
// BMF_24BPP:
// BMF_32BPP:
//
// Always using RED, GREEN, BLUE primaries, and
// ignored this flag.
//
// BBPF_NEGATIVE_DEST
//
// Invert the final destination surface, so
// after the halftone it just the negative
// result from the source.
//
// BBPF_INVERT_SRC_MASK
//
// Invert the source mask bits before using
// it, this in effect make mask bit 0 (off)
// for copy the source and mask bit 1 (on)
// for preserved the destination.
//
// BBPF_HAS_BANDRECT
//
// Set to specified that rclBand RECTL data structrue
// should be used to compute for the caller's
// destination bitmap buffer.
//
// If this flag is not set then halftone dll assumed
// the caller's bitmap buffer is same width/height
// as specified in the destination HTSURFACEINFO.
//
// BBPF_BW_ONLY
//
// Produced monochrome version of the output even the
// destination is the color device.
//
// BBPF_TILE_SRC
//
// Tilt the source to destination and source bitmap
// when this bit is set the source mask is ignored.
//
// BBPF_ICM_ON
//
// When set, the halftone will use the input color
// directly without any modification
//
// BBPF_NO_ANTIALIASING
//
// Turn off anti-aliasing when halftone
//
//
// DestPrimaryOrder- Specified destination primary color order, it can be
// either PRIMARY_ORDER_RGB or PRIMARY_ORDER_CMY group, it
// depends on the surface format has following meaning.
//
// BMF_1BPP:
//
// This field is ignored.
//
// BMF_4BPP_VGA16:
//
// This field automatically set to PRIMARY_ORDER_BGR
// by the halftone DLL.
//
// BMF_4BPP:
//
// for each byte there are two indices entries, and
// for each nibble has following meaning, notice that
// bit 3/7 always set to 0, the index number only
// range from 0 to 7.
//
// PRIMARY_ORDER_abc
// |||
// ||+-- bit 0/4
// ||
// |+--- bit 1/5
// |
// +---- bit 2/7
//
// BMF_8BPP_VGA256:
//
// This field is ignored, the palette entries and its
// order is defined by halftone DLL at run time, the
// caller should get the palette for the VGA256
// surface through HT_Get8BPPFormatPalette() API call.
//
// BMF_16BPP_555:
//
// PRIMARY_ORDER_abc
// |||
// ||+-- bit 0-4 (5 bits)
// ||
// |+--- bit 5-9 (5 bits)
// |
// +---- bit 10-14 (5 bits)
//
// BMF_16BPP_565:
//
// This field is ignored, it alway assume BGR as
// shown below
//
// PRIMARY_ORDER_BGR
// |||
// ||+-- bit 0-4 (5 bits)
// ||
// |+--- bit 5-10 (6 bits)
// |
// +---- bit 11-15 (5 bits)
//
// BMF_24BPP:
//
// This field is ignored, it alway assume BGR as
// shown below
//
// PRIMARY_ORDER_BGR
// |||
// ||+-- bit 0-7 (8 bits)
// ||
// |+--- bit 8-15 (8 bits)
// |
// +---- bit 16-23 (8 bits)
//
// BMF_32BPP:
//
// PRIMARY_ORDER_abc
// |||
// ||+-- bit 0-7 (8 bits)
// ||
// |+--- bit 8-15 (8 bits)
// |
// +---- bit 16-23 (8 bits)
//
//
// rclSrc - RECTL data structure defined the source rectangle area
// to be bitblt from, fields in this data structure are
// relative to the source HTSURFACEINFO's width/height.
//
// rclDest - RECTL data structure defined the destination rectangle
// area to be bitblt to, fields in this data structure are
// relative to the destination HTSURFACEINFO's width/height.
//
// rclClip - RECTL data structure defined the destination clipping
// rectangle area, fields in this data structure are
// relative to the destination HTSURFACEINFO's width/height.
//
// rclBand - RECTL data structure defined the device banding rectangle
// area, fields in this data structure are relative to the
// destination HTSURFACEINFO's width/height.
//
// This RECTL only used if BBPF_HAS_BANDRECT flag is set,
// when this flag is set, halftone DLL will automatically
// clipped the destination to this rectangle area and
// copied this rectangle to the output buffer with rclBand's
// left/top aligned to the buffer's physical origin. The
// destination's buffer (bitmap) must the format specified
// in the destination HTSURFACEINFO.
//
// If rclBand rectangle is larger than the logical destination
// surface size (destination HTSURFACEINFO), halftone dll
// still move the the band's left/top location to the 0/0
// origin and extra width/height is remain unchanged.
//
// The rclBand normally is used for device which does not
// have enough memory to hold all the destination surface
// at one time, it just like to repeatly using same buffer
// to temporary holding the halftone results.
//
// The rclBand's left/top/right/bottom may not be negative
// numbers.
//
// ptlSrcMask - a POINTL data structure to specified the logical
// coordinate of starting point for the source mask bitmap,
// this field only used if a HTSURFACEINFO for the source
// mask is passed.
//
// This source mask bitmap must always monochrome and its
// width/height must
//
// Width >= ptlSrcMask.x + source surface width.
// Height >= ptlSrcMask.y + source surface height;
//
//
// NOTE: 1) all RECTL data structure are left/top inclusive and right/bottom
// exclusive.
//
// 2) if rclSrc rectangle is not will ordered it specified the source
// should be inverted before process for not ordered directions.
//
// 3) if rclDest rectangle is not will ordered it specified the
// destination should be inverted after process for not ordered
// directions.
//
// 4) if BBPF_HAS_DEST_CLIPRECT flag is set and rclClip is not well
// ordered or its left equal to its right, or its top equal to its
// bottom, then all destination are clipped, destination will not
// be updated that is.
//
// 5) if BBPF_HAS_BANDRECT flag is set and rclBand is not well orderd
// or it left eqaul to its right, or its top eqaul to its bottom,
// then a HTERR_INVALID_BANDRECT is returned.
//
//
//
// ABIF_USE_CONST_ALPHA_VALUE - The ConstAlphaValue field is used
// ABIF_DSTPAL_IS_RGRBUAD - The pDstPal Pointed to RGBQUAD structure
// array rather PALETTEENTRY array
// ABIF_SRC_ALPHA_IS_PREMUL - In 32bpp per-pixel alpha blending the
// source RGB already pre-multiply with its
// per-pixel alpha value
// ABIF_BLEND_DEST_ALPHA - Only valid if source and destination
// both are 32bpp and per-pixel alpha is used
// d = s + (1 - s) * d
//
#define ABIF_USE_CONST_ALPHA_VALUE 0x01
#define ABIF_DSTPAL_IS_RGBQUAD 0x02
#define ABIF_SRC_ALPHA_IS_PREMUL 0x04
#define ABIF_BLEND_DEST_ALPHA 0x08
typedef struct _ABINFO { BYTE Flags; BYTE ConstAlphaValue; WORD cDstPal; LPPALETTEENTRY pDstPal; } ABINFO, *PABINFO;
#define BBPF_HAS_DEST_CLIPRECT 0x0001
#define BBPF_USE_ADDITIVE_PRIMS 0x0002
#define BBPF_NEGATIVE_DEST 0x0004
#define BBPF_INVERT_SRC_MASK 0x0008
#define BBPF_HAS_BANDRECT 0x0010
#define BBPF_BW_ONLY 0x0020
#define BBPF_TILE_SRC 0x0040
#define BBPF_ICM_ON 0x0080
#define BBPF_NO_ANTIALIASING 0x0100
#define BBPF_DO_ALPHA_BLEND 0x0200
typedef struct _BITBLTPARAMS { WORD Flags; BYTE bReserved; BYTE DestPrimaryOrder; PABINFO pABInfo; RECTL rclSrc; RECTL rclDest; RECTL rclClip; RECTL rclBand; POINTL ptlBrushOrg; POINTL ptlSrcMask; LPVOID pBBData; } BITBLTPARAMS, FAR *PBITBLTPARAMS;
//
// DEVICEHALFTONEINFO
//
// This data structure is passed for every HT_xxx api calls except the
// HT_CreateDeviceHalftoneInfo() which return the pointer to this data
// structure. It is used to identify the device color characteristics
// durning the halftone process.
//
// DeviceOwnData - this field will initially set to NULL, and will be
// used by the caller to stored useful information
// such as handle/pointer.
//
// cxPattern - width of the halftone pattern in pels
//
// cyPattern - height of the halftone pattern in pels.
//
// HTColorAdjustment - Current default color adjustment, if an halftone
// APIs required a PHTCOLORADJUSTMENT parameter and its
// passed as NULL pointer then default color adjustment
// is taken from here, the caller can change the
// HTCOLORADJUSTMENT data structure to affect all the
// color adjustment on this device.
//
typedef struct _DEVICEHALFTONEINFO { ULONG_PTR DeviceOwnData; WORD cxPattern; WORD cyPattern; HTCOLORADJUSTMENT HTColorAdjustment; } DEVICEHALFTONEINFO;
typedef DEVICEHALFTONEINFO FAR *PDEVICEHALFTONEINFO;typedef PDEVICEHALFTONEINFO FAR *PPDEVICEHALFTONEINFO;
//
// CHBINFO
//
// This data structure is one of the parameter passed to the halftone entry
// point HT_CreateHalftoneBrush();
//
// Flags - one or more following flags can be defined
//
// CHBF_BW_ONLY
//
// Create only black/white even the device is
// color.
//
// CHBF_USE_ADDITIVE_PRIMS
//
//
// Specified if the halftone result will be
// using Red/Green/Blue primary color or using
// Cyan/Magenta/Yellow primary color, depends
// on the destination surface format as
//
// BMF_1BPP:
//
// Additive Prims: 0=Black, 1=White
// Substractive Prims: 0=White, 1=Black
//
// BMF_4BPP_VGA16:
// BMF_8BPP_VGA256:
// BMF_16BPP_555:
// BMF_24BPP:
//
// Always using RED, GREEN, BLUE primaries
// and this flag is ignored.
//
// BMF_4BPP:
//
// Additive Prims: RED, GREEN. BLUE
// Substractive Prims: CYAN, MAGENTA, YELLOW
//
// The order of the RGB, or CMY is specified
// by DestPrimaryOrder field. (see below)
//
// CHBF_NEGATIVE_BRUSH
//
// Create the negative version of the brush.
//
//
// DestSurfaceFormat - One of the following can be specified,
//
// BMF_1BPP, BMF_4BPP, BMF_4BPP_VGA16,
// BMF_8BPP_VGA256, BMF_16BPP_555.
//
// for VGA16, VGA256, 16BPP_555 surface format
// see HTSURFACEINFO for descriptions.
//
// DestScanLineAlignBytes - Alignment bytes needed for each output pattern
// scan line, some common ones are
//
// BMF_ALIGN_BYTE ( 8-bit aligned)
// BMF_ALIGN_WORD (16-bit aligned)
// BMF_ALIGN_DWORD (32-bit aligned)
// BMF_ALIGN_QWORD (64-bit aligned)
//
// DestPrimaryOrder - Specified destination primary color order, it can
// be either PRIMARY_ORDER_RGB or PRIMARY_ORDER_CMY
// group, it depends on the surface format has
// following meaning.
//
// BMF_1BPP:
//
// This field is ignored.
//
//
// BMF_4BPP_VGA16:
//
// This field automatically set to
// PRIMARY_ORDER_BGR by the halftone DLL.
//
// BMF_4BPP:
//
// for each byte there are two indices
// entries, and for each nibble has following
// meaning, notice that bit 3/7 always set to
// 0, the index number only range from 0 to 7.
//
// PRIMARY_ORDER_abc
// |||
// ||+-- bit 0/4
// ||
// |+--- bit 1/5
// |
// +---- bit 2/7
//
//
// BMF_8BPP_VGA256:
//
// This field is ignored, the palette entries
// and its order is defined by halftone DLL
// at run time, the caller should get the
// palette for the VGA256 surface through
// HT_Get8BPPFormatPalette() API call.
//
// BMF_16BPP_555:
//
// PRIMARY_ORDER_abc
// |||
// ||+-- bit 0-4 (5 bits)
// ||
// |+--- bit 5-9 (5 bits)
// |
// +---- bit 10-15 (5 bits)
//
//
//
#define CHBF_BW_ONLY 0x01
#define CHBF_USE_ADDITIVE_PRIMS 0x02
#define CHBF_NEGATIVE_BRUSH 0x04
#define CHBF_BOTTOMUP_BRUSH 0x08
#define CHBF_ICM_ON 0x10
typedef struct _CHBINFO { BYTE Flags; BYTE DestSurfaceFormat; BYTE DestScanLineAlignBytes; BYTE DestPrimaryOrder; } CHBINFO;
//
// STDMONOPATTERN
//
// This data structure is used when calling the HT_CreateStdMonoPattern().
//
// Flags - One or more following flags may be defined
//
// SMP_TOPDOWN
//
// Specified that first scan line of the pattern
// bitmap will be the viewing top, if this flag
// is not defined then the last scan line is the
// viewing top.
//
// SMP_0_IS_BLACK
//
// specified that the in the bitmap a bit value
// 0 = black and bit value 1=white, if this flag
// is not defined then bit value 0=white and
// bit value 1=black.
//
// ScanLineAlignBytes - Alignment bytes needed for each output pattern scan
// line, some common ones are
//
// BMF_ALIGN_BYTE ( 8-bit aligned)
// BMF_ALIGN_WORD (16-bit aligned)
// BMF_ALIGN_DWORD (32-bit aligned)
// BMF_ALIGN_QWORD (64-bit aligned)
//
// PatternIndex - Specified the pattern index number, this has the
// predefined value as HT_STDMONOPAT_xxxx. If a invalid
// index number is passed then it return an error
// HTERR_INVALID_STDMONOPAT_INDEX is returned.
//
// LineWidth - This field only applied to the pattern which has
// lines in them, the value range from 0-255 (byte) and
// it repesent as LineWidth/1000 of inch, for example
// a 3 indicate 3/1000 = 0.003 inch width, if this value
// is less than the device minimum pel size, it will
// default to the 1 pel, the maximum is 255/1000 = 0.255
// inch width.
//
// If a zero is specified then it halftone will using
// default line width settting.
//
// LinesPerInch - This field only applied to the pattern wich has lines
// in them, the value range from 0 to 255 (byte). The
// LinesPerInch is calculated in the perpendicular
// direction of two parallel lines, the distances
// between two parallel lines that is.
//
// If a zero is specified then it halftone will using
// default line per inch setting.
//
// BytesPerScanLine - If will be filled by halftone dll to specified the
// size in bytes for each scan line in the pattern.
//
// cxPels - It will be filled by halftone dll of the final
// pattern's width in pel.
//
// cyPels - It will be filled by halftone dll of the final
// pattern's height in scan line.
//
// pPattern - Specified the memory location where the pattern will
// be stored, if this field is NULL then it will fill in
// the width/height fields.
//
//
#define HT_SMP_HORZ_LINE 0
#define HT_SMP_VERT_LINE 1
#define HT_SMP_HORZ_VERT_CROSS 2
#define HT_SMP_DIAG_15_LINE_UP 3
#define HT_SMP_DIAG_15_LINE_DOWN 4
#define HT_SMP_DIAG_15_CROSS 5
#define HT_SMP_DIAG_30_LINE_UP 6
#define HT_SMP_DIAG_30_LINE_DOWN 7
#define HT_SMP_DIAG_30_CROSS 8
#define HT_SMP_DIAG_45_LINE_UP 9
#define HT_SMP_DIAG_45_LINE_DOWN 10
#define HT_SMP_DIAG_45_CROSS 11
#define HT_SMP_DIAG_60_LINE_UP 12
#define HT_SMP_DIAG_60_LINE_DOWN 13
#define HT_SMP_DIAG_60_CROSS 14
#define HT_SMP_DIAG_75_LINE_UP 15
#define HT_SMP_DIAG_75_LINE_DOWN 16
#define HT_SMP_DIAG_75_CROSS 17
#define HT_SMP_PERCENT_SCREEN_START (HT_SMP_DIAG_75_CROSS + 1)
#define HT_SMP_PERCENT_SCREEN(x) (x + HT_SMP_PERCENT_SCREEN_START)
#define HT_SMP_MAX_INDEX HT_SMP_PERCENT_SCREEN(100)
#define SMP_TOPDOWN W_BITPOS(0)
#define SMP_0_IS_BLACK W_BITPOS(1)
typedef struct _STDMONOPATTERN { WORD Flags; BYTE ScanLineAlignBytes; BYTE PatternIndex; BYTE LineWidth; BYTE LinesPerInch; WORD BytesPerScanLine; WORD cxPels; WORD cyPels; LPBYTE pPattern; } STDMONOPATTERN;
typedef STDMONOPATTERN FAR *PSTDMONOPATTERN;
//
// Following is used in ConvertColorTable
//
#define CCTF_BW_ONLY 0x0001
#define CCTF_NEGATIVE 0x0002
#define CCTF_ICM_ON 0x0004
//////////////////////////////////////////////////////////////////////////////
// //
// //
// Exposed Halftone DLL APIs //
// //
// //
//////////////////////////////////////////////////////////////////////////////
#ifndef _HTAPI_ENTRY_
LONGAPIENTRYHT_CreateDeviceHalftoneInfo( PHTINITINFO pHTInitInfo, PPDEVICEHALFTONEINFO ppDeviceHalftoneInfo );
BOOLAPIENTRYHT_DestroyDeviceHalftoneInfo( PDEVICEHALFTONEINFO pDeviceHalftoneInfo );
LONGAPIENTRYHT_CreateHalftoneBrush( PDEVICEHALFTONEINFO pDeviceHalftoneInfo, PHTCOLORADJUSTMENT pHTColorAdjustment, PCOLORTRIAD pColorTriad, CHBINFO CHBInfo, LPVOID pOutputBuffer );
#ifndef _WINDDI_
LONGAPIENTRYHT_ComputeRGBGammaTable( WORD GammaTableEntries, WORD GammaTableType, UDECI4 RedGamma, UDECI4 GreenGamma, UDECI4 BlueGamma, LPBYTE pGammaTable );
LONGAPIENTRYHT_Get8BPPFormatPalette( LPPALETTEENTRY pPaletteEntry, UDECI4 RedGamma, UDECI4 GreenGamma, UDECI4 BlueGamma );
LONGAPIENTRYHT_Get8BPPMaskPalette( LPPALETTEENTRY pPaletteEntry, BOOL Use8BPPMaskPal, BYTE CMYMask, UDECI4 RedGamma, UDECI4 GreenGamma, UDECI4 BlueGamma );
#endif
LONGAPIENTRYHT_CreateStandardMonoPattern( PDEVICEHALFTONEINFO pDeviceHalftoneInfo, PSTDMONOPATTERN pStdMonoPattern );
LONGAPIENTRYHT_HalftoneBitmap( PDEVICEHALFTONEINFO pDeviceHalftoneInfo, PHTCOLORADJUSTMENT pHTColorAdjustment, PHTSURFACEINFO pSourceHTSurfaceInfo, PHTSURFACEINFO pSourceMaskHTSurfaceInfo, PHTSURFACEINFO pDestinationHTSurfaceInfo, PBITBLTPARAMS pBitbltParams );
#endif // _HTAPI_ENTRY_
#endif // _HT_
|
