#include "StdAfx.h"
//#define STRICT
#include <windows.h>
#include <windowsx.h>
#include <commdlg.h>
#include <stdlib.h> // MAX_ constants
#include "diblib.h"
/*--------------------------------------------------------------------
READ TIFF
Load the TIFF data from the file into memory. Return
a pointer to a valid DIB (or NULL for errors).
Uses the TIFFRGBA interface to libtiff.lib to convert
most file formats to a useable form. We just keep the 32 bit
form of the data to display, rather than optimizing for the
display.
Main entry points:
int ChkTIFF ( LPCTSTR lpszPath )
PVOID ReadTIFF ( LPCTSTR lpszPath )
RETURN
A valid DIB pointer for success; NULL for failure.
--------------------------------------------------------------------*/
#include "TiffLib/tiff.h"
#include "TiffLib/tiffio.h"
#include <assert.h>
#include <stdio.h>
// piggyback some data on top of the RGBA Image
struct TIFFDibImage {
TIFFRGBAImage tif;
int dibinstalled;
} ;
HANDLE LoadTIFFinDIB(LPCTSTR lpFileName);
HANDLE TIFFRGBA2DIB(TIFFDibImage* dib, uint32* raster) ;
static void
MyWarningHandler(const char* module, const char* fmt, va_list ap)
{
// ignore all warnings (unused tags, etc)
return;
}
static void
MyErrorHandler(const char* module, const char* fmt, va_list ap)
{
return;
}
// Turn off the error and warning handlers to check if a valid file.
// Necessary because of the way that the Doc loads images and restart files.
int ChkTIFF ( LPCTSTR lpszPath )
{
int rtn = 0;
TIFFErrorHandler eh;
TIFFErrorHandler wh;
eh = TIFFSetErrorHandler(NULL);
wh = TIFFSetWarningHandler(NULL);
TIFF* tif = TIFFOpen(lpszPath, "r");
if (tif) {
rtn = 1;
TIFFClose(tif);
}
TIFFSetErrorHandler(eh);
TIFFSetWarningHandler(wh);
return rtn;
}
void DibInstallHack(TIFFDibImage* img) ;
PVOID ReadTIFF ( LPCTSTR lpszPath )
{
void* pDIB = 0;
TIFFErrorHandler wh;
wh = TIFFSetWarningHandler(MyWarningHandler);
if (ChkTIFF(lpszPath)) {
TIFF* tif = TIFFOpen(lpszPath, "r");
if (tif) {
char emsg[1024];
if (TIFFRGBAImageOK(tif, emsg)) {
TIFFDibImage img;
char emsg[1024];
if (TIFFRGBAImageBegin(&img.tif, tif, -1, emsg)) {
size_t npixels;
uint32* raster;
DibInstallHack(&img);
npixels = img.tif.width * img.tif.height;
raster = (uint32*) _TIFFmalloc(npixels * sizeof (uint32));
if (raster != NULL) {
if (TIFFRGBAImageGet(&img.tif, raster, img.tif.width, img.tif.height)) {
pDIB = TIFFRGBA2DIB(&img, raster);
}
}
_TIFFfree(raster);
}
TIFFRGBAImageEnd(&img.tif);
}
else {
TRACE("Unable to open image(%s): %s\n", lpszPath, emsg );
}
TIFFClose(tif);
}
}
TIFFSetWarningHandler(wh);
return pDIB;
}
HANDLE TIFFRGBA2DIB(TIFFDibImage* dib, uint32* raster)
{
void* pDIB = 0;
TIFFRGBAImage* img = &dib->tif;
uint32 imageLength;
uint32 imageWidth;
uint16 BitsPerSample;
uint16 SamplePerPixel;
uint32 RowsPerStrip;
uint16 PhotometricInterpretation;
BITMAPINFOHEADER bi;
int dwDIBSize ;
TIFFGetField(img->tif, TIFFTAG_IMAGEWIDTH, &imageWidth);
TIFFGetField(img->tif, TIFFTAG_IMAGELENGTH, &imageLength);
TIFFGetField(img->tif, TIFFTAG_BITSPERSAMPLE, &BitsPerSample);
TIFFGetField(img->tif, TIFFTAG_ROWSPERSTRIP, &RowsPerStrip);
TIFFGetField(img->tif, TIFFTAG_SAMPLESPERPIXEL, &SamplePerPixel);
TIFFGetField(img->tif, TIFFTAG_PHOTOMETRIC, &PhotometricInterpretation);
if ( BitsPerSample == 1 && SamplePerPixel == 1 && dib->dibinstalled ) { // bilevel
bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = imageWidth;
bi.biHeight = imageLength;
bi.biPlanes = 1; // always
bi.biBitCount = 1;
bi.biCompression = BI_RGB;
bi.biSizeImage = WIDTHBYTES(bi.biWidth * bi.biBitCount) * bi.biHeight;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0; // must be zero for RGB compression (none)
bi.biClrImportant = 0; // always
// Get the size of the DIB
dwDIBSize = GetDIBSize( &bi );
// Allocate for the BITMAPINFO structure and the color table.
pDIB = GlobalAllocPtr( GHND, dwDIBSize );
if (pDIB == 0) {
return( NULL );
}
// Copy the header info
*((BITMAPINFOHEADER*)pDIB) = bi;
// Get a pointer to the color table
RGBQUAD *pRgbq = (RGBQUAD *)((LPSTR)pDIB + sizeof(BITMAPINFOHEADER));
pRgbq[0].rgbRed = 0;
pRgbq[0].rgbBlue = 0;
pRgbq[0].rgbGreen = 0;
pRgbq[0].rgbReserved = 0;
pRgbq[1].rgbRed = 255;
pRgbq[1].rgbBlue = 255;
pRgbq[1].rgbGreen = 255;
pRgbq[1].rgbReserved = 255;
// Pointers to the bits
//PVOID pbiBits = (LPSTR)pRgbq + bi.biClrUsed * sizeof(RGBQUAD);
//
// In the BITMAPINFOHEADER documentation, it appears that
// there should be no color table for 32 bit images, but
// experience shows that the image is off by 3 words if it
// is not included. So here it is.
PVOID pbiBits = GetDIBImagePtr((BITMAPINFOHEADER*)pDIB); //(LPSTR)pRgbq + 3 * sizeof(RGBQUAD);
int sizeWords = bi.biSizeImage/4;
RGBQUAD* rgbDib = (RGBQUAD*)pbiBits;
long* rgbTif = (long*)raster;
_TIFFmemcpy(pbiBits, raster, bi.biSizeImage);
}
// For now just always default to the RGB 32 bit form. // save as 32 bit for simplicity
else if ( true /*BitsPerSample == 8 && SamplePerPixel == 3*/ ) { // 24 bit color
bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = imageWidth;
bi.biHeight = imageLength;
bi.biPlanes = 1; // always
bi.biBitCount = 32;
bi.biCompression = BI_RGB;
bi.biSizeImage = WIDTHBYTES(bi.biWidth * bi.biBitCount) * bi.biHeight;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0; // must be zero for RGB compression (none)
bi.biClrImportant = 0; // always
// Get the size of the DIB
dwDIBSize = GetDIBSize( &bi );
// Allocate for the BITMAPINFO structure and the color table.
pDIB = GlobalAllocPtr( GHND, dwDIBSize );
if (pDIB == 0) {
return( NULL );
}
// Copy the header info
*((BITMAPINFOHEADER*)pDIB) = bi;
// Get a pointer to the color table
RGBQUAD *pRgbq = (RGBQUAD *)((LPSTR)pDIB + sizeof(BITMAPINFOHEADER));
// Pointers to the bits
//PVOID pbiBits = (LPSTR)pRgbq + bi.biClrUsed * sizeof(RGBQUAD);
//
// In the BITMAPINFOHEADER documentation, it appears that
// there should be no color table for 32 bit images, but
// experience shows that the image is off by 3 words if it
// is not included. So here it is.
PVOID pbiBits = (LPSTR)pRgbq + 3 * sizeof(RGBQUAD);
int sizeWords = bi.biSizeImage/4;
RGBQUAD* rgbDib = (RGBQUAD*)pbiBits;
long* rgbTif = (long*)raster;
// Swap the byte order while copying
for ( int i = 0 ; i < sizeWords ; ++i )
{
rgbDib[i].rgbRed = TIFFGetR(rgbTif[i]);
rgbDib[i].rgbBlue = TIFFGetB(rgbTif[i]);
rgbDib[i].rgbGreen = TIFFGetG(rgbTif[i]);
rgbDib[i].rgbReserved = 0;
}
}
return pDIB;
}
///////////////////////////////////////////////////////////////
//
// Hacked from tif_getimage.c in libtiff in v3.5.7
//
//
typedef unsigned char u_char;
#define DECLAREContigPutFunc(name) \
static void name(\
TIFFRGBAImage* img, \
uint32* cp, \
uint32 x, uint32 y, \
uint32 w, uint32 h, \
int32 fromskew, int32 toskew, \
u_char* pp \
)
#define DECLARESepPutFunc(name) \
static void name(\
TIFFRGBAImage* img,\
uint32* cp,\
uint32 x, uint32 y, \
uint32 w, uint32 h,\
int32 fromskew, int32 toskew,\
u_char* r, u_char* g, u_char* b, u_char* a\
)
DECLAREContigPutFunc(putContig1bitTile);
static int getStripContig1Bit(TIFFRGBAImage* img, uint32* uraster, uint32 w, uint32 h);
//typdef struct TIFFDibImage {
// TIFFRGBAImage tif;
// dibinstalled;
//} TIFFDibImage ;
void DibInstallHack(TIFFDibImage* dib) {
TIFFRGBAImage* img = &dib->tif;
dib->dibinstalled = false;
switch (img->photometric) {
case PHOTOMETRIC_MINISWHITE:
case PHOTOMETRIC_MINISBLACK:
switch (img->bitspersample) {
case 1:
img->put.contig = putContig1bitTile;
img->get = getStripContig1Bit;
dib->dibinstalled = true;
break;
}
break;
}
}
/*
* 1-bit packed samples => 1-bit
*
* Override to just copy the data
*/
DECLAREContigPutFunc(putContig1bitTile)
{
int samplesperpixel = img->samplesperpixel;
(void) y;
fromskew *= samplesperpixel;
int wb = WIDTHBYTES(w);
u_char* ucp = (u_char*)cp;
/* Conver 'w' to bytes from pixels (rounded up) */
w = (w+7)/8;
while (h-- > 0) {
_TIFFmemcpy(ucp, pp, w);
/*
for (x = wb; x-- > 0;) {
*cp++ = rgbi(Map[pp[0]], Map[pp[1]], Map[pp[2]]);
pp += samplesperpixel;
}
*/
ucp += (wb + toskew);
pp += (w + fromskew);
}
}
/*
* Hacked from the tif_getimage.c file.
*/
static uint32
setorientation(TIFFRGBAImage* img, uint32 h)
{
TIFF* tif = img->tif;
uint32 y;
switch (img->orientation) {
case ORIENTATION_BOTRIGHT:
case ORIENTATION_RIGHTBOT: /* XXX */
case ORIENTATION_LEFTBOT: /* XXX */
TIFFWarning(TIFFFileName(tif), "using bottom-left orientation");
img->orientation = ORIENTATION_BOTLEFT;
/* fall thru... */
case ORIENTATION_BOTLEFT:
y = 0;
break;
case ORIENTATION_TOPRIGHT:
case ORIENTATION_RIGHTTOP: /* XXX */
case ORIENTATION_LEFTTOP: /* XXX */
default:
TIFFWarning(TIFFFileName(tif), "using top-left orientation");
img->orientation = ORIENTATION_TOPLEFT;
/* fall thru... */
case ORIENTATION_TOPLEFT:
y = h-1;
break;
}
return (y);
}
/*
* Get a strip-organized image that has
* PlanarConfiguration contiguous if SamplesPerPixel > 1
* or
* SamplesPerPixel == 1
*
* Hacked from the tif_getimage.c file.
*
* This is set up to allow us to just copy the data to the raster
* for 1-bit bitmaps
*/
static int
getStripContig1Bit(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
{
TIFF* tif = img->tif;
tileContigRoutine put = img->put.contig;
uint16 orientation;
uint32 row, y, nrow, rowstoread;
uint32 pos;
u_char* buf;
uint32 rowsperstrip;
uint32 imagewidth = img->width;
tsize_t scanline;
int32 fromskew, toskew;
tstrip_t strip;
tsize_t stripsize;
u_char* braster = (u_char*)raster; // byte wide raster
uint32 wb = WIDTHBYTES(w);
int ret = 1;
buf = (u_char*) _TIFFmalloc(TIFFStripSize(tif));
if (buf == 0) {
TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for strip buffer");
return (0);
}
y = setorientation(img, h);
orientation = img->orientation;
toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? wb+wb : wb-wb);
TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
scanline = TIFFScanlineSize(tif);
fromskew = (w < imagewidth ? imagewidth - w : 0)/8;
for (row = 0; row < h; row += nrow)
{
rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip;
nrow = (row + rowstoread > h ? h - row : rowstoread);
strip = TIFFComputeStrip(tif,row+img->row_offset, 0);
stripsize = ((row + img->row_offset)%rowsperstrip + nrow) * scanline;
if (TIFFReadEncodedStrip(tif, strip, buf, stripsize ) < 0
&& img->stoponerr)
{
ret = 0;
break;
}
pos = ((row + img->row_offset) % rowsperstrip) * scanline;
(*put)(img, (uint32*)(braster+y*wb), 0, y, w, nrow, fromskew, toskew, buf + pos);
y += (orientation == ORIENTATION_TOPLEFT ?-(int32) nrow : (int32) nrow);
}
_TIFFfree(buf);
return (ret);
}
/*
* Local Variables:
* mode: c++
* c-basic-offset: 8
* fill-column: 78
* End:
*/