[wxWidgets.git] / src / tiff / contrib / win_dib / Tiffile.cpp

#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);
}
Commit	Line	Data
8414a40c VZ	1	#include "StdAfx.h"
	2
	3	//#define STRICT
	4	#include <windows.h>
	5	#include <windowsx.h>
	6	#include <commdlg.h>
	7	#include <stdlib.h> // MAX_ constants
	8	#include "diblib.h"
	9
	10	/*--------------------------------------------------------------------
	11	READ TIFF
	12	Load the TIFF data from the file into memory. Return
	13	a pointer to a valid DIB (or NULL for errors).
	14	Uses the TIFFRGBA interface to libtiff.lib to convert
	15	most file formats to a useable form. We just keep the 32 bit
	16	form of the data to display, rather than optimizing for the
	17	display.
	18
	19	Main entry points:
	20
	21	int ChkTIFF ( LPCTSTR lpszPath )
	22	PVOID ReadTIFF ( LPCTSTR lpszPath )
	23
	24	RETURN
	25	A valid DIB pointer for success; NULL for failure.
	26
	27	--------------------------------------------------------------------*/
	28
	29	#include "TiffLib/tiff.h"
	30	#include "TiffLib/tiffio.h"
	31	#include <assert.h>
	32	#include <stdio.h>
	33
	34
	35	// piggyback some data on top of the RGBA Image
	36	struct TIFFDibImage {
	37	TIFFRGBAImage tif;
	38	int dibinstalled;
	39	} ;
	40
	41
	42	HANDLE LoadTIFFinDIB(LPCTSTR lpFileName);
	43	HANDLE TIFFRGBA2DIB(TIFFDibImage* dib, uint32* raster) ;
	44
	45	static void
	46	MyWarningHandler(const char* module, const char* fmt, va_list ap)
	47	{
	48	// ignore all warnings (unused tags, etc)
	49	return;
	50	}
	51
	52	static void
	53	MyErrorHandler(const char* module, const char* fmt, va_list ap)
	54	{
	55	return;
	56	}
	57
	58	// Turn off the error and warning handlers to check if a valid file.
	59	// Necessary because of the way that the Doc loads images and restart files.
	60	int ChkTIFF ( LPCTSTR lpszPath )
	61	{
	62	int rtn = 0;
	63
	64	TIFFErrorHandler eh;
65	TIFFErrorHandler wh;
66
67	eh = TIFFSetErrorHandler(NULL);
68	wh = TIFFSetWarningHandler(NULL);
69
70	TIFF* tif = TIFFOpen(lpszPath, "r");
71	if (tif) {
72	rtn = 1;
73	TIFFClose(tif);
74	}
75
76	TIFFSetErrorHandler(eh);
77	TIFFSetWarningHandler(wh);
78
79	return rtn;
80	}
81
82	void DibInstallHack(TIFFDibImage* img) ;
83
84	PVOID ReadTIFF ( LPCTSTR lpszPath )
85	{
86	void* pDIB = 0;
87	TIFFErrorHandler wh;
88
89	wh = TIFFSetWarningHandler(MyWarningHandler);
90
91	if (ChkTIFF(lpszPath)) {
92	TIFF* tif = TIFFOpen(lpszPath, "r");
93	if (tif) {
94	char emsg[1024];
95
96	if (TIFFRGBAImageOK(tif, emsg)) {
97	TIFFDibImage img;
98	char emsg[1024];
99
100	if (TIFFRGBAImageBegin(&img.tif, tif, -1, emsg)) {
101	size_t npixels;
102	uint32* raster;
103
104	DibInstallHack(&img);
105
106	npixels = img.tif.width * img.tif.height;
107	raster = (uint32) _TIFFmalloc(npixels sizeof (uint32));
108	if (raster != NULL) {
109	if (TIFFRGBAImageGet(&img.tif, raster, img.tif.width, img.tif.height)) {
110	pDIB = TIFFRGBA2DIB(&img, raster);
111	}
112	}
113	_TIFFfree(raster);
114	}
115	TIFFRGBAImageEnd(&img.tif);
116	}
117	else {
118	TRACE("Unable to open image(%s): %s\n", lpszPath, emsg );
119	}
120	TIFFClose(tif);
121	}
122	}
123
124	TIFFSetWarningHandler(wh);
125
126	return pDIB;
127	}
128
129
130
131	HANDLE TIFFRGBA2DIB(TIFFDibImage* dib, uint32* raster)
132	{
133	void* pDIB = 0;
134	TIFFRGBAImage* img = &dib->tif;
135
136	uint32 imageLength;
137	uint32 imageWidth;
138	uint16 BitsPerSample;
139	uint16 SamplePerPixel;
140	uint32 RowsPerStrip;
141	uint16 PhotometricInterpretation;
142
143	BITMAPINFOHEADER bi;
144	int dwDIBSize ;
145
146	TIFFGetField(img->tif, TIFFTAG_IMAGEWIDTH, &imageWidth);
147	TIFFGetField(img->tif, TIFFTAG_IMAGELENGTH, &imageLength);
148	TIFFGetField(img->tif, TIFFTAG_BITSPERSAMPLE, &BitsPerSample);
149	TIFFGetField(img->tif, TIFFTAG_ROWSPERSTRIP, &RowsPerStrip);
150	TIFFGetField(img->tif, TIFFTAG_SAMPLESPERPIXEL, &SamplePerPixel);
151	TIFFGetField(img->tif, TIFFTAG_PHOTOMETRIC, &PhotometricInterpretation);
152
153	if ( BitsPerSample == 1 && SamplePerPixel == 1 && dib->dibinstalled ) { // bilevel
154	bi.biSize = sizeof(BITMAPINFOHEADER);
155	bi.biWidth = imageWidth;
156	bi.biHeight = imageLength;
157	bi.biPlanes = 1; // always
158	bi.biBitCount = 1;
159	bi.biCompression = BI_RGB;
160	bi.biSizeImage = WIDTHBYTES(bi.biWidth * bi.biBitCount) * bi.biHeight;
161	bi.biXPelsPerMeter = 0;
162	bi.biYPelsPerMeter = 0;
163	bi.biClrUsed = 0; // must be zero for RGB compression (none)
164	bi.biClrImportant = 0; // always
165
166	// Get the size of the DIB
167	dwDIBSize = GetDIBSize( &bi );
168
169	// Allocate for the BITMAPINFO structure and the color table.
170	pDIB = GlobalAllocPtr( GHND, dwDIBSize );
171	if (pDIB == 0) {
172	return( NULL );
173	}
174
175	// Copy the header info
176	((BITMAPINFOHEADER)pDIB) = bi;
177
178	// Get a pointer to the color table
179	RGBQUAD pRgbq = (RGBQUAD )((LPSTR)pDIB + sizeof(BITMAPINFOHEADER));
180
181	pRgbq[0].rgbRed = 0;
182	pRgbq[0].rgbBlue = 0;
183	pRgbq[0].rgbGreen = 0;
184	pRgbq[0].rgbReserved = 0;
185	pRgbq[1].rgbRed = 255;
186	pRgbq[1].rgbBlue = 255;
187	pRgbq[1].rgbGreen = 255;
188	pRgbq[1].rgbReserved = 255;
189
190	// Pointers to the bits
191	//PVOID pbiBits = (LPSTR)pRgbq + bi.biClrUsed * sizeof(RGBQUAD);
192	//
193	// In the BITMAPINFOHEADER documentation, it appears that
194	// there should be no color table for 32 bit images, but
195	// experience shows that the image is off by 3 words if it
196	// is not included. So here it is.
197	PVOID pbiBits = GetDIBImagePtr((BITMAPINFOHEADER)pDIB); //(LPSTR)pRgbq + 3 sizeof(RGBQUAD);
198
199	int sizeWords = bi.biSizeImage/4;
200	RGBQUAD* rgbDib = (RGBQUAD*)pbiBits;
201	long* rgbTif = (long*)raster;
202
203	_TIFFmemcpy(pbiBits, raster, bi.biSizeImage);
204	}
205
206	// For now just always default to the RGB 32 bit form. // save as 32 bit for simplicity
207	else if ( true /BitsPerSample == 8 && SamplePerPixel == 3/ ) { // 24 bit color
208
209	bi.biSize = sizeof(BITMAPINFOHEADER);
210	bi.biWidth = imageWidth;
211	bi.biHeight = imageLength;
212	bi.biPlanes = 1; // always
213	bi.biBitCount = 32;
214	bi.biCompression = BI_RGB;
215	bi.biSizeImage = WIDTHBYTES(bi.biWidth * bi.biBitCount) * bi.biHeight;
216	bi.biXPelsPerMeter = 0;
217	bi.biYPelsPerMeter = 0;
218	bi.biClrUsed = 0; // must be zero for RGB compression (none)
219	bi.biClrImportant = 0; // always
220
221	// Get the size of the DIB
222	dwDIBSize = GetDIBSize( &bi );
223
224	// Allocate for the BITMAPINFO structure and the color table.
225	pDIB = GlobalAllocPtr( GHND, dwDIBSize );
226	if (pDIB == 0) {
227	return( NULL );
228	}
229
230	// Copy the header info
231	((BITMAPINFOHEADER)pDIB) = bi;
232
233	// Get a pointer to the color table
234	RGBQUAD pRgbq = (RGBQUAD )((LPSTR)pDIB + sizeof(BITMAPINFOHEADER));
235
236	// Pointers to the bits
237	//PVOID pbiBits = (LPSTR)pRgbq + bi.biClrUsed * sizeof(RGBQUAD);
238	//
239	// In the BITMAPINFOHEADER documentation, it appears that
240	// there should be no color table for 32 bit images, but
241	// experience shows that the image is off by 3 words if it
242	// is not included. So here it is.
243	PVOID pbiBits = (LPSTR)pRgbq + 3 * sizeof(RGBQUAD);
244
245	int sizeWords = bi.biSizeImage/4;
246	RGBQUAD* rgbDib = (RGBQUAD*)pbiBits;
247	long* rgbTif = (long*)raster;
248
249	// Swap the byte order while copying
250	for ( int i = 0 ; i < sizeWords ; ++i )
251	{
252	rgbDib[i].rgbRed = TIFFGetR(rgbTif[i]);
253	rgbDib[i].rgbBlue = TIFFGetB(rgbTif[i]);
254	rgbDib[i].rgbGreen = TIFFGetG(rgbTif[i]);
255	rgbDib[i].rgbReserved = 0;
256	}
257	}
258
259	return pDIB;
260	}
261
262
263
264
265	///////////////////////////////////////////////////////////////
266	//
267	// Hacked from tif_getimage.c in libtiff in v3.5.7
268	//
269	//
270	typedef unsigned char u_char;
271
272
273	#define DECLAREContigPutFunc(name) \
274	static void name(\
275	TIFFRGBAImage* img, \
276	uint32* cp, \
277	uint32 x, uint32 y, \
278	uint32 w, uint32 h, \
279	int32 fromskew, int32 toskew, \
280	u_char* pp \
281	)
282
283	#define DECLARESepPutFunc(name) \
284	static void name(\
285	TIFFRGBAImage* img,\
286	uint32* cp,\
287	uint32 x, uint32 y, \
288	uint32 w, uint32 h,\
289	int32 fromskew, int32 toskew,\
290	u_char* r, u_char* g, u_char* b, u_char* a\
291	)
292
293	DECLAREContigPutFunc(putContig1bitTile);
294	static int getStripContig1Bit(TIFFRGBAImage* img, uint32* uraster, uint32 w, uint32 h);
295
296	//typdef struct TIFFDibImage {
297	// TIFFRGBAImage tif;
298	// dibinstalled;
299	//} TIFFDibImage ;
300
301	void DibInstallHack(TIFFDibImage* dib) {
302	TIFFRGBAImage* img = &dib->tif;
303	dib->dibinstalled = false;
304	switch (img->photometric) {
305	case PHOTOMETRIC_MINISWHITE:
306	case PHOTOMETRIC_MINISBLACK:
307	switch (img->bitspersample) {
308	case 1:
309	img->put.contig = putContig1bitTile;
310	img->get = getStripContig1Bit;
311	dib->dibinstalled = true;
312	break;
313	}
314	break;
315	}
316	}
317
318	/*
319	* 1-bit packed samples => 1-bit
320	*
321	* Override to just copy the data
322	*/
323	DECLAREContigPutFunc(putContig1bitTile)
324	{
325	int samplesperpixel = img->samplesperpixel;
326
327	(void) y;
328	fromskew *= samplesperpixel;
329	int wb = WIDTHBYTES(w);
330	u_char* ucp = (u_char*)cp;
331
332	/* Conver 'w' to bytes from pixels (rounded up) */
333	w = (w+7)/8;
334
335	while (h-- > 0) {
336	_TIFFmemcpy(ucp, pp, w);
337	/*
338	for (x = wb; x-- > 0;) {
339	*cp++ = rgbi(Map[pp[0]], Map[pp[1]], Map[pp[2]]);
340	pp += samplesperpixel;
341	}
342	*/
343	ucp += (wb + toskew);
344	pp += (w + fromskew);
345	}
346	}
347
348	/*
349	* Hacked from the tif_getimage.c file.
350	*/
351	static uint32
352	setorientation(TIFFRGBAImage* img, uint32 h)
353	{
354	TIFF* tif = img->tif;
355	uint32 y;
356
357	switch (img->orientation) {
358	case ORIENTATION_BOTRIGHT:
359	case ORIENTATION_RIGHTBOT: /* XXX */
360	case ORIENTATION_LEFTBOT: /* XXX */
361	TIFFWarning(TIFFFileName(tif), "using bottom-left orientation");
362	img->orientation = ORIENTATION_BOTLEFT;
363	/* fall thru... */
364	case ORIENTATION_BOTLEFT:
365	y = 0;
366	break;
367	case ORIENTATION_TOPRIGHT:
368	case ORIENTATION_RIGHTTOP: /* XXX */
369	case ORIENTATION_LEFTTOP: /* XXX */
370	default:
371	TIFFWarning(TIFFFileName(tif), "using top-left orientation");
372	img->orientation = ORIENTATION_TOPLEFT;
373	/* fall thru... */
374	case ORIENTATION_TOPLEFT:
375	y = h-1;
376	break;
377	}
378	return (y);
379	}
380
381	/*
382	* Get a strip-organized image that has
383	* PlanarConfiguration contiguous if SamplesPerPixel > 1
384	* or
385	* SamplesPerPixel == 1
386	*
387	* Hacked from the tif_getimage.c file.
388	*
389	* This is set up to allow us to just copy the data to the raster
390	* for 1-bit bitmaps
391	*/
392	static int
393	getStripContig1Bit(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
394	{
395	TIFF* tif = img->tif;
396	tileContigRoutine put = img->put.contig;
397	uint16 orientation;
398	uint32 row, y, nrow, rowstoread;
399	uint32 pos;
400	u_char* buf;
401	uint32 rowsperstrip;
402	uint32 imagewidth = img->width;
403	tsize_t scanline;
404	int32 fromskew, toskew;
405	tstrip_t strip;
406	tsize_t stripsize;
407	u_char* braster = (u_char*)raster; // byte wide raster
408	uint32 wb = WIDTHBYTES(w);
409	int ret = 1;
410
411	buf = (u_char*) _TIFFmalloc(TIFFStripSize(tif));
412	if (buf == 0) {
413	TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for strip buffer");
414	return (0);
415	}
416	y = setorientation(img, h);
417	orientation = img->orientation;
418	toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? wb+wb : wb-wb);
419	TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
420	scanline = TIFFScanlineSize(tif);
421	fromskew = (w < imagewidth ? imagewidth - w : 0)/8;
422	for (row = 0; row < h; row += nrow)
423	{
424	rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip;
425	nrow = (row + rowstoread > h ? h - row : rowstoread);
426	strip = TIFFComputeStrip(tif,row+img->row_offset, 0);
427	stripsize = ((row + img->row_offset)%rowsperstrip + nrow) * scanline;
428	if (TIFFReadEncodedStrip(tif, strip, buf, stripsize ) < 0
429	&& img->stoponerr)
430	{
431	ret = 0;
432	break;
433	}
434
435	pos = ((row + img->row_offset) % rowsperstrip) * scanline;
436	(put)(img, (uint32)(braster+y*wb), 0, y, w, nrow, fromskew, toskew, buf + pos);
437	y += (orientation == ORIENTATION_TOPLEFT ?-(int32) nrow : (int32) nrow);
438	}
439	_TIFFfree(buf);
440	return (ret);
441	}
442