/*************************************************************************

*

* Source file for Windows 95/Win32.

*

* The function LoadTIFFinDIB in this source file let you load

* a TIFF file and build a memory DIB with it and return the

* HANDLE (HDIB) of the memory bloc containing the DIB.

*

* Example :

*

* HDIB hDIB;

* hDIB = LoadTIFFinDIB("sample.tif");

*

*

* To build this source file you must include the TIFF library

* in your project.

*

* 4/12/95 Philippe Tenenhaus 100423.3705@compuserve.com

*

************************************************************************/

#include "tiffio.h"

#define HDIB HANDLE

#define IS_WIN30_DIB(lpbi) ((*(LPDWORD)(lpbi)) == sizeof(BITMAPINFOHEADER))

#define CVT(x) (((x) * 255L) / ((1L<<16)-1))

static HDIB CreateDIB(DWORD dwWidth, DWORD dwHeight, WORD wBitCount);

static LPSTR FindDIBBits(LPSTR lpDIB);

static WORD PaletteSize(LPSTR lpDIB);

static WORD DIBNumColors(LPSTR lpDIB);

static int checkcmap(int n, uint16* r, uint16* g, uint16* b);

/*************************************************************************

*

* HDIB LoadTIFFinDIB(LPSTR lpFileName)

*

* Parameter:

*

* LPSTR lpDIB - File name of a tiff imag

*

* Return Value:

*

* LPSTR - HANDLE of a DIB

*

* Description:

*

* This function load a TIFF file and build a memory DIB with it

* and return the HANDLE (HDIB) of the memory bloc containing

* the DIB.

*

* 4/12/95 Philippe Tenenhaus 100423.3705@compuserve.com

*

************************************************************************/

HDIB LoadTIFFinDIB(LPSTR lpFileName)

{

TIFF *tif;

unsigned long imageLength;

unsigned long imageWidth;

unsigned int BitsPerSample;

unsigned long LineSize;

unsigned int SamplePerPixel;

unsigned long RowsPerStrip;

int PhotometricInterpretation;

long nrow;

unsigned long row;

char *buf;

LPBITMAPINFOHEADER lpDIB;

HDIB hDIB;

char *lpBits;

HGLOBAL hStrip;

int i,l;

int Align;

tif = TIFFOpen(lpFileName, "r");

if (!tif)

goto TiffOpenError;

TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &imageWidth);

TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &imageLength);

TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &BitsPerSample);

TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &RowsPerStrip);

TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &RowsPerStrip);

TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &PhotometricInterpretation);

LineSize = TIFFScanlineSize(tif); //Number of byte in ine line

SamplePerPixel = (int) (LineSize/imageWidth);

//Align = Number of byte to add at the end of each line of the DIB

Align = 4 - (LineSize % 4);

if (Align == 4) Align = 0;

//Create a new DIB

hDIB = CreateDIB((DWORD) imageWidth, (DWORD) imageLength, (WORD)

(BitsPerSample*SamplePerPixel));

lpDIB = (LPBITMAPINFOHEADER) GlobalLock(hDIB);

if (!lpDIB)

goto OutOfDIBMemory;

if (lpDIB)

lpBits = FindDIBBits((LPSTR) lpDIB);

//In the tiff file the lines are save from up to down

//In a DIB the lines must be save from down to up

if (lpBits)

{

lpBits = FindDIBBits((LPSTR) lpDIB);

lpBits+=((imageWidth*SamplePerPixel)+Align)*(imageLength-1);

//now lpBits pointe on the bottom line

hStrip = GlobalAlloc(GHND,TIFFStripSize(tif));

buf = GlobalLock(hStrip);

if (!buf)

goto OutOfBufMemory;

//PhotometricInterpretation = 2 image is RGB

//PhotometricInterpretation = 3 image have a color palette

if (PhotometricInterpretation == 3)

{

uint16* red;

uint16* green;

uint16* blue;

int16 i;

LPBITMAPINFO lpbmi;

int Palette16Bits;

TIFFGetField(tif, TIFFTAG_COLORMAP, &red, &green, &blue);

//Is the palette 16 or 8 bits ?

if (checkcmap(1<<BitsPerSample, red, green, blue) == 16)

Palette16Bits = TRUE;

else

Palette16Bits = FALSE;

lpbmi = (LPBITMAPINFO)lpDIB;

//load the palette in the DIB

for (i = (1<<BitsPerSample)-1; i >= 0; i--)

{

if (Palette16Bits)

{

lpbmi->bmiColors[i].rgbRed =(BYTE) CVT(red[i]);

lpbmi->bmiColors[i].rgbGreen = (BYTE) CVT(green[i]);

lpbmi->bmiColors[i].rgbBlue = (BYTE) CVT(blue[i]);

}

else

{

lpbmi->bmiColors[i].rgbRed = (BYTE) red[i];

lpbmi->bmiColors[i].rgbGreen = (BYTE) green[i];

lpbmi->bmiColors[i].rgbBlue = (BYTE) blue[i];

}

}

}

//read the tiff lines and save them in the DIB

//with RGB mode, we have to change the order of the 3 samples RGB

<=> BGR

for (row = 0; row < imageLength; row += RowsPerStrip)

{

nrow = (row + RowsPerStrip > imageLength ? imageLength - row :

RowsPerStrip);

if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, row, 0),

buf, nrow*LineSize)==-1)

{

goto TiffReadError;

}

else

{

for (l = 0; l < nrow; l++)

{

if (SamplePerPixel == 3)

for (i=0;i< (int) (imageWidth);i++)

{

lpBits[i*SamplePerPixel+0]=buf[l*LineSize+i*Sample

PerPixel+2];

lpBits[i*SamplePerPixel+1]=buf[l*LineSize+i*Sample

PerPixel+1];

lpBits[i*SamplePerPixel+2]=buf[l*LineSize+i*Sample

PerPixel+0];

}

else

memcpy(lpBits, &buf[(int) (l*LineSize)], (int)

imageWidth*SamplePerPixel);

lpBits-=imageWidth*SamplePerPixel+Align;

}

}

}

GlobalUnlock(hStrip);

GlobalFree(hStrip);

GlobalUnlock(hDIB);

TIFFClose(tif);

}

return hDIB;

OutOfBufMemory:

TiffReadError:

GlobalUnlock(hDIB);

GlobalFree(hStrip);

OutOfDIBMemory:

TIFFClose(tif);

TiffOpenError:

return (HANDLE) 0;

}

static int checkcmap(int n, uint16* r, uint16* g, uint16* b)

{

while (n-- > 0)

if (*r++ >= 256 || *g++ >= 256 || *b++ >= 256)

return (16);

return (8);

}

/*************************************************************************

* All the following functions were created by microsoft, they are

* parts of the sample project "wincap" given with the SDK Win32.

*

* Microsoft says that :

*

* You have a royalty-free right to use, modify, reproduce and

* distribute the Sample Files (and/or any modified version) in

* any way you find useful, provided that you agree that

* Microsoft has no warranty obligations or liability for any

* Sample Application Files which are modified.

*

************************************************************************/

HDIB CreateDIB(DWORD dwWidth, DWORD dwHeight, WORD wBitCount)

{

BITMAPINFOHEADER bi; // bitmap header

LPBITMAPINFOHEADER lpbi; // pointer to BITMAPINFOHEADER

DWORD dwLen; // size of memory block

HDIB hDIB;

DWORD dwBytesPerLine; // Number of bytes per scanline

// Make sure bits per pixel is valid

if (wBitCount <= 1)

wBitCount = 1;

else if (wBitCount <= 4)

wBitCount = 4;

else if (wBitCount <= 8)

wBitCount = 8;

else if (wBitCount <= 24)

wBitCount = 24;

else

wBitCount = 4; // set default value to 4 if parameter is bogus

// initialize BITMAPINFOHEADER

bi.biSize = sizeof(BITMAPINFOHEADER);

bi.biWidth = dwWidth; // fill in width from parameter

bi.biHeight = dwHeight; // fill in height from parameter

bi.biPlanes = 1; // must be 1

bi.biBitCount = wBitCount; // from parameter

bi.biCompression = BI_RGB;

bi.biSizeImage = (dwWidth*dwHeight*wBitCount)/8; //0; // 0's here

mean "default"

bi.biXPelsPerMeter = 2834; //0;

bi.biYPelsPerMeter = 2834; //0;

bi.biClrUsed = 0;

bi.biClrImportant = 0;

// calculate size of memory block required to store the DIB. This

// block should be big enough to hold the BITMAPINFOHEADER, the color

// table, and the bits

dwBytesPerLine = (((wBitCount * dwWidth) + 31) / 32 * 4);

dwLen = bi.biSize + PaletteSize((LPSTR)&bi) + (dwBytesPerLine * dwHeight);

// alloc memory block to store our bitmap

hDIB = GlobalAlloc(GHND, dwLen);

// major bummer if we couldn't get memory block

if (!hDIB)

{

return NULL;

}

// lock memory and get pointer to it

lpbi = (VOID FAR *)GlobalLock(hDIB);

// use our bitmap info structure to fill in first part of

// our DIB with the BITMAPINFOHEADER

*lpbi = bi;

// Since we don't know what the colortable and bits should contain,

// just leave these blank. Unlock the DIB and return the HDIB.

GlobalUnlock(hDIB);

/* return handle to the DIB */

return hDIB;

}

LPSTR FAR FindDIBBits(LPSTR lpDIB)

{

return (lpDIB + *(LPDWORD)lpDIB + PaletteSize(lpDIB));

}

WORD FAR PaletteSize(LPSTR lpDIB)

{

/* calculate the size required by the palette */

if (IS_WIN30_DIB (lpDIB))

return (DIBNumColors(lpDIB) * sizeof(RGBQUAD));

else

return (DIBNumColors(lpDIB) * sizeof(RGBTRIPLE));

}

WORD DIBNumColors(LPSTR lpDIB)

{

WORD wBitCount; // DIB bit count

/* If this is a Windows-style DIB, the number of colors in the

* color table can be less than the number of bits per pixel

* allows for (i.e. lpbi->biClrUsed can be set to some value).

* If this is the case, return the appropriate value.

*/

if (IS_WIN30_DIB(lpDIB))

{

DWORD dwClrUsed;

dwClrUsed = ((LPBITMAPINFOHEADER)lpDIB)->biClrUsed;

if (dwClrUsed)

return (WORD)dwClrUsed;

}

/* Calculate the number of colors in the color table based on

* the number of bits per pixel for the DIB.

*/

if (IS_WIN30_DIB(lpDIB))

wBitCount = ((LPBITMAPINFOHEADER)lpDIB)->biBitCount;

else

wBitCount = ((LPBITMAPCOREHEADER)lpDIB)->bcBitCount;

/* return number of colors based on bits per pixel */

switch (wBitCount)

{

case 1:

return 2;

case 4:

return 16;

case 8:

return 256;

default:

return 0;

}

}

/*

* Local Variables:

* mode: c

* c-basic-offset: 8

* fill-column: 78

* End:

*/