From 9491825ddff7a294d1f49061bae7044e426aeb2e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Fri, 6 Nov 2015 05:38:49 +0100 Subject: Imported Upstream version 1.8.3 --- tiff/contrib/win_dib/Tiffile.cpp | 449 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 449 insertions(+) create mode 100755 tiff/contrib/win_dib/Tiffile.cpp (limited to 'tiff/contrib/win_dib/Tiffile.cpp') diff --git a/tiff/contrib/win_dib/Tiffile.cpp b/tiff/contrib/win_dib/Tiffile.cpp new file mode 100755 index 0000000..9d958b1 --- /dev/null +++ b/tiff/contrib/win_dib/Tiffile.cpp @@ -0,0 +1,449 @@ +#include "StdAfx.h" + +//#define STRICT +#include +#include +#include +#include // 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 +#include + + +// 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: + */ -- cgit v1.2.3