/************************************************************************* * * 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*SamplePerPixel+2];                                lpBits[i*SamplePerPixel+1]=buf[l*LineSize+i*SamplePerPixel+1];                               lpBits[i*SamplePerPixel+2]=buf[l*LineSize+i*SamplePerPixel+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 heremean "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;      }}