373 lines
11 KiB
C
373 lines
11 KiB
C
/*************************************************************************
|
|
*
|
|
* 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;
|
|
}
|
|
}
|