Victor Image Processing Library version 5

Summary of What's New in Version 5
Over 60 new functions have been introduced and many existing functions have been extended so that the Victor Library has many new features that will enhance your applications' ability to load, save, and process images. These new features include

File handling
Memory buffers can now be used to load and save images in the formats: BMP, GIF, JPEG, PNG, and TIFF
All formats now automatically identify grayscale images when loading
BMP — load 16- and 32-bit color images
GIF — load and save without using patented LZW compression
JPEG — load and save progressive and optimized JPEGs
PNG — load and save this new file format
TIFF — load and save 16-bit grayscale
TIFF — load multipage images by page number or by index

Image Allocation
Allocate space for 16-bit grayscale images

Image conversion
Convert images between 8- and 16-bit grayscale
Convert a DIB section to an image
Convert a device dependent bitmap to an image
Intelligent conversion of palette color image to a 1-bit image

Image Processing
Resize with interpolation (resample)
Transparent overlay
Dilation — darken an image by enlarging dark regions
Erosion — brighten an image by enlarging light regions
User-defined matrix convolution kernel of up to 63 x 63
Median filter up to 11 x 11

Scanning
TWAIN device support -- This module is now a part of the Victor Library package. Add image acquisition from any TWAIN-compliant device to your application. Use the built-in interface or design your own user interface, scan single or multipage documents.

Screen capture
Capture a window to an image
Capture a window client area to an image

• a modified form of the Victor Library that is a DLL and dynamically links to the MicroSoft C run time library DLL. This is the smallest Victor Library and it makes use of a DLL already present in Windows. Option D.
• a modified form of the Victor Library that is a static linkable library for including Victor functions in your own C/C++ executable program file. The advantage of using this form of the library is that there is no need to distribute a Victor DLL with your app and only those functions that you actually use will be included in your program. Option S.

Victor Library New Functions in Version 5
bmpinfofrombuffer	--	Get image information from memory buffer in BMP format
clienttoimage	--	Capture a screen window client area
convertgray8to16	--	Convert 8-bit grayscale to 16-bit
convertgray16to8	--	Convert 16-bit grayscale to 8-bit
coverclear	--	Overlay an image onto another with a transparent color
ddbtoimage	--	Convert device dependent bitmap to an image
dibsecttoimage	--	Convert DIB section to an image
dilate	--	Darken an image by enlarging the dark regions
erode	--	Brighten an image by enlarging the light regions
getpngcomment	--	Get comment from PNG file
gifinfofrombuffer	--	Get image information from memory buffer in GIF format
isgrayscaleimage	--	Determine if an image is grayscale
jpeggeterror	--	Get last JPEG error
loadbmpfrombuffer	--	Load image from memory buffer in BMP format
loadbmppalettefrombuffer	--	Load palette from memory buffer in BMP format
loadgiffrombuffer	--	Load image from memory buffer in GIF format
loadgifpalettefrombuffer	--	Load palette from memory buffer in GIF format
loadpng	--	Load image from PNG file
loadpngfrombuffer	--	Load image from memory buffer in PNG format
loadpngpalette	--	Load palette from PNG file
loadpngpalettefrombuffer	--	Load palette from memory buffer in PNG format
loadtiffrombuffer	--	Load image from memory buffer in TIFF format
loadtifpagebyindex	--	Load nth image from TIFF file
loadtifpalettefrombuffer	--	Load palette from memory buffer in TIFF format
loadtifpalettepagebyindex	--	Load palette of nth image from TIFF file
matrixconvex	--	Matrix convolution with kernel size up to 63 x 63
medianfilter	--	Median filter with filter size up to 11 x 11
pnggeterror	--	Get last PNG error
pnginfo	--	Get info about image in PNG file
pnginfofrombuffer	--	Get image information from memory buffer in PNG format
resizeex	--	Resize image with interpolation
savebmptobuffer	--	Save image to memory buffer in BMP format
savegifex	--	Save image in royalty-free uncompressed GIF format
savegiftobufferex	--	Save image to memory buffer in GIF format
savejpgex	--	Save progressive JPEG to file
savejpgtobufferex	--	Save progressive JPEG to memory
savepng	--	Save image to PNG file
savepngtobuffer	--	Save image to memory buffer in PNG format
savetiftobuffer	--	Save image to memory buffer in TIFF format
tiffgeterror	--	Get last TIFF error
tiffinfofrombuffer	--	Get image information from memory buffer in TIFF format
tiffinfopagebyindex	--	Get TIFF information about a single page in a multipage TIFF file
Victorversionex	--	Get Victor extended version information
windowtoimage	--	Capture a screen window to an image
TWdetecttwain	--	detect TWAIN source manager
TWgetbrightness	--	get scanner brightness range
TWgetcontrast	--	get scanner contrast range
TWgeterror	--	get extended error information
TWgetsourcenames	--	get names of available data sources
TWgetmeasureunit	--	get valid measurement unit types
TWgetpixeltype	--	get valid pixel types
TWgetxresolution	--	get scanner resolution range
TWgetyresolution	--	get scanner resolution range
TWscanimage	--	acquire image from default data source
TWscanimageex	--	acquire image from default data source without displaying Acquire dialog box
TWscanmultipleimages	--	acquire multiple images from default data source
TWscanmultipleimagesex	--	acquire multiple images from default data source without displaying Acquire dialog box
TWselectsource	--	select a new default data source
TWselectsourcebyname	--	select a data source by name
TWsetbrightness	--	set scanner brightness
TWsetcontrast	--	set scanner contrast
TWsetmeasureunit	--	set measurement unit type
TWsetpixeltype	--	restrict pixel type
TWsetproductname	--	inform data source of application name
TWsetxresolution	--	set scanner resolution
TWsetyresolution	--	set scanner resolution
TWvicversion	--	return Victor Library TWAIN support module version number

Victor Library New Features added to Existing Functions
allocimage	--	Allocate 16-bit grayscale buffer
allocDIB	--	Allocate 16-bit grayscale buffer
convert8bitto1bit	--	Converts grayscale version of palette color image to 1-bit image
loadbmp	--	Load a 16- or 32-bit RGB image into a 24-bit buffer
loadgif	--	Load uncompressed GIF
loadjpg	--	Load progressive JPEG
loadtif	--	Load a 16-bit grayscale image into 16-bit buffer
	--	Load 1-bit LZW compressed
loadtifpage	--	Load a 16-bit grayscale image into 16-bit buffer
	--	Load 1-bit LZW compressed
printimage	--	Prints grayscale version of palette color image when halftone or scatter are selected
printimagenoeject	--	Prints grayscale version of palette color image when halftone or scatter are selected
rotate	--	Rotate a 1-bit image any angle
rotate90	--	Rotate a 1-bit image 90 degrees
savegif	--	Save uncompressed GIF
savegifex	--	Save uncompressed GIF
savetif	--	Save 16-bit grayscale image to file
	--	Save 1-bit LZW compressed
savetifpage	--	Save 16-bit grayscale image to file
	--	Return TIFF_MOTYPE if trying to append an Intel byte order image to a Motorola byte order file
	--	Sets NewSubFileType value = 2, OldSubFileType value = 3
tiffgetpageinfo	--	Assign page numbers if file has no page number information
tiffinfo	--	Vbitcount is set to 16 for 16-bit grayscale image
tiffinfopage	--	Vbitcount is set to 16 for 16-bit grayscale image
loadbmppalettefrombuffer

Summary

int bmpinfofrombuffer(buff, bminfo);
unsigned char huge *buff;       Buffer address
BITMAPINFOHEADER far *bminfo;   Structure to receive data

The BITMAPINFOHEADER structure is defined in the WINDOWS SDK and is reproduced below.

typedef struct tagBITMAPINFOHEADER {
   DWORD biSize;          // Size of this struct
   DWORD biWidth;         // Image width in pixels
   DWORD biHeight;        // Image height in pixels
   WORD  biPlanes;        // Planes = 1
   WORD  biBitCount;      // Color bits per pixel 1, 4, 8, 24
   DWORD biCompression;   // Compression type
   DWORD biSizeImage;     // Image size in bytes
   DWORD biXPelsPerMeter, biYPelsPerMeter; // Horiz, vert res
   DWORD biClrUsed;       // Number of colors used
   DWORD biClrImportant;  // Number of important colors
   } BITMAPINFOHEADER;

The BMP file data contains a BITMAPFILEHEADER followed by a device independent bitmap (DIB) consisting of a BITMAPINFO structure and an array of bytes defining the pixels of the bitmap.

Return value    Explanation
NO_ERROR    Function successful
BAD_OPN    Memory handle not available
BAD_BMP    File is not a readable BMP format
BAD_PTR    Buff points at unreadable memory

See also bmpinfo

Example See loadbmpfrombuffer

Summary

int clienttoimage(hwnd, resimg);
HWND hwnd;              Window handle
imgdes far *resimg;     Result image

The result image will have the same bits per pixel as the current display mode. If the function is successful the image descriptor resimg is filled in. Clienttoimage allocates memory to hold the image, so freeimage must be called when this memory is no longer needed.

Return value    Explanation
NO_ERROR    Function successful
BAD_MEM    Insufficient memory
BAD_BPP    Bits per pixel not 1, 4, 8, 16, or 24

See also
windowtoimage

Example

int CaptureScreenClient(HWND hWnd)
{
   int rcode;
   imgdes timage;
   char *fname = "client.tif";

   // Capture window as Victor image
   rcode = clienttoimage(hWnd, &timage);
   if(rcode == NO_ERROR) {
      // Save captured client area
      rcode = savetif(fname, &timage, 0);
      // Release memory allocated by clienttoimage()
      freeimage(&timage);
      }
   return(rcode)
}

This example captures a window's client area and saves it as a TIFF file.

Summary

int convertgray8to16(srcimg, resimg);
imgdes far *srcimg;     Source image 
imgdes far *resimg;     Result image 

Description
The convert8to16 function converts a grayscale 8-bit per pixel source image area into a grayscale 16-bit per pixel result image area. The source and result image areas are defined by the corresponding image descriptors. A 16-bit grayscale image can be saved with savetif.

Return value    Explanation
NO_ERROR    Function successful
BAD_RANGE    Range error, see Appendix A
BAD_IBUF    Invalid image buffer address
BAD_MEM    Insufficient memory
BAD_BPP    Source is not 8-bit or result is not 16-bit
BAD_DIB    Source or result is a compressed DIB

Example
See convertgray16to8

Summary

int convertgray16to8(srcimg, resimg);
imgdes far *srcimg;      Source image 
imgdes far *resimg;      Result image 

Description
The convert16to8 function converts a grayscale 16-bit per pixel source image area into a grayscale 8-bit per pixel result image area. The source and result image areas are defined by the corresponding image descriptors.

Return value    Explanation
NO_ERROR    Function successful
BAD_RANGE    Range error, see Appendix A
BAD_IBUF    Invalid image buffer address
BAD_MEM    Insufficient memory
BAD_BPP    Source is not 16-bit or result is not 8-bit
BAD_DIB    Source or result is a compressed DIB

Example

int process16bitGrayTIFF(char *fname)
{
   int rcode;
   TiffData tdat;
   imgdes timage;

   rcode = tiffinfo(fname, &tdat); // Fill structure
   if(rcode == NO_ERROR && 
      // Make sure image to load is 16-bit grayscale
      tdat.BitsPSample == 16 && tdat->SamplesPPixel == 1)
      // Allocate memory for image storage
      rcode = allocimage(&timage, tdat.width, tdat.length, tdat.vbitcount);
      if(rcode == NO_ERROR)
         // Read in a 16-bit grayscale TIFF file
         rcode = loadtif(fname, &timage);
         if(rcode == NO_ERROR) {
            imgdes nimage;
            allocimage(&nimage, tdat.width, tdat.length, 8);
            // Convert image to 8-bit
            rcode = convertgray16to8(&timage, &nimage);
            if(rcode == NO_ERROR) {
               // Process image
               histoequalize(&nimage, &nimage);
               // Convert image back to 16-bits
               convertgray8to16(&nimage, &timage);
               // Save processed 16-bit image
               rcode = savetif(fname, &timage, 0);
               freeimage(&nimage); // Release memory allocated for 8-bit image
               }
            }
         // Release memory allocated for 16-bit image
         freeimage(&timage);
         }
      }
   return(rcode)
}

This function loads a 16-bit grayscale image, converts it to 8-bits, performs image processing on it, converts it back to a 16-bit image, and saves it.

Summary

int coverclear(transcolor, srcimg, oprimg, resimg);
const long transColor;   Transparent color(0-0xffffff)
imgdes far *srcimg;      Source image 
imgdes far *oprimg;      Operator image 
imgdes far *resimg;      Result image 

Description
The coverclear function places the operator image onto the source image. In regions of the operator where pixel values are equal to transcolor the source image will show through. The image areas are defined by the corresponding image descriptors.

Return value    Explanation
NO_ERROR    Function successful
BAD_RANGE    Range error, see Appendix A
BAD_IBUF    Invalid image buffer address
BAD_MEM    Insufficient memory
BAD_BPP    Images are not both 8- or 24-bit
BAD_DIB    Source or result is a compressed DIB
BAD_FAC    Transcolor is outside the range 0 (black) to 0xffffff (white)

See also
cover

Example

int addShadowWithCoverClear(imgdes *srcimg, imgdes *desimg)
{
   imgdes tmpsrc;
   // Drop shadow at horiz offset 10, vert offset 5
   int hoffset = 10, voffset = 5;
   int rcode, cols, rows;
   long transcolor = 0xffffff; // White

   cols = CALC_WIDTH(srcimg); // Macros in VICDEFS.H
   rows = CALC_HEIGHT(srcimg);

   // Create the shadow in a temp buffer
   rcode = allocimage(&tmpsrc, cols, rows, srcimg->bmh->biBitCount);
   if(rcode == NO_ERROR) {
      zeroimage(255, &tmpsrc); // Set all pixels to white
      tmpsrc.stx = hoffset;
      tmpsrc.sty = voffset;
      copyimage(srcimg, &tmpsrc); // Copy src image to offset pos

      tmpsrc.stx = 0;
      tmpsrc.sty = 0;
      kodalith(255, &tmpsrc, &tmpsrc); // Turn all pixels not white to black
      changebright(64, &tmpsrc, &tmpsrc); // Black -> dark gray
      for(j=0; j<25; j++) // Simulate gaussian blur
         blur(&tmpsrc, &tmpsrc);
      // Cover the shadow with the original image
      rcode = coverclear(transcolor, &tmpsrc, srcimg, desimg);
      freeimage(&tmpsrc); // Delete temp image
      }
   return(rcode);
}

This example creates a drop shadow of all non-white pixels in the image.

Summary

int ddbtoimage(hbitmap, hpal, resimg);
HBITMAP hbitmap;         Device dependent bitmap handle
HPALETTE hPal;           Palette handle or NULL
imgdes far *resimg;      Result image

Description
The ddbtoimage function creates a Victor-compatible image from a device dependent bitmap and palette. If hPal is NULL the Windows default palette will be used. If the function is successful the image descriptor resimg is filled in.

Ddbtoimage allocates memory to hold the image, so freeimage must be called when this memory is no longer needed.

Return value    Explanation
NO_ERROR    Function successful
BAD_MEM    Insufficient memory
BAD_HANDLE    Invalid bitmap handle

See also
dibtoimage

Example

int SaveBitmapToTiffFile(HBITMAP hBitmap, HPALETTE hPal)
{
   int rcode;
   imgdes timage;
   char *fname = "bitmap.tif";
   
   rcode = ddbtoimage(hBitmap, hPal, &timage);
   if(rcode == NO_ERROR) {
      // Save captured image
      rcode = savetif(fname, &timage, 0);
      freeimage(&timage);
      }
   return(rcode);
}

This example saves a device dependent bitmap as a TIFF file.

Summary

int dibsecttoimage(hBitmap, image);
HBITMAP hBitmap;         DIB section handle
imgdes far *image;       Image 

Description
The dibsecttoimage function creates a Victor-compatible image from a DIB-section (WIN32 device independent bitmap). This function is useful when a DIB is imported from another source to allow Victor functions to operate on it.

Although Windows allows the palette data of a DIB to be indexes into the currently realized logical palette, dibsecttoimage assumes explicit RGB values. If the function is successful the image descriptor resimg is filled in.

Dibsecttoimage allocates memory to hold the image, so freeimage must be called when this memory is no longer needed. Dibsecttoimage is available only in the Victor Library for 32-bit Windows, excluding Windows NT versions earlier than 3.51.

Return value    Explanation
NO_ERROR    Function successful
BAD_MEM    Insufficient memory
BAD_HANDLE    HBitmap is not a DIB section bitmap handle
BAD_DIB    DIB is compressed
BAD_BPP    Bits per pixel is not 1, 8, or 24

See also
dibtoimage

Example

int SaveDIBSectToTiffFile(HBITMAP hBitmap)
{
   int rcode;
   imgdes timage;
   char *fname = "bitmap.tif";
   
   rcode = dibsecttoimage(hBitmap, &timage);
   if(rcode == NO_ERROR) {
      // Save captured image
      rcode = savetif(fname, &timage, 0);
      freeimage(&timage);
      }
   return(rcode);
}

This example saves a DIB section as a TIFF file.

Summary

int dilate(amount, srcimg, resimg);
const int amount;        Amount of dilation (0 - 255)
imgdes far *srcimg;      Source image 
imgdes far *resimg;      Result image 

Description
The dilate function darkens an image area by enlarging the dark regions of the image. The variable amount determines the extent of the darkening. Maximum dilation is obtained when amount set to 255 and no dilation occurs if amount is set to zero. If the average brightness of a pixel's 3 x 3 local area is darker than amount, the pixel is replaced by its darkest neighbor.

If 3 x 3 local area average brightness < amount
    then Result = darkest pixel in 3 x 3 area

Return value    Explanation
NO_ERROR    Function successful
BAD_RANGE    Range error (see Appendix A) or image area is less than 3 x 3 pixels
BAD_IBUF    Invalid image buffer address
BAD_MEM    Insufficient memory
BAD_BPP    Images are not both 8- or 24-bit
BAD_DIB    Source or result is a compressed DIB
BAD_FAC    Amount is outside range of 0 - 255

Example

int darkenByDilation(HWND hWnd, imgdes *image)
{
   int rcode, amount = 200;

   rcode = dilate(amount, image, image);
   if(rcode != NO_ERROR)
      MessageBox(hWnd, "Error in darken by dilation", 0, MB_OK);
   return(rcode); 
}

This example darkens an image using dilation.

Summary

int erode(amount, srcimg, resimg);
const int amount;        Amount of erosion (0 - 255)
imgdes far *srcimg;      Source image 
imgdes far *resimg;      Result image 

Description
The erode function brightens an image area by enlarging the bright regions of the image. The variable amount determines the extent of the brightening. Maximum erosion is obtained with amount set to 255 and no erosion occurs if amount is set to zero.

Erode examines a pixel's 3 x 3 local area. If the average brightness of the local area is brighter than 255 minus amount, the central pixel is replaced by its brightest neighbor.

If 3 x 3 local area average brightness > (255 - amount)
    then Result = brightest pixel in 3 x 3 area

Return value    Explanation
NO_ERROR    Function successful
BAD_RANGE    Range error (see Appendix A) or image area is less than 3 x 3 pixels
BAD_IBUF    Invalid image buffer address
BAD_MEM    Insufficient memory
BAD_BPP    Images are not both 8- or 24-bit
BAD_DIB    Source or result is a compressed DIB
BAD_FAC    Amount is outside range of 0 - 255

Example

int brightenByErosion(HWND hWnd, imgdes *image)
{
   int rcode, amount = 200;

   rcode = erode(amount, image, image);
   if(rcode != NO_ERROR)
      MessageBox(hWnd, "Error in brighten by erosion", 0, MB_OK);
   return(rcode); 
}

This example brightens an image using erosion.

Summary

int getpngcomment(filename, type, buffer, buffermax);
const char far *filename;  Filename to read
char far *type;            Comment type
char far *buffer;          Buffer to receive comment
int buffermax;             Maximum number of characters buffer will hold,
                           including null terminator

Description
The getpngcomment function copies a comment string (if present) from a PNG file to a buffer. If the number of characters in the comment exceeds buffermax, the string is truncated to fit into buffer. To determine the size of the buffer to allocate to hold the string, call getpngcomment with buffer equal 0 (see example).

Only uncompressed comments can be retrieved with getpngcomment. The defined comment type values are "Title", "Author", "Description", "Copyright", "Creation Time", "Software", "Disclaimer", "Warning", "Source", and "Comment."

Return value    Explanation
0 to 32768    Actual number of characters copied into buffer
BAD_OPN    Filename not found
BAD_PNG    File is not a valid PNG file

Example

void readAPNGComment(HWND hWnd, char *fname)
{
   int rcode, comlen;
   char buff[80], near *combuff;

   // Get comment length  
   rcode = getpngcomment(fname, "Comment", 0, 0);
   switch(rcode) {
      case(BAD_OPN):
         wsprintf(buff, "Cannot open %s", (LPSTR)fname); break;
      case(BAD_PNG):
         wsprintf(buff, "Bad PNG: %s", (LPSTR)fname); break;
      case(0):
         wsprintf(buff, "No comment in %s", (LPSTR)fname); break;
      default:  // Getpngcomment() returned length of comment
         comlen = rcode;   // Save length of comment
         // Allocate space for comment string
         combuff = (char near *)calloc(comlen + 1, sizeof(char));
         if(combuff == NULL) {
            wsprintf(buff, "Insufficient memory");
            rcode = BAD_MEM;
            }
         else {    // Get the comment
            getgifcomment(fname, combuff, comlen + 1);
            // Display comment in message box
            MessageBox(hWnd, combuff, 0, MB_OK);
            free(combuff);
            }
      }
   if(rcode <= 0) // If error, display error message
      MessageBox(hWnd, buff, 0, MB_OK);
}

This example reads and displays a comment string in a PNG file.

Summary

int gifinfofrombuffer(buff, ginfo);
unsigned char huge *buff;       Buffer address
typedef struct {                Structure to contain GIF file data
   int width, length;           Image width and length in pixels
   int BitsColRes;              Number of bits of color resolution
   int BitsPPixel;              Number of bits per pixel
   int TransColor;              Transparent color
   int Laceflag;                Interlace flag
   int Codesize;                LZW code size
   int GIFvers;                 GIF version, 87 or 89
   int vbitcount;               Victor bits per pixel (used to allocate an
                                image buffer with allocimage)
   } GifData far *ginfo;        Pointer to structure

Description

The gifinfofrombuffer function reads the header information from memory holding GIF file data and places the image information in the ginfo structure. The purpose of the gifinfofrombuffer function is to identify the type and size of the image and permit allocating enough memory to load the file.

If a GIF file contains a transparent color, gifinfo will return it in the structure element TransColor. If a transparent color is not present, TransColor is set to -1.

Return value    Explanation
NO_ERROR    Function successful
BAD_OPN    Memory handle not available
BAD_GIF    File is not a valid GIF file
BAD_PTR    Buff does not point to readable memory

See also
gifinfo

Example
See loadgiffrombuffer

Summary

BOOL isgrayscaleimage(image);
imgdes far *image;          Image 

Description
The isgrayscaleimage function examines the image's palette information and reports whether it is grayscale. This function does not alter the value of the image descriptor element imgtype.

To be judged grayscale an image must have a palette with these characteristics:

• The red, green, and blue values of each palette entry must be equal
• The interval between adjacent palette entries must be positive and constant.

This function returns FALSE if the image does not have a palette, for example for a 16-bit grayscale or a 24-bit RGB image.

The file load functions call isgrayscaleimage internally and correctly set the value of the image descriptor element imgtype.

Return value    Explanation
TRUE    Image is grayscale
FALSE    Image is not grayscale

Summary

int jpeggeterror(void);

Description
The jpeggeterror function reports extended error information after a JPEG function returns BAD_JPEG.

Return value    Explanation
0    No extended error information
-100    Sample precision is not 8
-101    Unexpected End Of File
-102    Reset marker could not be found
-103    Invalid marker found in the image data
-104    Error reading data from the file
-105    Invalid data found in JPEG file
-106    Component info out of bounds
-107    Blocks in an MCU is greater than 10
-108    Bits per sample is not 8
-109    Invalid number of components
-110    File type not SOF0, SOF1, or SOF2
-111    Unexpected End Of Image
-112    File is not JPEG JFIF
-113    Bad progressive JPEG scan parameter

Example

int loadAJpegFile(HWND hWnd, char *fname, imgdes *image)
{
   JpegData jdat;
   int rcode;

   // Get info on the file we're to load
   rcode = jpeginfo(fname, &jdat);
   if(rcode == NO_ERROR) { // Fill structure
      // Allocate space for an image
      rcode = allocimage(image, (int)jdat.width, (int)jdat.length, jdat.vbitcount);
      if(rcode == NO_ERROR) {
         // Load image
         rcode = loadjpg(fname, image);
         if(rcode == BAD_JPEG) {
            char szBuff[128];
            // Get extended error info
            int extRcode = jpeggeterror();
            wsprintf(szBuff, "Error in loading %s: extended error code %d", (LPSTR)fname, extRcode);
            MessageBox(hWnd, szBuff, 0, MB_OK);
            }
         freeimage(image); // Free image on error
         }
      }
   return(rcode);
}

This function reports extended error information when a JPEG file cannot be loaded.

Summary

int loadbmpfrombuffer(buff, image); 
unsigned char huge *buff;   Buffer address
imgdes far *image;          Image 

The BMP file header includes the image dimensions. If these dimensions do not match the dimensions of the area defined by the image descriptor, the smaller of the two will be used to load the file. Loadbmpfrombuffer will enter into the image descriptor member colors the number of palette colors loaded.

Loadbmpfrombuffer loads 1-, 4-, 8-, 16-, 24-, or 32-bit BMP files. When 4-bit BMP files are loaded, they are expanded into 8-bit image buffers and when 16- or 32-bit BMP files are loaded they are stored in 24-bit image buffers.

BMP file data contains a BITMAPFILEHEADER followed by a device independent bitmap (DIB) consisting of a BITMAPINFO structure, which describes the dimensions and colors of the bitmap, and an array of bytes defining the pixels of the bitmap. The bits in the array are packed together, but each scan line must be zero-padded to end on a LONG boundary. The origin of the bitmap is the lower-left corner.

DIBs are discussed in the Victor User's Guide. The BMP file format data structures are discussed in Microsoft Windows SDK Programmer's Reference.

Return value   Explanation
NO_ERROR   Function successful
BAD_RANGE   Range error, see Appendix A
BAD_IBUF   Invalid image buffer address
BAD_MEM   Insufficient memory
BAD_BPP   Image is not 1-, 8-, or 24-bit or image and file are not compatible bits per pixel
BAD_DIB   Source or result is a compressed DIB
BAD_OPN   Memory handle not available
BAD_BMP   File is not a readable BMP format
BAD_CMP   Unreadable compression scheme
BAD_PTR   Buff points at unreadable memory

See also bmpinfo, savebmp

Summary

int loadbmppalettefrombuffer(buff, paltable);
unsigned char huge *buff;    Buffer address where BMP file data begins
RGBQUAD far *paltable;       Storage buffer for palette values

When loading a BMP file, it is not necessary to call this function, because loadbmpfrombuffer automatically loads any palette data available if the image descriptor member palette is nonzero.

Return value    Explanation
0 - 256   Number of palette colors read
BAD_MEM   Insufficient memory
BAD_OPN   Memory handle not available
BAD_BMP   File is not a readable BMP format
BAD_PTR   Buff points at unreadable memory

Summary

int loadgiffrombuffer(buff, image); 
unsigned char huge *buff;   Buffer address
imgdes far *image;          Image 

Description
The loadgiffrombuffer function loads image data from a memory buffer holding GIF file data into an area in an image buffer defined by the image descriptor. Palette data is loaded into the buffer defined by the image descriptor member palette.

Before making the first call to loadgif, unlockLZW should be called to enable reading LZW-compressed files. Otherwise loadgif will only read uncompressed GIF files.

The GIF file header includes the image dimensions. If these dimensions do not match the dimensions of the area defined by the image descriptor, the smaller of the two will be used to load the file.

Loadgiffrombuffer will enter into the image descriptor member colors the number of palette colors loaded. Loadgiffrombuffer loads 1- to 8-bit GIF images. 1-Bit GIF images are loaded into 1-bit image buffers and 2- to 8-bit GIF images are loaded into 8-bit image buffers.
The transparent color in a GIF file can be obtained using the gifinfofrombuffer function.

An attempt to load an image from LZW-compressed file data will return the error code LZW_DISABLED unless LZW functionality has been enabled with unlockLZW. The use of LZW compression requires an LZW license from Unisys Corporation. For information concerning licensing the LZW compression and/or decompression capability, please contact: Unisys Corporation, Welch Licensing Department - C1SW19, Township Line & Union Meeting Roads, P O Box 500, Blue Bell PA 19424, www.unisys.com.

Return value   Explanation
NO_ERROR   Function successful
BAD_RANGE   Range error, see Appendix A
BAD_IBUF   Invalid image buffer address
BAD_MEM   Insufficient memory
BAD_BPP   Image is not 1- or 8-bit
BAD_DIB   Source or result is a compressed DIB
BAD_OPN   Memory handle not available
BAD_GIF   File is not a readable GIF format
LZW_DISABLED   LZW functionality not available, see unlockLZW
BAD_PTR   Buff points at unreadable memory

See also gifinfofrombuffer, loadgifpalettefrombuffer, savegiftobufferex

int loadgifpalettefrombuffer(buff, paltable); 
unsigned char huge *buff;   Buffer address where GIF file data begins
RGBQUAD far *paltable;      Storage buffer for palette values

Description
The loadgifpalettefrombuffer function loads the palette data from a memory buffer holding GIF file data into paltable. Paltable must be an array of 256 RGBQUAD structures (1024 bytes). A GIF image may contain up to 256 colors.

When loading a GIF file, it is not necessary to call this function, because loadgiffrombuffer automatically loads any palette data available if the image descriptor member palette is nonzero.

Return value   Explanation
0 - 256   Number of palette colors read
BAD_MEM   Insufficient memory
BAD_OPN   Memory handle not available
BAD_GIF   File is not a readable GIF format
BAD_PTR   Buff points at unreadable memory

int loadpng(filename, image); 
const char far *filename;   Filename to load
imgdes far *image;          Image 

Description
The loadpng function loads image data from a PNG file into an area in an image buffer defined by the image descriptor. Palette data is loaded into the buffer defined by the image descriptor member palette.

The PNG file header includes the image dimensions. If these dimensions do not match the dimensions of the area defined by the image descriptor, the smaller of the two will be used to load the file.

Loadpng will enter into the image descriptor member colors the number of palette colors loaded. Loadpng loads all PNG images. 1-Bit PNG images are loaded into 1-bit image buffers and 2- to 8-bit PNG images are loaded into 8-bit image buffers. All grayscale PNG images are loaded into 8-bit buffers. All RGB images are loaded into 24-bit buffers. Alpha channel data is ignored. Supported pixel depth is 1- to 64-bit.

The transparent color(s) in a PNG file can be obtained using the pnginfo function. If a transparent color is present, pnginfo will return it in the structure element TransData. If a transparent color is not present, the isPresent element of TransData is set to FALSE.

The Victor loadpng function is based on the source code for the ZLIB compression library by Jean-loup Gailly and Mark Adler. PNG stands for Portable Network Graphics. This format is intended to be a patent-free replacement for GIF and uses the LZ77 compression rather than LZW.

Return value    Explanation
NO_ERROR    Function successful
BAD_RANGE    Range error, see Appendix A
BAD_IBUF    Invalid image buffer address
BAD_MEM    Insufficient memory
BAD_BPP    Image is not 1-, 8-, or 24-bit
BAD_DIB    Source or result is a compressed DIB
BAD_OPN    Filename not found
BAD_PNG    File is not a readable Png format

See also

pnginfo, loadpngpalette, savepng, pnggeterror

Example

int loadAPng(HWND hWnd, char *fname, imgdes *image)
{
   PngData pdat;
   int rcode;

   // Get info on the file we're to load
   rcode = pnginfo(fname, &pdat);
   if(rcode != NO_ERROR) { // Fill structure
      MessageBox(hWnd,"Error in reading file", 0, MB_OK);
      return(rcode);
      }
   // Allocate space for the image
   rcode = allocimage(image, pdat.width, pdat.length, pdat.vbitcount);
   if(rcode != NO_ERROR) {
      MessageBox(hWnd,"Not enough memory to load file", 0, MB_OK);
      return(rcode);
      }
   // Load image
   rcode = loadpng(fname, image);
   if(rcode != NO_ERROR) { 
      char szBuff[80];
      wsprintf(szBuff, "Could not load %s", fname);
      MessageBox(hWnd, szBuff, 0, MB_OK); 
      }
   freeimage(image); // Free image on error
   return(rcode);
} 

This example loads an image from a PNG file.

Summary

int loadpngfrombuffer(buff, image); 
unsigned char huge *buff;     Buffer address
imgdes far *image;            Image 

Description
The loadpngfrombuffer function loads PNG file data from a memory buffer into an area in an image buffer defined by the image descriptor. Palette data is loaded into the buffer defined by the image descriptor member palette.

The PNG file header includes the image dimensions. If these dimensions do not match the dimensions of the area defined by the image descriptor, the smaller of the two will be used to load the file.

Loadpngfrombuffer will enter into the image descriptor member colors the number of palette colors loaded. Loadpngfrombuffer loads all PNG images. 1-Bit PNG images are loaded into 1-bit image buffers and 2- to 8-bit PNG images are loaded into 8-bit image buffers. All grayscale PNG images are loaded into 8-bit buffers. All RGB images are loaded into 24-bit buffers. Alpha channel data is ignored. Supported pixel depth is 1- to 64-bit.

The Victor loadpngfrombuffer function is based on the source code for the ZLIB compression library by Jean-loup Gailly and Mark Adler. PNG stands for Portable Network Graphics. This format is intended to be a patent-free replacement for GIF. It uses the LZ77 compression rather than LZW.

Return value  Explanation
NO_ERROR  Function successful
BAD_RANGE   Range error, see Appendix A
BAD_IBUF  Invalid image buffer address
BAD_MEM   Insufficient memory
BAD_BPP   Image is not 1-, 8-, or 24-bit or image and file are not compatible bits per pixel
BAD_DIB   Source or result is a compressed DIB
BAD_OPN   Memory handle not available
BAD_PNG   File is not a readable PNG format
BAD_PTR   Buff points at unreadable memory

See also
pnginfofrombuffer, loadpngpalettefrombuffer, savepngtobuffer, pnggeterror

Summary

int loadpngpalettefrombuffer(buff, paltable); 
unsigned char huge *buff;     Buffer address where PNG data begins
RGBQUAD far *paltable;        Storage buffer for palette values

Description
The loadpngpalettefrombuffer function loads the palette data from a memory buffer holding PNG file data into paltable. Paltable must be an array of 256 RGBQUAD structures (1024 bytes). A PNG image may contain up to 256 colors.

When loading a PNG file, it is not necessary to call this function, because loadpngfrombuffer automatically loads any palette data available if the image descriptor member palette is nonzero.

Return value  Explanation
0 - 256  Number of palette colors read
BAD_MEM  Insufficient local memory
BAD_OPN  Memory handle not available
BAD_PNG  File is not a readable PNG format
BAD_PTR  Buff points at unreadable memory

Summary

int loadpngpalette(filename, paltable); 
char far *filename;      Filename of PNG file
RGBQUAD far *paltable;   Storage buffer for palette values

Description
The loadpngpalette function loads the palette data from a PNG image file into paltable.

Paltable must be an array of 256 RGBQUAD structures (1024 bytes) since a PNG image may contain up to 256 colors. When loading a PNG file, it is not necessary to call this function, because loadpng automatically loads any palette data available if the image descriptor member palette is nonzero.

Return value    Explanation
0 - 256    Number of palette colors read
BAD_MEM    Insufficient memory
BAD_OPN    Filename not found
BAD_PNG    File is not a readable PNG format

Example

int getPNGpal(HWND hWnd, char *fname, 
   RGBQUAD *paltable)  // paltable must be sizeof(RGBQUAD) * 256
{
   int colors;
   char szBuff[80];

   // Load palette data 
   colors = loadpngpalette(fname, paltable); 
   if(colors >= 0)   // Check range for error 
      wsprintf(szBuff, "%s contains %d colors", (LPSTR)fname, colors);
   else
      wsprintf(szBuff, "Error on loading palette of %s", (LPSTR)fname);
   MessageBox(hWnd, szBuff, 0, MB_OK);
   return(colors);
}

This example loads a PNG color palette into an array and if there are no errors, displays the number of palette colors loaded.

Summary

int loadtiffrombuffer(buff, image);
unsigned char huge *buff;   Buffer address
imgdes far *image;          Image 

Description
The loadtiffrombuffer function loads TIFF file data from a memory buffer into an area in an image buffer. The image area is defined by the image descriptor. Palette data, if present in the file, is loaded into the buffer defined by the image descriptor member palette. For a list of all the formats read by this function refer to loadtif.

The TIFF file header includes the image dimensions. If these dimensions do not match the dimensions of the area defined by the image descriptor, the smaller of the two will be used. Loadtiffrombuffer will enter into the image descriptor member colors the number of palette colors loaded. When 4-bit TIFF files are loaded, they are expanded into 8-bit image buffers. When a grayscale TIFF image is loaded, bit 0 of the image descriptor member imgtype is set to 1.

An attempt to load an LZW-compressed TIFF image will return the error code LZW_DISABLED unlessLZW functionality has been enabled with unlockLZW. The use of LZW compression requires an LZW license from Unisys Corporation. For information concerning licensing the LZW compression/decompression capability, please contact: Unisys Corporation, Welch Licensing Department - C1SW19 Township Line & Union Meeting Roads, P O Box 500, Blue Bell PA 19424, www.unisys.com.

Return value  Explanation
NO_ERROR   Function successful
BAD_RANGE  Range error, see Appendix A
BAD_IBUF   Invalid image buffer address
BAD_MEM   Insufficient memory
BAD_BPP   Image is not 1-, 8-, 16-, or 24-bit or image and file are not compatible bits per pixel
BAD_DIB   Source or result is a compressed DIB
BAD_OPN   Memory handle not available
BAD_TIFF   File is not a readable TIFF format
BAD_CMP   Unreadable compression scheme
TOO_CPLX   File data is too complex to read
LZW_DISABLED   LZW functionality not available, seeunlockLZW
BAD_PTR   Buff points at unreadable memory

See also loadtif, tiffinfofrombuffer, savetiftobuffer

Summary

int loadtifpagebyindex(filename, image, pageIndex);
char far *filename;          Filename of TIFF file
imgdes far *image;           Image 
int pageIndex;               Index of target page to load

Description
The loadtifpagebyindex function loads an image from a single or multipage TIFF file. The image that is to be loaded is specified by the pageIndex parameter, which is zero-based.

Use loadtifpagebyindex to load an image based on its position in the file. Use loadtifpage to load an image based on its page number tag.

Except for being able to load a specific image from a multipage TIFF file, loadtifpagebyindex is identical to the loadtif function.

To determine the number of pages and their page numbers in a multipage TIFF file, use the tiffgetpageinfo function.

If pageIndex is set to -1, calling loadtifpagebyindex will load the first image in a TIFF file.

Return value  Explanation
NO_ERROR   Function successful
BAD_RANGE  Range error, see Appendix A
BAD_IBUF   Invalid image buffer address
BAD_MEM   Insufficient memory
BAD_BPP   Image is not 1-, 8-, 16-, or 24-bit or image and file are not compatible bits per pixel
BAD_DIB   Source or result is a compressed DIB
BAD_OPN   Filename not found
BAD_TIFF   File is not a readable TIFF format
BAD_CMP   Unreadable compression scheme
TOO_CPLX   File data is too complex to read
TIFF_NOPAGE  TIFF page not found and pageIndex is not -1
LZW_DISABLED   LZW functionality not available, seeunlockLZW

See also loadtif, loadtifpage, tiffgetpageinfo, tiffinfopage

Summary

int loadtifpalettefrombuffer(buff, paltable); 
unsigned char huge *buff;   Buffer address where TIFF file data begins
RGBQUAD far *paltable;      Storage buffer for palette values

Description
The loadtifpalettefrombuffer function loads the palette data from a memory buffer holding TIFF file data into paltable. Paltable must be an array of 256 RGBQUAD structures (1024 bytes), since a TIFF image may contain up to 256 colors.

When loading a TIFF file, it is not necessary to call this function, because loadtiffrombuffer automatically loads any palette data available if the image descriptor member palette is nonzero.

Return value Explanation
0 - 256   Number of palette colors read
BAD_MEM   Insufficient memory
BAD_OPN   Memory handle not available
BAD_TIFF   File is not a readable TIFF format
BAD_PTR   Buff points at unreadable memory

Summary

int loadtifpalettepagebyindex(filename, paltable, pageIndex); 
char far *filename;      Filename of TIFF file
RGBQUAD far *paltable;   Storage buffer for palette values
int pageIndex;           Index of page to load palette from

Description
The loadtifpalettepagebyindex function loads the palette data from a specified page in a palette color TIFF image file into paltable. Paltable must be an array of 256 RGBQUAD structures (1024 bytes), since a TIFF image may contain up to 256 colors.

Use loadtifpalettepagebyindex to load an image palette based on its position in the file. Use loadtifpalettepage to load an image palette based on its page number tag.

When loading a TIFF image, it is not necessary to call this function, because loadtifpagebyindex automatically loads any palette data available if the image descriptor member palette is nonzero.

Return value Explanation
0 - 256   Number of palette colors read
BAD_MEM   Insufficient memory
BAD_OPN   Filename not found
BAD_TIFF   File is not a readable TIFF format
TIFF_NOPAGE   TIFF page not found and pageIndex is not -1

See also
loadtifpalette, loadtifpalettepage

matrixconvex

8

24

Summary

int matrixconvex(ksize, kernel, divsr, srcimg, resimg);
const int ksize;         Width of local area (3 - 63)
const char far *kernel;  Convolution matrix
const int divsr          Divisor
imgdes far *srcimg;      Source image 
imgdes far *resimg;      Result image 

Description
The matrixconvex function transforms an image area with a ksize x ksize convolution matrix. The source and result image areas are defined by the corresponding image descriptors.

   char kernel[9] = {1,1,1,1,1,1,1,1,1};

   matrixconvex(3, kernel, 9 &srcimg, &resimg);

int detect_horiz2(HWND hWnd, imgdes *image)
{
   static char dethoriz[] = {1, 1, 1, 0, 0, 0, -1, -1, -1};
   int divsr = 1;
   int rcode;
   
   rcode = matrixconvex(3, dethoriz, divsr, image, image);
   if(rcode != NO_ERROR)
      MessageBox(hWnd,"Error at matrixconvex()", 0, MB_OK);
   return(rcode);
}

int medianfilter(ksize,  srcimg, resimg);
const int ksize;         Width of local area (3 - 11)
imgdes far *srcimg;      Source image 
imgdes far *resimg;      Result image 

int watercolor(HWND hWnd, imgdes *image)
{
   int rcode;
   
   rcode = medianfilter(3, image, image);
   if(rcode != NO_ERROR)
      MessageBox(hWnd,"Error at matrixconvex()", 0, MB_OK);
   else {
      medianfilter(5, image, image);
      medianfilter(7, image, image);
      sharpen(image, image);
      }
   return(rcode);
}

int pnggeterror(void);

int loadAPngFile(HWND hWnd, char *fname, imgdes *image)
{
   PngData pdat;
   int rcode;

   // Get info on the file we're to load
   rcode = pnginfo(fname, &pdat);
   if(rcode == NO_ERROR) { // Fill structure
      // Allocate space for an image
      rcode = allocimage(image, (int)pdat.width, (int)pdat.length, pdat.vbitcount);
      if(rcode == NO_ERROR) {
         // Load image
         rcode = loadpng(fname, image);
         if(rcode == BAD_PNG) {
            char szBuff[128];
            // Get extended error info
            int extRcode = pnggeterror();
            wsprintf(szBuff, "Error in loading %s: extended error code %d", (LPSTR)fname, extRcode);
            MessageBox(hWnd, szBuff, 0, MB_OK);
            }
         freeimage(image); // Free image on error
         }
      }
   return(rcode);
}

int pnginfo(filename, pinfo);
char far *filename;      Filename to read
typedef struct {
   unsigned width;       PNG image width, length
   unsigned length;
   int bitDepth;         Bits per pixel, 1, 2, 4, 8, or 16
   int vbitcount;        Victor bits per pixel (used to allocate an image buffer with allocimage)
   int colorType;        Color types: 0=GS, 2=RGB, 3=PalCol, 4=GS+alpha, 6=RGB+alpha
   int interlaced;       0 = non-interlaced, 1 = interlaced
   int imageId;          Identifier for colorType/bitDepth
   int channels;         Number of channels of data per pixel
   int pixelDepth;       Number of bits per pixel
   unsigned rowBytes;    Bytes in one image row
   PNGTRANSINFO transData;Transparency data
   PNGTRANSINFO backData;Background color data
   DWORD igamma;         Gamma as float = igamma / 100000   
   DWORD physXres;       X,Y axis pixels per unit
   DWORD physYres;
   DWORD physUnits;
   PNGSIGBITS sigBit;    Significant bits in file
   DWORD offsXoffset;    X,Y axis offset
   DWORD offsYoffset;
   UCHAR offsUnits;
  } PngData far *pinfo;  Pointer to data structure to be filled in

     typedef struct {
       BOOL isPresent;    TRUE if transparency data is present
       UCHAR data[6];     Up to 6 bytes of transparency data
       int byteCount;     Bytes of transparency data
       } PNGTRANSINFO;

void pngsize(HWND hWnd, char *fname)
{
   PngData pdat;             /* Reserve space for structure */
   int rcode;
   char szBuff[80];

   rcode = pnginfo(fname, &pdat);
   if(rcode == BAD_OPN) {
      wsprintf(szBuff, "Could not find %s", (LPSTR)fname);
      MessageBox(hWnd, szBuff, 0, MB_OK);
      }
   else if(rcode == BAD_PNG) {
      wsprintf(szBuff, "%s is not a PNG file", (LPSTR)fname);
      MessageBox(hWnd, szBuff, 0, MB_OK);
      }
   else {
      wsprintf(szBuff, 
         "%s image dimensions: Width=%d, Length=%d",
         (LPSTR)fname, pdat.width, pdat.length);
      MessageBox(hWnd, szBuff, 0, MB_OK);
      }
}

int pnginfofrombuffer(buff, pinfo);
unsigned char huge *buff;     Buffer address
typedef struct {
   unsigned width;       PNG image width, length
   unsigned length;
   int bitDepth;         Bits per pixel, 1, 2, 4, 8, or 16
   int vbitcount;        Victor bits per pixel (used to allocate an image buffer with allocimage)
   int colorType;        Color types: 0=GS, 2=RGB, 3=PalCol, 4=GS+alpha, 6=RGB+alpha
   int interlaced;       0 = non-interlaced, 1 = interlaced
   int imageId;          Identifier for colorType/bitDepth
   int channels;         Number of channels of data per pixel
   int pixelDepth;       Number of bits per pixel
   unsigned rowBytes;    Bytes in one image row
   PNGTRANSINFO transData;Transparency data
   PNGTRANSINFO backData;Background color data
   DWORD igamma;         Gamma as float = igamma / 100000   
   DWORD physXres;       X,Y axis pixels per unit
   DWORD physYres;
   DWORD physUnits;
   PNGSIGBITS sigBit;    Significant bits in file
   DWORD offsXoffset;    X,Y axis offset
   DWORD offsYoffset;
   UCHAR offsUnits;
  } PngData far *pinfo;  Pointer to data structure to be filled in

int resizeex(srcimg, resimg, mode);
imgdes far *srcimg;     Source image 
imgdes far *resimg;     Result image 
int mode;               Resize mode (0=pixel replication, 1=interpolation)

void ResizeImageByInterp(HWND hWnd, imgdes *image)
{
   imgdes timage;
   int dx, dy, rcode, pct = 50; // 50% reduction
   int mode = RESIZEBILINEAR; // Bilinear interpolation

   // Allocate space for the new DIB
   dx = (int)(((long)(image->endx - image->stx + 1)) * pct / 100);
   dy = (int)(((long)(image->endy - image->sty + 1)) * pct / 100);
   if((rcode = allocimage(&timage, dx, dy,
      image->bmh->biBitCount)) == NO_ERROR) {
      // Resize Image into timage
      if((rcode = resizeex(image, &timage, mode)) == NO_ERROR) {
         // Success, free source image
         freeimage(image);
         // Assign timage to image
         copyimgdes(&timage, image);
         }
      else // Error in resizing image, release timage memory
         freeimage(&timage);
      }
   if(rcode != NO_ERROR)
      MessageBox(hWnd, "Error at resizeex()", 0, MB_OK);
}

int savebmptobuffer(buff, image, compression); 
unsigned char huge *far *buff;   Resulting buffer address
imgdes far *image;               Image 
int comp;                        Compression type (0=none 1=RLE8)

   GlobalFreePtr(buff);     // Windowsx.h macro

   BUFFER_SIZE(buff);     // Vicdefs.h macro

int savegifex(filename, image, saveMode, transColor);
char far *filename;              Filename to save
imgdes far *image;               Image 
int saveMode;                    Save mode
int transColor;                  Transparent color (0-255)

   saveMode = GIFINTERLACE | GIFNOCOMP;   // value = 9

int save_GifEx(HWND hWnd, char *fname, imgdes *image)
{
#define VINTERLACE   1 // Defined in VICDEFS.H
#define VTRANSPARENT 2
#define VWRITE4BIT   4
int rcode;

// Write a transparent, interlaced GIF
int saveMode = VINTERLACE | VTRANSPARENT;
int transColor = 10; // Transparent color is 10

// Write a 4-bit GIF if palette colors are 16 or less
if(image->colors <= 16)
   saveMode |= VWRITE4BIT;

rcode = savegifex(fname, imgptr, saveMode, trasnColor);
if(rcode != NO_ERROR) {
   char szBuff[80];
   wsprintf(szBuff, "Could not save %s", (LPSTR)fname);
   MessageBox(hWnd, szBuff, 0, MB_OK);
   }
return(rcode);
}

int savegiftobufferex(buff, image, saveMode, transColor);
unsigned char huge *far *buff;   Resulting buffer address
imgdes far *image;               Image 
int saveMode;                    Save mode
int transColor;                  Transparent color (0-255)

   GlobalFreePtr(buff);     // Windowsx.h macro

   BUFFER_SIZE(buff);     // Vicdefs.h macro

   saveMode = GIFINTERLACE | GIFNOCOMP;   // value = 9

int savejpgex(filename, image, quality, mode); 
char * filename;         Filename to save
imgdes far *image;       Image 
int quality;             Image quality (1 - 100)
int mode;                Save mode (0=baseline, 1=progressive, 2=sequential optimized)

int saveProgressiveJpeg(HWND hWnd, char *fname, imgdes *image)
{
   int j, rcode, quality = 75;
   int savemode = JPGPROG;
   char szBuff[80];

   rcode = savejpgex(fname, image, quality, savemode);
   if(rcode != NO_ERROR) {
      wsprintf(szBuff, "Could not save %s", (LPSTR)fname);
      MessageBox(hWnd, szBuff, 0, MB_OK);
      }
   return(rcode);
}

int savejpgtobufferex(buffer, image, quality,mode); 
unsigned char huge * far *buffer;  Buffer address
imgdes far *image;                 Image 
int quality;                       Image quality (1 - 100)
int mode;                          Save mode (0=baseline, 1=progressive, 2=sequential optimized)

     GlobalFreePtr(buffer); // WINDOWSX.H macro

   BUFFER_SIZE(buffer);     // Vicdefs.h macro

int savepng(filename, image, comp);
char far *filename;      Filename to save
imgdes far *image;       Image 
int comp;                Compression type (0-11)

int saveAPng(HWND hWnd, char *fname, imgdes *image)
{
   int rcode;
   int comp = PNGALLFILTERS | PNGINTERLACE;
   char szBuff[80];

   histoequalize(image, image);
   rcode = savepng(fname, image, comp);
   if(rcode != NO_ERROR) {
      wsprintf(szBuff, "Could not save %s", (LPSTR)fname);
      MessageBox(hWnd, szBuff, 0, MB_OK);
      }
   return(rcode);
}

int savepngtobuffer(buff, image, comp);
unsigned char huge *far *buff;  Resulting buffer address
imgdes far *image;              Image 
int comp;                       Compression type (0-11)

   GlobalFreePtr(buff);     // Windowsx.h macro

   BUFFER_SIZE(buff);     // Vicdefs.h macro

int savetiftobuffer(buff, image, comp); 
unsigned char huge *far *buff; Resulting buffer address
imgdes far *image;             Image 
int comp;                      Compression type (0-4, 0x10-0x14)

   GlobalFreePtr(buff);     // Windowsx.h macro

   BUFFER_SIZE(buff);     // Vicdefs.h macro

int tiffgeterror(void);

int loadATiffFile(HWND hWnd, char *fname, imgdes *image)
{
   TiffData tdat;
   int rcode;

   // Get info on the file we're to load
   rcode = tiffinfo(fname, &tdat);
   if(rcode == NO_ERROR) { // Fill structure
      // Allocate space for an image
      rcode = allocimage(image, (int)tdat.width, (int)tdat.length, tdat.vbitcount);
      if(rcode == NO_ERROR) {
         // Load image
         rcode = loadtif(fname, image);
         if(rcode == BAD_TIFF) {
            char szBuff[128];
            // Get extended error info
            int extRcode = tiffgeterror();
            wsprintf(szBuff, "Error in loading %s: extended error code %d", (LPSTR)fname, extRcode);
            MessageBox(hWnd, szBuff, 0, MB_OK);
            }
         freeimage(image); // Free image on error
         }
      }
   return(rcode);
}

int tiffinfofrombuffer(buff, tinfo);
unsigned char huge *buff;  Buffer address
typedef struct {           Structure to contain TIFF file data
   unsigned ByteOrder;     Intel or Motorola ("II" or "MM")
   unsigned width, length; Image width and length in pixels
   unsigned BitsPSample;   Bits per sample
   unsigned Comp;          Compression scheme
   unsigned SamplesPPixel; Samples per pixel
   unsigned PhotoInt;      Photometric interpretation
   unsigned PlanarCfg;     Planar configuration
   int vbitcount;          Victor bits per pixel (used to allocate an image buffer with allocimage)
   } TiffData far *tinfo;  Pointer to structure

int tiffinfopagebyindex(filename, tinfo, pageIndex);
const char far *filename;     Filename of multi-page TIFF file
typedef struct {              Structure to contain TIFF file data
	unsigned ByteOrder;        Intel or Motorola ("II" or "MM")
	unsigned width, length;    Image width and length in pixels
	unsigned BitsPSample;      Bits per sample
	unsigned Comp;             Compression scheme
	unsigned SamplesPPixel;    Samples per pixel
	unsigned PhotoInt;         Photometric interpretation
	unsigned PlanarCfg;        Planar configuration
	int vbitcount;             Victor bits per pixel (used to allocate an image buffer with allocimage)
} TiffData far *tinfo;        Pointer to structure
int pageIndex;                Index number of the target page number to get information about

int windowtoimage(hwnd, resimg);
HWND hwnd;              Window handle
imgdes far *resimg;     Result image

int CaptureScreenWindow(HWND hWnd)
{
   int rcode;
   imgdes timage;
   char *fname = "window.tif";

   // Capture window as Victor image
   rcode = windowtoimage(hWnd, &timage);
   if(rcode == NO_ERROR) {
      // Save captured window
      rcode = savetif(fname, &timage, 0);
      // Release memory allocated by windowtoimage()
      freeimage(&timage);
      }
   return(rcode)
}

WORD Victorversionex(verinfo);
typedef struct {       Structure to contain version information
   WORD version;       Version number
   WORD exver;         Extended version information
   } VIC_VERSION_INFO far *verinfo

void showVicVersionex(HWND hWnd, char *fname, imgdes *image)
{
   char szBuff[80];
   VIC_VERSION_INFO verinfo;

   Victorversionex(&verinfo);
   wsprintf(szBuff, "Victor Library version %d.%02d,%02d",
      HIBYTE(verfino.version), LOBYTE(verinfo.version),
         verinfo.flags); 
   MessageBox(hWnd, szBuff, 0, MB_OK);
}

TWdetecttwain 							
Summary
int TWdetecttwain(hWnd);
HWND hWnd;		          Window handle

void EnableTwainScanMenuItems(HWND hWnd, HMENU hMenu) 
{
   static BOOL scanDriverReady = FALSE;
   int mstate;

   // Enable/disable scan menu items
   if(scanDriverReady == FALSE) {
      // Enable/disable scan menu items
      mstate = MF_GRAYED;
      // If Twain source manager (TWAIN.DLL or TWAIN_32.DLL) 
      // is present, enable the scan menu items
      if(TWdetecttwain(hWnd) == NO_ERROR) {
         scanDriverReady = TRUE;
         mstate = MF_ENABLED;
         }
      EnableMenuItem(hMenu, IDM_F_SELECTSOURCE, mstate);
      EnableMenuItem(hMenu, IDM_F_ACQUIRE, mstate);
      }
}

int TWgetbrightness(hWnd, brightdata);
HWND hWnd;                      Window handle
typedef struct {
   short conType;               Container type, TWON_ONEVALUE, TWON_ENUMERATION, or TWON_RANGE,
   TWAIN_ONEVALUE oneVal;       Data for onevalue-type container 
   TWAIN_ENUMTYPE enum;         Data for enum-type container
   TWAIN_RANGE range;           Data for range-type container
   } TWAIN_CAP_DATA far *brightdata;    Pointer to structure;

int TWgetcontrast(hWnd, contrastdata);
HWND hWnd;                      Window handle
typedef struct {
   short conType;               Container type, TWON_ONEVALUE, TWON_ENUMERATION, or TWON_RANGE,
   TWAIN_ONEVALUE oneVal;       Data for onevalue-type container 
   TWAIN_ENUMTYPE enum;         Data for enum-type container
   TWAIN_RANGE range;           Data for range-type container
   } TWAIN_CAP_DATA far *contrastdata;  Pointer to structure;

int TWgeterror(void);	

int TWgetmeasureunit(hWnd, unitTypes);
HWND hWnd;                      Window handle
typedef struct {
   short conType;               Container type, TWON_ONEVALUE, TWON_ENUMERATION, or TWON_RANGE,
   TWAIN_ONEVALUE oneVal;       Data for onevalue-type container 
   TWAIN_ENUMTYPE enum;         Data for enum-type container
   TWAIN_RANGE range;           Data for range-type container
   } TWAIN_CAP_DATA far *unitTypes;      Pointer to structure;

int TWgetpixeltype(hWnd, pixelTypes);
HWND hWnd;                      Window handle
typedef struct {
   short conType;               Container type, TWON_ONEVALUE, TWON_ENUMERATION, or TWON_RANGE,
   TWAIN_ONEVALUE oneVal;       Data for onevalue-type container 
   TWAIN_ENUMTYPE enum;         Data for enum-type container
   TWAIN_RANGE range;           Data for range-type container
   } TWAIN_CAP_DATA far *pixelTypes; Pointer to structure;