laag-libtiff 4.0.9.0

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

@@ -0,0 +1,379 @@
+/*************************************************************************
+ *
+ * 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;
+      }
+}
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 8
+ * fill-column: 78
+ * End:
+ */

data/vendor/gitlab.com/libtiff/libtiff/html/.cvsignore

@@ -0,0 +1,5 @@
+Makefile
+.cvsignore
+BigTIFF
+robots.txt
+

data/vendor/gitlab.com/libtiff/libtiff/html/BigTIFFProposal.html

@@ -0,0 +1,99 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html lang="en">
+<head>
+  <title>Proposal to Implement BigTIFF Support in LibTiff</title>
+</head>
+<body>
+  <h1>Proposal to Implement BigTIFF Support in LibTiff</h1>
+  <p><b>NEWS:</b> We have located all four required sponsors. There are no more 
+    open slots. We will issue appropriate press release shortly.</p>
+  <h2>0. Summary</h2>
+  <p>BigTIFF logically extends the original TIFF file format (referred to as 
+    'ClassicTIFF' from this point on), breaking the 4 gigabyte boundary, in theory 
+    allowing files up to 18,000 petabytes in size. The BigTIFF specification is the 
+    result of work by a variety of parties on the LibTiff mailing list, including 
+    the current LibTiff maintainers, Joris Van Damme and Adobe staff. The BigTIFF 
+    specification has not yet been officially approved by the TIFF specification 
+    owner (Adobe) but implementation within LibTiff could accelerate that 
+    process.</p>
+  <p>For more information on the BigTIFF file format, we recommend 
+    <a href="http://www.awaresystems.be/imaging/tiff/bigtiff.html">AWare Systems' 
+    BigTIFF page.</a></p>
+  <p>BigTIFF is expected to be especially useful for people and vendors that are 
+    confronted with unusually large images, and still seek to use an open, simple, 
+    and extendable format. This requirement is frequently seen in the geospatial 
+    field, but also affects large format scanners, medical imaging and other 
+    fields.</p>
+  <h2>1. Sponsoring</h2>
+  <p>It is planned that LibTiff 4.0, the BigTIFF upgrade to LibTiff, would start 
+    March 1, 2007. A preliminary version (LibTiff 4.0alpha1) will be operational by 
+    June 15, 2007. Testing and final release improvements for LibTiff 4.0 will be 
+    completed by July 30, 2007.</p>
+  <p>The LibTiff BigTIFF upgrade team is seeking USD 24,000 from four sponsors (USD 
+    6,000 each) to fund the project. Sponsorship payment will be invoiced upon 
+    delivery of the LibTiff 4.0alpha1 release (on or before June 15) with a 30 day 
+    payable, giving time for some technical review.</p>
+  <p>In addition to the benefits of open interchange of BigTIFF data that comes from 
+    support in a public and free open source codec, sponsors will be given proper 
+    public acknowledgment. During development, they will be mentioned in the 
+    appropriate sections of the LibTiff and AWare Systems site.</p>
+  <p>When LibTiff 4.0 with BigTIFF support is released, they will additionally 
+    receive public acknowledgment in a formal press release, distributed widely to 
+    news venues in the imaging and geospatial industries.</p>
+  <p>A 'migration guide' document or any functional equivalent thereof will be 
+    included in the standard free distribution, but sponsors will additionally 
+    receive up to 20 hours of consulting and support on any BigTIFF migration issues 
+    that they may be facing, and/or any additional related requests they may have.</p>
+  <h2>2. Development and Testing</h2>
+  <p>The work will primarily be done by Joris Van Damme on behalf of his company 
+    AWare Systems. Joris was closely involved in the drafting of the BigTIFF file 
+    format proposal, and has also developed the proprietary AWare Systems TIFF 
+    codec that already supports BigTIFF. Joris Van Damme has a deep understanding 
+    of the TIFF format, and has been acting as a LibTiff co-maintainer for over a 
+    year, contributing the upgraded OJPEG codec as well as several other 
+    improvements.</p>
+  <p>Joris and AWare Systems have agreed to crosstest their proprietary codec and 
+    LibTiff's support for BigTIFF extensively. Joris will also extend the test image 
+    library included with LibTiff, with a number of varying BigTIFF test files. 
+    These files will primarily include test files with issues that relate closely 
+    to the BigTIFF file format and the difference with ClassicTIFF. For instance, 
+    in BigTIFF the datatypes TIFF_LONG, TIFF_LONG8, TIFF_IFD and TIFF_IFD8 are all 
+    valid for tags pointing to additional IFDs, and thus files will be included to 
+    illustrate and enable testing all of these. Additionally, Joris will build a 
+    tool to enable creating test files that exceed 4 gigabyte, as these can of 
+    course not be included in the test suite in a more direct manner, and a tool to 
+    convert files from ClassicTIFF to BigTIFF, as well as the other way around for 
+    source BigTIFF files that do not exceed 4 gigabyte in size.</p>
+  <p>Frank Warmerdam has also agreed to be involved in a consulting and validation 
+    role. Frank has been LibTiff's primary maintainer since approximately the year 
+    2000, develops large-image exploitation software for the geospatial industry 
+    (GDAL) and is currently President of the Open Source Geospatial Foundation 
+    (OSGeo). Frank will also be ensuring that BigTIFF improvements are made 
+    accessible to all users of the GDAL library.</p>
+  <h2>3. Implementation Strategy</h2>
+  <p>Many people who have a need for BigTIFF, use LibTiff already. We thus plan to 
+    support BigTIFF in LibTiff, applying a minimum change strategy much like the 
+    one that was applied in the creation of the new file format in the first 
+    place.</p>
+  <p>To support BigTIFF, we will use a 64bit integer datatype. It is anticipated 
+    that some older platforms will not be able to comply with this need, and for 
+    that reason we will encapsulate all required changes inside a conditional 
+    compilation switch.</p>
+  <p>While it is anticipated that there will be ABI (application binary interface) 
+    changes as part of a BigTIFF support upgrade to LibTiff, and possibly some 
+    more to support other major upgrades to LibTiff, the plan is such that 
+    the source level API will remain compatible for most LibTiff applications. 
+    Applications using specialized interfaces may require some minor source code 
+    changes, but we will provide backwards compatibility to support the majority
+    of existing application level code.</p>
+  <p>The resulting LibTiff version would transparently support reading traditional 
+    32bit ClassicTIFF files, and 64bit BigTIFF files, as well as writing either 
+    ClassicTIFF or BigTIFF files based on a flag in the TIFFOpen/TIFFClientOpen call.</p>
+  <h2>4. Intellectual Property and Licensing</h2>
+  <p>The licensing agreement of LibTiff will remain unchanged.</p>
+  <h2>5. Contact information</h2>
+  <p>Please contact <a href="mailto:warmerdam@pobox.com">Frank Warmerdam</a> and/or 
+    <a href="mailto:info@awaresystems.be">Joris Van Damme</a> for more information 
+    on sponsorship agreements.</p>
+</body>
+</html>