laag-libtiff 4.0.9.0

data/vendor/gitlab.com/libtiff/libtiff/contrib/win_dib/Makefile.w95

@@ -0,0 +1,134 @@
+#	$Header: /usr/people/sam/tiff/libtiff/RCS/Makefile.w95,v 1.2 1994/11/28
+06:13:31 sam Exp $
+#
+# Tag Image File Format Library
+#
+# Copyright (c) 1988, 1989, 1990, 1991, 1992 Sam Leffler
+# Copyright (c) 1991, 1992 Silicon Graphics, Inc.
+# 
+# Permission to use, copy, modify, distribute, and sell this software and 
+# its documentation for any purpose is hereby granted without fee, provided
+# that (i) the above copyright notices and this permission notice appear in
+# all copies of the software and related documentation, and (ii) the names of
+# Sam Leffler and Silicon Graphics may not be used in any advertising or
+# publicity relating to the software without the specific, prior written
+# permission of Sam Leffler and Silicon Graphics.
+# 
+# THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
+# EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
+# WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
+# 
+# IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+# ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+# OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+# WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
+# LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
+# OF THIS SOFTWARE.
+#
+# This Makefile is for use with microsoft nmake version 1.50 and 
+# Microsoft 32-bit C/C++ Compiler 9.00
+#
+DESTDIR=.
+#
+IPATH=	-I. 
+CONF_LIBRARY=$(NULL)
+COPTS=	-Oxa -DBSDTYPES -Zd
+CFLAGS=	$(COPTS)  $(CONF_LIBRARY)
+#
+INCS=	tiff.h tiffio.h
+SRCS=	tif_aux.c \
+	tif_close.c \
+	tif_codec.c \
+	tif_compress.c \
+	tif_dir.c \
+	tif_dirinfo.c \
+	tif_dirread.c \
+	tif_dirwrite.c \
+	tif_dumpmode.c \
+	tif_error.c \
+	tif_getimage.c \
+	tif_jpeg.c \
+	tif_flush.c \
+	tif_lzw.c \
+	tif_next.c \
+	tif_open.c \
+	tif_packbits.c \
+	tif_predict \
+	tif_print.c \
+	tif_read.c \
+	tif_swab.c \
+	tif_strip.c \
+	tif_thunder.c \
+	tif_tile.c \
+	tif_version.c \
+	tif_warning.c \
+	tif_write.c \
+	tif_win32.c 
+		
+	
+OBJS=	tif_aux.obj \
+	tif_close.obj \
+	tif_codec.obj \
+	tif_compress.obj \
+	tif_dir.obj \
+	tif_dirinfo.obj \
+	tif_dirread.obj \
+	tif_dirwrite.obj \
+	tif_dumpmode.obj \
+	tif_error.obj \
+	tif_getimage.obj \
+	tif_jpeg.obj \
+	tif_flush.obj \
+	tif_lzw.obj \
+	tif_next.obj \
+	tif_open.obj \
+	tif_packbits.obj \
+	tif_predict.obj \
+	tif_print.obj \
+	tif_read.obj \
+	tif_swab.obj \
+	tif_strip.obj \
+	tif_thunder.obj \
+	tif_tile.obj \
+	tif_version.obj \
+	tif_warning.obj \
+	tif_write.obj \
+	tif_win32.obj 
+	
+	
+
+ALL=	libtiff.lib
+
+all:	 $(ALL)
+
+%.obj : %.c
+	$(CC) $(CFLAGS) -c $*.c
+
+
+#.INCLUDE .IGNORE : depend
+
+libtiff.lib: $(OBJS)
+	 - del libtiff.lib
+	 lib /OUT:libtiff.lib $(OBJS)
+
+
+#To include fax3 support, you need to modify mkg3states.c so it could run
+#under windows 95 or NT. This application make the file g3state.h.
+#after that, you have to add to the build script : tif_fax3.c and tif_fax3.obj
+#and define CCITT_SUPPORT in the file tifconf.h
+
+#$(OBJS): tiffio.h tiff.h tiffcomp.h tiffiop.h tiffconf.h
+#tif_fax3.obj: tif_fax3.c g3states.h t4.h tif_fax3.h
+
+#g3states.h: mkg3states.c t4.h
+#	$(CC) $(CFLAGS) mkg3states.c
+#	mkg3states -c > g3states.h
+
+
+clean:
+	del *.obj
+        del mkg3stat
+        del g3states.h
+
+tags:	$(SRCS)
+	$(CTAGS) $(SRCS)

data/vendor/gitlab.com/libtiff/libtiff/contrib/win_dib/README.Tiffile

@@ -0,0 +1,31 @@
+Frank,
+
+I attached a file that uses RGBA interface (tif_getimage.c) to read a tiff
+file and convert to a DIB.  It's advantage is that it is easy to read *any*
+tiff file suported by libtiff and easily convert it to a DIB.  The disadvantage
+is that bilevel (B&W) bitmaps (and all other non-rgba images) are also 
+converted to RGBA, thus taking up 32x as much memory as needed (4 bytes per 
+pixel, rather than 1 bit).  I read tiff files, but don't need to
+write them.  And my files are typically small, so the overhead is mostly
+inconsequential.  But for bilevel images, I overrode the get() and put()
+routines of the RGBA interface to just copy the data from the input raster
+to the output raster, rather than expanding out to full 32 bit format.  It
+would be nice if there were a simple way to handle all palletized images,
+but that would take more custom routines, and it's not that important to me.
+
+Usage:
+
+    m_pDIB = (PBITMAPINFOHEADER)::ReadTIFF(pathName);
+    if (m_pDIB != 0) {
+       m_format = IMAGETYPE_TIF;
+    }
+
+This is intended as Win32, but the modifications for new get() and put()
+routines may be independent of platform.
+
+Thanks for your work supporting the forum and the library!
+
+Regards,
+
+Mark James
+mark@james.net

data/vendor/gitlab.com/libtiff/libtiff/contrib/win_dib/README.tiff2dib

@@ -0,0 +1,51 @@
+
+Date: 04 Dec 95 10:34:23 EST
+From: Philippe <100423.3705@compuserve.com>
+To: TIFF/sam Leffler <sam@cthulhu.engr.sgi.com>
+Subject: TIFF library and Windows 95
+Message-Id: <951204153422_100423.3705_BHG101-1@CompuServe.COM>
+
+Sam, 
+
+First, let me thanks all of you how have worked 
+on that great TIFF library !
+
+Here is some information that may help someone.
+
+I build the library under Windows 95 as a 32-bit library.
+The contribution of Scott Wagner (tif_win32.c) worked fine, but 
+the makefile "makefile.msc" was unsable because it was
+written for DOS or Windows 3.1 and all the files names 
+are limited to 8 characters.
+
+Here is the makefile I used : makefile.w95
+
+Also, I had to disable fax3 support because I wasn't able
+to build (as it is) the tool "mkg3states" to generate the include
+file "g3states.h". 
+This source file must be modify to be build under Windows 95.
+
+To build the library under Windows 95 with Visual C++ 2.0, 
+I had to :
+
+- undefine CCITT_SUPPORT in "tiffconf.h"
+
+- create the file version.h with this line :
+      #define VERSION "3.4beta024"
+
+- build the makefile "makefile.w95"
+
+I also join the source file "tif2dib.c" that I created, 
+it contain the function LoadTIFFinDIB that load 
+a TIFF file and build a memory DIB with it and return the 
+HANDLE (HDIB) of the memory bloc containing this DIB.
+Since DIB is the "natural" bitmap format for Windows 3.1, 95 and NT,
+this function sould be usefull for some Windows 95 (or NT) developer.
+
+
+Sorry for my approximate english ...
+
+Regards,
+
+Philippe Tenenhaus   100423.3705@compuserve.com
+Paris

data/vendor/gitlab.com/libtiff/libtiff/contrib/win_dib/Tiffile.cpp

@@ -0,0 +1,449 @@
+#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:
+ */