mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1591 lines
48 KiB
1591 lines
48 KiB
// Cdib.cpp
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "cdib.h"
|
|
#include <windowsx.h>
|
|
#include <afxadv.h>
|
|
#include <io.h>
|
|
#include <errno.h>
|
|
#include <math.h>
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CDib
|
|
|
|
IMPLEMENT_DYNAMIC(CDib, CObject)
|
|
|
|
/**************************************************************************\
|
|
* CDib::CDib()
|
|
*
|
|
* Constructor for CDib class
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* none
|
|
*
|
|
* Return Value:
|
|
*
|
|
* none
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
CDib::CDib()
|
|
{
|
|
m_pBMI = NULL;
|
|
m_pBits = NULL;
|
|
m_pPalette = NULL;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::~CDib
|
|
*
|
|
* Destructor for CDib class
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* none
|
|
*
|
|
* Return Value:
|
|
*
|
|
* none
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
CDib::~CDib()
|
|
{
|
|
Free();
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::Free()
|
|
*
|
|
* Cleans the stored DIB from memory
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* none
|
|
*
|
|
* Return Value:
|
|
*
|
|
* void
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
void CDib::Free()
|
|
{
|
|
// Make sure all member data that might have been allocated is freed.
|
|
if (m_pBits) {
|
|
GlobalFreePtr(m_pBits);
|
|
m_pBits = NULL;
|
|
}
|
|
if (m_pBMI) {
|
|
GlobalFreePtr(m_pBMI);
|
|
m_pBMI = NULL;
|
|
}
|
|
if (m_pPalette) {
|
|
m_pPalette->DeleteObject();
|
|
delete m_pPalette;
|
|
m_pPalette = NULL;
|
|
}
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::Paint()
|
|
*
|
|
* Draws a DIB to the target DC
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* hDC - Target DC
|
|
* lpDCRect - DC window rect
|
|
* lpDIBRect - DIB's rect
|
|
*
|
|
* Return Value:
|
|
*
|
|
* status
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
BOOL CDib::Paint(HDC hDC, LPRECT lpDCRect, LPRECT lpDIBRect) const
|
|
{
|
|
float lWidthVal = 1;
|
|
float lHeightVal = 1;
|
|
|
|
if (!m_pBMI)
|
|
return FALSE;
|
|
|
|
HPALETTE hPal = NULL; // Our DIB's palette
|
|
HPALETTE hOldPal = NULL; // Previous palette
|
|
|
|
// Get the DIB's palette, then select it into DC
|
|
if (m_pPalette != NULL) {
|
|
hPal = (HPALETTE) m_pPalette->m_hObject;
|
|
|
|
// Select as background since we have
|
|
// already realized in forground if needed
|
|
hOldPal = ::SelectPalette(hDC, hPal, TRUE);
|
|
}
|
|
|
|
// Make sure to use the stretching mode best for color pictures
|
|
::SetStretchBltMode(hDC, COLORONCOLOR);
|
|
|
|
// Determine whether to call StretchDIBits() or SetDIBitsToDevice()
|
|
BOOL bSuccess;
|
|
if ((RECTWIDTH(lpDCRect) == RECTWIDTH(lpDIBRect)) &&
|
|
(RECTHEIGHT(lpDCRect) == RECTHEIGHT(lpDIBRect)))
|
|
bSuccess = ::SetDIBitsToDevice(hDC, // hDC
|
|
lpDCRect->left, // DestX
|
|
lpDCRect->top, // DestY
|
|
RECTWIDTH(lpDCRect), // nDestWidth
|
|
RECTHEIGHT(lpDCRect), // nDestHeight
|
|
lpDIBRect->left, // SrcX
|
|
(int)Height() - lpDIBRect->top - RECTHEIGHT(lpDIBRect),
|
|
// SrcY
|
|
0, // nStartScan
|
|
(WORD)Height(), // nNumScans
|
|
m_pBits, // lpBits
|
|
m_pBMI, // lpBitsInfo
|
|
DIB_RGB_COLORS); // wUsage
|
|
else {
|
|
//Window width becomes smaller than original image width
|
|
if (RECTWIDTH(lpDIBRect) > lpDCRect->right - lpDCRect->left) {
|
|
lWidthVal = (float)(lpDCRect->right - lpDCRect->left)/RECTWIDTH(lpDIBRect);
|
|
}
|
|
//Window height becomes smaller than original image height
|
|
if (RECTHEIGHT(lpDIBRect) > lpDCRect->bottom - lpDCRect->top) {
|
|
lHeightVal = (float)(lpDCRect->bottom - lpDCRect->top)/RECTHEIGHT(lpDIBRect);
|
|
}
|
|
long ScaledWidth = (int)(RECTWIDTH(lpDIBRect) * min(lWidthVal,lHeightVal));
|
|
long ScaledHeight = (int)(RECTHEIGHT(lpDIBRect) * min(lWidthVal,lHeightVal));
|
|
bSuccess = ::StretchDIBits(hDC, // hDC
|
|
lpDCRect->left, // DestX
|
|
lpDCRect->top, // DestY
|
|
ScaledWidth, // nDestWidth
|
|
ScaledHeight, // nDestHeight
|
|
lpDIBRect->left, // SrcX
|
|
lpDIBRect->top, // SrcY
|
|
RECTWIDTH(lpDIBRect), // wSrcWidth
|
|
RECTHEIGHT(lpDIBRect), // wSrcHeight
|
|
m_pBits, // lpBits
|
|
m_pBMI, // lpBitsInfo
|
|
DIB_RGB_COLORS, // wUsage
|
|
SRCCOPY); // dwROP
|
|
|
|
// update outline areas
|
|
// Invalidated right side rect
|
|
RECT WindowRect;
|
|
WindowRect.top = lpDCRect->top;
|
|
WindowRect.left = lpDCRect->left + ScaledWidth;
|
|
WindowRect.right = lpDCRect->right;
|
|
WindowRect.bottom = lpDCRect->bottom;
|
|
|
|
HBRUSH hBrush = CreateSolidBrush(GetBkColor(hDC));
|
|
FillRect(hDC,&WindowRect,hBrush);
|
|
|
|
// Invalidated bottom rect
|
|
WindowRect.top = lpDCRect->top + ScaledHeight;
|
|
WindowRect.left = lpDCRect->left;
|
|
WindowRect.right = lpDCRect->left + ScaledWidth;
|
|
WindowRect.bottom = lpDCRect->bottom;
|
|
|
|
FillRect(hDC,&WindowRect,hBrush);
|
|
DeleteObject(hBrush);
|
|
}
|
|
// Reselect old palette
|
|
if (hOldPal != NULL) {
|
|
::SelectPalette(hDC, hOldPal, TRUE);
|
|
}
|
|
return bSuccess;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::CreatePalette()
|
|
*
|
|
* Creates a valid palette using the current DIB data
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* none
|
|
*
|
|
* Return Value:
|
|
*
|
|
* status
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
BOOL CDib::CreatePalette()
|
|
{
|
|
if (!m_pBMI)
|
|
return FALSE;
|
|
|
|
//get the number of colors in the DIB
|
|
WORD wNumColors = NumColors();
|
|
|
|
if (wNumColors != 0) {
|
|
// allocate memory block for logical palette
|
|
HANDLE hLogPal = ::GlobalAlloc(GHND, sizeof(LOGPALETTE) + sizeof(PALETTEENTRY)*wNumColors);
|
|
|
|
// if not enough memory, clean up and return NULL
|
|
if (hLogPal == 0)
|
|
return FALSE;
|
|
|
|
LPLOGPALETTE lpPal = (LPLOGPALETTE)::GlobalLock((HGLOBAL)hLogPal);
|
|
|
|
// set version and number of palette entries
|
|
lpPal->palVersion = PALVERSION;
|
|
lpPal->palNumEntries = (WORD)wNumColors;
|
|
|
|
for (int i = 0; i < (int)wNumColors; i++) {
|
|
lpPal->palPalEntry[i].peRed = m_pBMI->bmiColors[i].rgbRed;
|
|
lpPal->palPalEntry[i].peGreen = m_pBMI->bmiColors[i].rgbGreen;
|
|
lpPal->palPalEntry[i].peBlue = m_pBMI->bmiColors[i].rgbBlue;
|
|
lpPal->palPalEntry[i].peFlags = 0;
|
|
}
|
|
|
|
// create the palette and get handle to it
|
|
if (m_pPalette) {
|
|
m_pPalette->DeleteObject();
|
|
delete m_pPalette;
|
|
}
|
|
m_pPalette = new CPalette;
|
|
BOOL bResult = m_pPalette->CreatePalette(lpPal);
|
|
::GlobalUnlock((HGLOBAL) hLogPal);
|
|
::GlobalFree((HGLOBAL) hLogPal);
|
|
return bResult;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::Width
|
|
*
|
|
* Returns DIB's width in pixels
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* none
|
|
*
|
|
* Return Value:
|
|
*
|
|
* DWORD
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
DWORD CDib::Width() const
|
|
{
|
|
if (!m_pBMI)
|
|
return 0;
|
|
return m_pBMI->bmiHeader.biWidth;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::Height()
|
|
*
|
|
* Returns DIB's height in pixels
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* none
|
|
*
|
|
* Return Value:
|
|
*
|
|
* DWORD
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
DWORD CDib::Height() const
|
|
{
|
|
if (!m_pBMI)
|
|
return 0;
|
|
return m_pBMI->bmiHeader.biHeight;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::PaletteSize()
|
|
*
|
|
* Returns the size of the DIB's palette
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* none
|
|
*
|
|
* Return Value:
|
|
*
|
|
* WORD - Palette size in bytes
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
WORD CDib::PaletteSize() const
|
|
{
|
|
if (!m_pBMI)
|
|
return 0;
|
|
return NumColors() * sizeof(RGBQUAD);
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::NumColors()
|
|
*
|
|
* Returns the number of colors in DIB's palette
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* none
|
|
*
|
|
* Return Value:
|
|
*
|
|
* WORD - Number of colors used
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
WORD CDib::NumColors() const
|
|
{
|
|
if (!m_pBMI)
|
|
return 0;
|
|
|
|
WORD wBitCount; // DIB bit count
|
|
|
|
// 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.
|
|
|
|
DWORD dwClrUsed;
|
|
|
|
dwClrUsed = m_pBMI->bmiHeader.biClrUsed;
|
|
if (dwClrUsed != 0)
|
|
return(WORD)dwClrUsed;
|
|
|
|
// Calculate the number of colors in the color table based on
|
|
// the number of bits per pixel for the DIB.
|
|
wBitCount = m_pBMI->bmiHeader.biBitCount;
|
|
|
|
// 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;
|
|
}
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::Save()
|
|
*
|
|
* Saves the DIB to a file.
|
|
* note: the CFile must be opened before this call is made!
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* CFile& - Open CFile
|
|
*
|
|
* Return Value:
|
|
*
|
|
* DWORD - Number of Bytes saved in the file
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
DWORD CDib::Save(CFile& file) const
|
|
{
|
|
BITMAPFILEHEADER bmfHdr; // Header for Bitmap file
|
|
DWORD dwDIBSize;
|
|
|
|
if (m_pBMI == NULL)
|
|
return 0;
|
|
|
|
// Fill in the fields of the file header
|
|
|
|
// Fill in file type (first 2 bytes must be "BM" for a bitmap)
|
|
bmfHdr.bfType = DIB_HEADER_MARKER; // "BM"
|
|
|
|
// Calculating the size of the DIB is a bit tricky (if we want to
|
|
// do it right). The easiest way to do this is to call GlobalSize()
|
|
// on our global handle, but since the size of our global memory may have
|
|
// been padded a few bytes, we may end up writing out a few too
|
|
// many bytes to the file (which may cause problems with some apps).
|
|
//
|
|
// So, instead let's calculate the size manually (if we can)
|
|
//
|
|
// First, find size of header plus size of color table. Since the
|
|
// first DWORD in both BITMAPINFOHEADER and BITMAPCOREHEADER conains
|
|
// the size of the structure, let's use this.
|
|
dwDIBSize = *(LPDWORD)&m_pBMI->bmiHeader + PaletteSize(); // Partial Calculation
|
|
|
|
// Now calculate the size of the image
|
|
if ((m_pBMI->bmiHeader.biCompression == BI_RLE8) || (m_pBMI->bmiHeader.biCompression == BI_RLE4)) {
|
|
// It's an RLE bitmap, we can't calculate size, so trust the
|
|
// biSizeImage field
|
|
dwDIBSize += m_pBMI->bmiHeader.biSizeImage;
|
|
} else {
|
|
DWORD dwBmBitsSize; // Size of Bitmap Bits only
|
|
|
|
// It's not RLE, so size is Width (DWORD aligned) * Height
|
|
dwBmBitsSize = WIDTHBYTES((m_pBMI->bmiHeader.biWidth)*((DWORD)m_pBMI->bmiHeader.biBitCount)) * m_pBMI->bmiHeader.biHeight;
|
|
dwDIBSize += dwBmBitsSize;
|
|
|
|
// Now, since we have calculated the correct size, why don't we
|
|
// fill in the biSizeImage field (this will fix any .BMP files which
|
|
// have this field incorrect).
|
|
m_pBMI->bmiHeader.biSizeImage = dwBmBitsSize;
|
|
}
|
|
|
|
// Calculate the file size by adding the DIB size to sizeof(BITMAPFILEHEADER)
|
|
bmfHdr.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER);
|
|
bmfHdr.bfReserved1 = 0;
|
|
bmfHdr.bfReserved2 = 0;
|
|
|
|
// Now, calculate the offset the actual bitmap bits will be in
|
|
// the file -- It's the Bitmap file header plus the DIB header,
|
|
// plus the size of the color table.
|
|
|
|
bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + m_pBMI->bmiHeader.biSize + PaletteSize();
|
|
|
|
// Write the file header
|
|
file.Write((LPSTR)&bmfHdr, sizeof(BITMAPFILEHEADER));
|
|
DWORD dwBytesSaved = sizeof(BITMAPFILEHEADER);
|
|
|
|
// Write the DIB header
|
|
UINT nCount = sizeof(BITMAPINFO) + (NumColors()-1)*sizeof(RGBQUAD);
|
|
dwBytesSaved += nCount;
|
|
file.Write(m_pBMI, nCount);
|
|
|
|
// Write the DIB bits
|
|
DWORD dwBytes = m_pBMI->bmiHeader.biBitCount * Width();
|
|
// Calculate the number of bytes per line
|
|
if (dwBytes%32 == 0)
|
|
dwBytes /= 8;
|
|
else
|
|
dwBytes = dwBytes/8 + (32-dwBytes%32)/8 + (((32-dwBytes%32)%8 > 0) ? 1 : 0);
|
|
nCount = dwBytes * Height();
|
|
dwBytesSaved += nCount;
|
|
file.WriteHuge(m_pBits, nCount);
|
|
return dwBytesSaved;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::Read()
|
|
*
|
|
* Reads from a File into DIB form
|
|
* Note: the CFile must be opened before this call is made!
|
|
*
|
|
* Arguments:
|
|
*
|
|
* CFile& - Open CFile
|
|
* FileType - BMP_IMAGE, TIFF_IMAGE
|
|
*
|
|
* Return Value:
|
|
*
|
|
* DWORD - Number of bytes read from the CFile
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
DWORD CDib::Read(CFile& file,int FileType)
|
|
{
|
|
DWORD dwReadBytes = 0;
|
|
|
|
// Ensures no memory leaks will occur
|
|
Free();
|
|
if (FileType == TIFF_IMAGE) {
|
|
DWORD dwCurrentFileOffset = 0;
|
|
DWORD dwStripByteCountOffset = 0;
|
|
DWORD dwStripOffset = 0;
|
|
|
|
// TIFF variables
|
|
TIFFFILEHEADER tfHeader;
|
|
TIFFTAG tTag;
|
|
short TagCount = 0;
|
|
|
|
dwReadBytes = file.Read(&tfHeader,sizeof(TIFFFILEHEADER));
|
|
if (dwReadBytes != sizeof(TIFFFILEHEADER)) {
|
|
AfxMessageBox("Error reading TIFF file header");
|
|
return 0;
|
|
}
|
|
dwCurrentFileOffset += dwReadBytes;
|
|
|
|
if (tfHeader.tfType != 42) {
|
|
AfxMessageBox("Invalid TIFF format");
|
|
return 0;
|
|
}
|
|
|
|
if (tfHeader.tfByteOrder[0] != 'I' && tfHeader.tfByteOrder[1] != 'I') {
|
|
AfxMessageBox("Invalid TIFF format not 'II'");
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// move file pointer to TAG offset
|
|
//
|
|
dwCurrentFileOffset = file.Seek(tfHeader.tfOffset,CFile::begin);
|
|
|
|
dwReadBytes = file.Read(&TagCount,sizeof(short));
|
|
if (dwReadBytes != sizeof(short)) {
|
|
AfxMessageBox("Error reading Number of TIFF TAGS");
|
|
return 0;
|
|
}
|
|
dwCurrentFileOffset += dwReadBytes;
|
|
|
|
if (TagCount <=0) {
|
|
AfxMessageBox("Number of TIFF TAGS must be 1 or more..");
|
|
return 0;
|
|
}
|
|
|
|
TIFFTODIBDATA TiffToDIBData;
|
|
long tempOffset = 0;
|
|
int ValueCount = 0;
|
|
|
|
|
|
memset(&TiffToDIBData,0,sizeof(TIFFTODIBDATA));
|
|
for (int i = 1;i<=TagCount;i++) {
|
|
dwReadBytes = file.Read(&tTag,sizeof(TIFFTAG));
|
|
if (dwReadBytes != sizeof(TIFFTAG)) {
|
|
AfxMessageBox("Error reading TIFF TAGS");
|
|
return 0;
|
|
}
|
|
switch (tTag.ttTag) {
|
|
case TIFF_NEWSUBFILETYPE:
|
|
break;
|
|
case TIFF_IMAGEWIDTH:
|
|
TiffToDIBData.bmiHeader.biWidth = tTag.ttOffset;
|
|
break;
|
|
case TIFF_LENGTH:
|
|
TiffToDIBData.bmiHeader.biHeight = tTag.ttOffset;
|
|
break;
|
|
case TIFF_BITSPERSAMPLE:
|
|
if (tTag.ttCount == 3)
|
|
TiffToDIBData.bmiHeader.biBitCount = 24;
|
|
else
|
|
TiffToDIBData.bmiHeader.biBitCount = (unsigned short)tTag.ttOffset;
|
|
break;
|
|
case TIFF_COMPRESSION:
|
|
TiffToDIBData.CompressionType = tTag.ttOffset;
|
|
break;
|
|
case TIFF_PHOTOINTERP:
|
|
break;
|
|
case TIFF_IMAGEDESCRIPTION:
|
|
tempOffset = dwCurrentFileOffset;
|
|
file.Seek(tTag.ttOffset,CFile::begin);
|
|
file.Read(TiffToDIBData.Description,sizeof(tTag.ttCount));
|
|
file.Seek(tempOffset,CFile::begin);
|
|
break;
|
|
case TIFF_STRIPOFFSETS:
|
|
TiffToDIBData.StripOffsets = tTag.ttOffset;
|
|
TiffToDIBData.OffsetCount = tTag.ttCount;
|
|
TiffToDIBData.pStripOffsets = (long*)GlobalAlloc(GPTR,sizeof(long) * tTag.ttCount);
|
|
if (tTag.ttCount == 1) {
|
|
//
|
|
// we only have one huge strip
|
|
//
|
|
TiffToDIBData.pStripOffsets[0] = tTag.ttOffset;
|
|
} else {
|
|
//
|
|
// we have multiple strips
|
|
//
|
|
tempOffset = dwCurrentFileOffset;
|
|
file.Seek(tTag.ttOffset,CFile::begin);
|
|
file.Read(TiffToDIBData.pStripOffsets,sizeof(long) * tTag.ttCount);
|
|
file.Seek(tempOffset,CFile::begin);
|
|
}
|
|
break;
|
|
case TIFF_ORIENTATION:
|
|
break;
|
|
case TIFF_SAMPLESPERPIXEL:
|
|
break;
|
|
case TIFF_ROWSPERSTRIP:
|
|
TiffToDIBData.RowsPerStrip = tTag.ttOffset;
|
|
break;
|
|
case TIFF_STRIPBYTECOUNTS:
|
|
TiffToDIBData.StripByteCounts = tTag.ttOffset;
|
|
TiffToDIBData.pStripByteCountsOffsets = (long*)GlobalAlloc(GPTR,sizeof(long) * tTag.ttCount);
|
|
if (tTag.ttCount == 1) {
|
|
//
|
|
// we only have one huge strip
|
|
//
|
|
TiffToDIBData.pStripByteCountsOffsets[0] = tTag.ttOffset;
|
|
} else {
|
|
//
|
|
// we have multiple strips
|
|
//
|
|
tempOffset = dwCurrentFileOffset;
|
|
file.Seek(tTag.ttOffset,CFile::begin);
|
|
file.Read(TiffToDIBData.pStripByteCountsOffsets,sizeof(long) * tTag.ttCount);
|
|
file.Seek(tempOffset,CFile::begin);
|
|
}
|
|
break;
|
|
case TIFF_XRESOLUTION:
|
|
tempOffset = dwCurrentFileOffset;
|
|
file.Seek(tTag.ttOffset,CFile::begin);
|
|
file.Read(&TiffToDIBData.xResolution,sizeof(TIFFRATIONAL));
|
|
file.Seek(tempOffset,CFile::begin);
|
|
break;
|
|
case TIFF_YRESOLUTION:
|
|
tempOffset = dwCurrentFileOffset;
|
|
file.Seek(tTag.ttOffset,CFile::begin);
|
|
file.Read(&TiffToDIBData.yResolution,sizeof(TIFFRATIONAL));
|
|
file.Seek(tempOffset,CFile::begin);
|
|
break;
|
|
case TIFF_RESOLUTIONUNIT:
|
|
TiffToDIBData.ResolutionUnit = tTag.ttOffset;
|
|
break;
|
|
case TIFF_SOFTWARE:
|
|
tempOffset = dwCurrentFileOffset;
|
|
file.Seek(tTag.ttOffset,CFile::begin);
|
|
file.Read(TiffToDIBData.Software,sizeof(tTag.ttCount));
|
|
file.Seek(tempOffset,CFile::begin);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
dwCurrentFileOffset += dwReadBytes;
|
|
}
|
|
|
|
//
|
|
// read next Tagcount to see if there are more TAGS
|
|
//
|
|
dwReadBytes = file.Read(&TagCount,sizeof(short));
|
|
if (dwReadBytes != sizeof(short)) {
|
|
AfxMessageBox("Error reading Number of TIFF TAGS");
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// if there are more tags exit for now..
|
|
//
|
|
if (TagCount >0) {
|
|
//AfxMessageBox("There are more TIFF TAGS in this file");
|
|
//return;
|
|
}
|
|
|
|
//
|
|
// calculate the rest of the TiffToDIBData
|
|
//
|
|
int BytesPerPixel = 0;
|
|
//
|
|
// 8-bit DATA
|
|
//
|
|
if (TiffToDIBData.bmiHeader.biBitCount == 8) {
|
|
BytesPerPixel = 1;
|
|
if (TiffToDIBData.ColorsUsed == 0)
|
|
TiffToDIBData.bmiHeader.biClrUsed = 256;
|
|
else
|
|
TiffToDIBData.bmiHeader.biClrUsed = TiffToDIBData.ColorsUsed;
|
|
}
|
|
//
|
|
// 24-bit DATA
|
|
//
|
|
else if (TiffToDIBData.bmiHeader.biBitCount == 24) {
|
|
BytesPerPixel = 3;
|
|
TiffToDIBData.bmiHeader.biClrUsed = 0;
|
|
}
|
|
//
|
|
// 4-bit DATA
|
|
//
|
|
else if (TiffToDIBData.bmiHeader.biBitCount == 4) {
|
|
BytesPerPixel = 2;
|
|
TiffToDIBData.bmiHeader.biClrUsed = 256;
|
|
}
|
|
//
|
|
// 1-bit DATA
|
|
//
|
|
else {
|
|
BytesPerPixel = 0;
|
|
TiffToDIBData.bmiHeader.biClrUsed = 2;
|
|
}
|
|
TiffToDIBData.bmiHeader.biSizeImage = WIDTHBYTES((TiffToDIBData.bmiHeader.biWidth)*((DWORD)TiffToDIBData.bmiHeader.biBitCount)) * TiffToDIBData.bmiHeader.biHeight;
|
|
TiffToDIBData.bmiHeader.biPlanes = 1;
|
|
TiffToDIBData.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
//
|
|
// create Palette size if one exists
|
|
//
|
|
RGBQUAD* pPalette = NULL;
|
|
long PaletteSize = 0;
|
|
if (TiffToDIBData.bmiHeader.biClrUsed != 0) {
|
|
PaletteSize = TiffToDIBData.bmiHeader.biClrUsed * sizeof(RGBQUAD);
|
|
pPalette = (RGBQUAD*)GlobalAllocPtr(GHND, PaletteSize);
|
|
if (pPalette == NULL) {
|
|
AfxMessageBox("Failed to Create Palette");
|
|
return 0;
|
|
}
|
|
if (TiffToDIBData.bmiHeader.biBitCount == 8) {
|
|
if (TiffToDIBData.ColorsUsed == 0) {
|
|
//
|
|
// create a grayscale palette
|
|
//
|
|
for (int i = 0;i<(int)TiffToDIBData.bmiHeader.biClrUsed;i++) {
|
|
pPalette[i].rgbRed = (BYTE)i;
|
|
pPalette[i].rgbBlue = (BYTE)i;
|
|
pPalette[i].rgbGreen = (BYTE)i;
|
|
pPalette[i].rgbReserved = 0;
|
|
}
|
|
} else {
|
|
//
|
|
// create the color palette from colormap
|
|
//
|
|
TiffToDIBData.bmiHeader.biClrUsed = TiffToDIBData.ColorsUsed;
|
|
}
|
|
}
|
|
if (TiffToDIBData.bmiHeader.biBitCount == 1) {
|
|
//
|
|
// create a black and white palette
|
|
//
|
|
pPalette[0].rgbRed = 0;
|
|
pPalette[0].rgbBlue = 0;
|
|
pPalette[0].rgbGreen = 0;
|
|
pPalette[0].rgbReserved = 0;
|
|
|
|
pPalette[1].rgbRed = 255;
|
|
pPalette[1].rgbBlue = 255;
|
|
pPalette[1].rgbGreen = 255;
|
|
pPalette[1].rgbReserved = 255;
|
|
}
|
|
}
|
|
|
|
BITMAPFILEHEADER bmfHeader;
|
|
memset(&bmfHeader,0,sizeof(BITMAPFILEHEADER));
|
|
bmfHeader.bfType = DIB_HEADER_MARKER;
|
|
bmfHeader.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + PaletteSize + TiffToDIBData.bmiHeader.biSizeImage;
|
|
bmfHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER)+ PaletteSize;
|
|
|
|
// Allocate memory for DIB info header and possible palette
|
|
m_pBMI = (LPBITMAPINFO)GlobalAllocPtr(GHND, bmfHeader.bfOffBits-sizeof(BITMAPFILEHEADER) + (PaletteSize*2));
|
|
if (m_pBMI == 0)
|
|
return 0;
|
|
|
|
DWORD dwLength = file.GetLength();
|
|
m_pBits = (LPBYTE)GlobalAllocPtr(GHND, TiffToDIBData.bmiHeader.biSizeImage + PaletteSize);
|
|
if (m_pBits == 0) {
|
|
GlobalFreePtr(m_pBMI);
|
|
m_pBMI = NULL;
|
|
return 0;
|
|
}
|
|
BYTE* pData = m_pBits;
|
|
|
|
//
|
|
// set line width (DWORD aligned length)
|
|
//
|
|
long LineWidth = TiffToDIBData.bmiHeader.biSizeImage/TiffToDIBData.bmiHeader.biHeight;
|
|
|
|
DWORD ImageByteCount = 0;
|
|
for (i = 0;i < TiffToDIBData.OffsetCount;i++) {
|
|
//
|
|
// seek to strip
|
|
//
|
|
file.Seek(TiffToDIBData.pStripOffsets[i],CFile::begin);
|
|
//
|
|
// read strip data (numbytes from pStripBytesCounts.
|
|
//
|
|
file.ReadHuge(pData,TiffToDIBData.pStripByteCountsOffsets[i]);
|
|
pData += TiffToDIBData.pStripByteCountsOffsets[i];
|
|
ImageByteCount+= TiffToDIBData.pStripByteCountsOffsets[i];
|
|
}
|
|
BYTE ColorValue = 0;
|
|
int LineCount = 1;
|
|
pData = m_pBits;
|
|
|
|
//
|
|
// Swap Red and Blue values if the data is 24-BIT
|
|
//
|
|
|
|
if (TiffToDIBData.bmiHeader.biClrUsed == 0) {
|
|
for (LONG i = 0; i < (LONG)TiffToDIBData.bmiHeader.biSizeImage; i += 3) {
|
|
BYTE bTemp = pData[i];
|
|
pData[i] = pData[i + 2];
|
|
pData[i + 2] = bTemp;
|
|
}
|
|
}
|
|
|
|
// Write BITMAPINFOHEADER to member
|
|
memmove(m_pBMI,&TiffToDIBData.bmiHeader,sizeof(BITMAPINFOHEADER));
|
|
|
|
if (TiffToDIBData.bmiHeader.biClrUsed >0) {
|
|
memmove(m_pBMI->bmiColors,pPalette,PaletteSize);
|
|
}
|
|
|
|
if (TiffToDIBData.bmiHeader.biBitCount == 1)
|
|
LineWidth = (long)ceil((float)TiffToDIBData.bmiHeader.biWidth/8.0f);
|
|
else
|
|
LineWidth = TiffToDIBData.bmiHeader.biWidth * BytesPerPixel;
|
|
|
|
pData = m_pBits;
|
|
//
|
|
// check DWORD alignment of data
|
|
//
|
|
if ((LineWidth % sizeof(DWORD))) {
|
|
//
|
|
// Pad data
|
|
//
|
|
int PaddedBytes = sizeof(DWORD) - (LineWidth % sizeof(DWORD));
|
|
LineCount = 1;
|
|
BYTE* pCurrent = NULL;
|
|
BYTE* pDest = NULL;
|
|
for (LineCount = TiffToDIBData.bmiHeader.biHeight;LineCount > 1;LineCount--) {
|
|
pCurrent = pData + (LineWidth*(LineCount - 1));
|
|
pDest = pCurrent + (PaddedBytes*(LineCount - 1));
|
|
memmove(pDest,pCurrent,(LineWidth + PaddedBytes));
|
|
}
|
|
}
|
|
|
|
if (pPalette)
|
|
GlobalFreePtr(pPalette);
|
|
if (TiffToDIBData.pStripByteCountsOffsets != NULL)
|
|
GlobalFree(TiffToDIBData.pStripByteCountsOffsets);
|
|
if (TiffToDIBData.pStripOffsets != NULL)
|
|
GlobalFree(TiffToDIBData.pStripOffsets);
|
|
//
|
|
// flip the data because we are converting it
|
|
// to DIB form
|
|
//
|
|
Flip(m_pBits);
|
|
CreatePalette();
|
|
} else {
|
|
BITMAPFILEHEADER bmfHeader;
|
|
|
|
// Go read the DIB file header and check if it's valid.
|
|
if (file.Read((LPSTR)&bmfHeader, sizeof(bmfHeader)) != sizeof(bmfHeader))
|
|
return 0;
|
|
if (bmfHeader.bfType != DIB_HEADER_MARKER)
|
|
return 0;
|
|
dwReadBytes = sizeof(bmfHeader);
|
|
|
|
// Allocate memory for DIB info header and possible palette
|
|
m_pBMI = (LPBITMAPINFO)GlobalAllocPtr(GHND, bmfHeader.bfOffBits-sizeof(BITMAPFILEHEADER) + 256*sizeof(RGBQUAD));
|
|
if (m_pBMI == 0)
|
|
return 0;
|
|
|
|
// Read header.
|
|
if (file.Read(m_pBMI, bmfHeader.bfOffBits-sizeof(BITMAPFILEHEADER)) != (UINT)(bmfHeader.bfOffBits-sizeof(BITMAPFILEHEADER))) {
|
|
GlobalFreePtr(m_pBMI);
|
|
m_pBMI = NULL;
|
|
return 0;
|
|
}
|
|
dwReadBytes += bmfHeader.bfOffBits-sizeof(BITMAPFILEHEADER);
|
|
|
|
DWORD dwLength = file.GetLength();
|
|
// Go read the bits.
|
|
m_pBits = (LPBYTE)GlobalAllocPtr(GHND, dwLength - bmfHeader.bfOffBits);
|
|
if (m_pBits == 0) {
|
|
GlobalFreePtr(m_pBMI);
|
|
m_pBMI = NULL;
|
|
return 0;
|
|
}
|
|
|
|
if (file.ReadHuge(m_pBits, dwLength-bmfHeader.bfOffBits) != (dwLength - bmfHeader.bfOffBits)) {
|
|
GlobalFreePtr(m_pBMI);
|
|
m_pBMI = NULL;
|
|
GlobalFreePtr(m_pBits);
|
|
m_pBits = NULL;
|
|
return 0;
|
|
}
|
|
dwReadBytes += dwLength - bmfHeader.bfOffBits;
|
|
|
|
CreatePalette();
|
|
}
|
|
return dwReadBytes;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::ReadFromHGLOBAL()
|
|
*
|
|
* Reads a global chunk of memory into DIB form
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* hGlobal - Global block of memory
|
|
* FileType - BMP_IMAGE, TIFF_IMAGE
|
|
*
|
|
* Return Value:
|
|
*
|
|
* status
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
BOOL CDib::ReadFromHGLOBAL(HGLOBAL hGlobal,int FileType)
|
|
{
|
|
Free();
|
|
if (hGlobal == NULL)
|
|
return FALSE;
|
|
if (FileType == TIFF_IMAGE) {
|
|
LPBYTE pSrcDib = (LPBYTE)GlobalLock(hGlobal);
|
|
|
|
TIFFFILEHEADER* ptfHeader = NULL;
|
|
ptfHeader = (TIFFFILEHEADER*)pSrcDib;
|
|
LPBYTE pPtr = pSrcDib;
|
|
LPBYTE ptempPtr = NULL;
|
|
DWORD dwCurrentFileOffset = 0;
|
|
DWORD dwStripByteCountOffset = 0;
|
|
DWORD dwStripOffset = 0;
|
|
|
|
// TIFF variables
|
|
TIFFTAG tTag;
|
|
short TagCount = 0;
|
|
|
|
if (ptfHeader->tfType != 42) {
|
|
AfxMessageBox("Invalid TIFF format");
|
|
return 0;
|
|
}
|
|
|
|
if (ptfHeader->tfByteOrder[0] != 'I' && ptfHeader->tfByteOrder[1] != 'I') {
|
|
AfxMessageBox("Invalid TIFF format not 'II'");
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// move pointer to TAG offset
|
|
//
|
|
pPtr += ptfHeader->tfOffset;
|
|
|
|
memmove(&TagCount,pPtr,sizeof(short));
|
|
pPtr += sizeof(short);
|
|
|
|
if (TagCount <=0) {
|
|
AfxMessageBox("Number of TIFF TAGS must be 1 or more..");
|
|
return 0;
|
|
}
|
|
|
|
TIFFTODIBDATA TiffToDIBData;
|
|
long tempOffset = 0;
|
|
int ValueCount = 0;
|
|
|
|
memset(&TiffToDIBData,0,sizeof(TIFFTODIBDATA));
|
|
for (int i = 1;i<=TagCount;i++) {
|
|
memmove(&tTag,pPtr,sizeof(TIFFTAG));
|
|
pPtr += sizeof(TIFFTAG);
|
|
|
|
switch (tTag.ttTag) {
|
|
case TIFF_NEWSUBFILETYPE:
|
|
break;
|
|
case TIFF_IMAGEWIDTH:
|
|
TiffToDIBData.bmiHeader.biWidth = tTag.ttOffset;
|
|
break;
|
|
case TIFF_LENGTH:
|
|
TiffToDIBData.bmiHeader.biHeight = tTag.ttOffset;
|
|
break;
|
|
case TIFF_BITSPERSAMPLE:
|
|
if (tTag.ttCount == 3)
|
|
TiffToDIBData.bmiHeader.biBitCount = 24;
|
|
else
|
|
TiffToDIBData.bmiHeader.biBitCount = (unsigned short)tTag.ttOffset;
|
|
break;
|
|
case TIFF_COMPRESSION:
|
|
TiffToDIBData.CompressionType = tTag.ttOffset;
|
|
break;
|
|
case TIFF_PHOTOINTERP:
|
|
break;
|
|
case TIFF_IMAGEDESCRIPTION:
|
|
ptempPtr = pPtr; // save current pointer
|
|
pPtr = pSrcDib; // move pointer to start of data
|
|
pPtr += tTag.ttOffset; // seek to offset
|
|
memmove(TiffToDIBData.Description,pPtr,sizeof(tTag.ttCount)); // read data
|
|
pPtr = ptempPtr; // move pointer back to org. position
|
|
break;
|
|
case TIFF_STRIPOFFSETS:
|
|
TiffToDIBData.StripOffsets = tTag.ttOffset;
|
|
TiffToDIBData.OffsetCount = tTag.ttCount;
|
|
TiffToDIBData.pStripOffsets = (long*)GlobalAlloc(GPTR,sizeof(long) * tTag.ttCount);
|
|
if (tTag.ttCount == 1) {
|
|
//
|
|
// we only have one huge strip
|
|
//
|
|
TiffToDIBData.pStripOffsets[0] = tTag.ttOffset;
|
|
} else {
|
|
//
|
|
// we have multiple strips
|
|
//
|
|
ptempPtr = pPtr; // save current pointer
|
|
pPtr = pSrcDib; // move pointer to start of data
|
|
pPtr += tTag.ttOffset; // seek to offset
|
|
memmove(TiffToDIBData.pStripOffsets,pPtr,sizeof(long) * tTag.ttCount); // read data
|
|
pPtr = ptempPtr; // move pointer back to org. position
|
|
}
|
|
break;
|
|
case TIFF_ORIENTATION:
|
|
break;
|
|
case TIFF_SAMPLESPERPIXEL:
|
|
break;
|
|
case TIFF_ROWSPERSTRIP:
|
|
TiffToDIBData.RowsPerStrip = tTag.ttOffset;
|
|
break;
|
|
case TIFF_STRIPBYTECOUNTS:
|
|
TiffToDIBData.StripByteCounts = tTag.ttOffset;
|
|
TiffToDIBData.pStripByteCountsOffsets = (long*)GlobalAlloc(GPTR,sizeof(long) * tTag.ttCount);
|
|
if (tTag.ttCount == 1) {
|
|
//
|
|
// we only have one huge strip
|
|
//
|
|
TiffToDIBData.pStripByteCountsOffsets[0] = tTag.ttOffset;
|
|
} else {
|
|
//
|
|
// we have multiple strips
|
|
//
|
|
ptempPtr = pPtr; // save current pointer
|
|
pPtr = pSrcDib; // move pointer to start of data
|
|
pPtr += tTag.ttOffset; // seek to offset
|
|
memmove(TiffToDIBData.pStripByteCountsOffsets,pPtr,sizeof(long) * tTag.ttCount); // read data
|
|
pPtr = ptempPtr; // move pointer back to org. position
|
|
}
|
|
break;
|
|
case TIFF_XRESOLUTION:
|
|
ptempPtr = pPtr; // save current pointer
|
|
pPtr = pSrcDib; // move pointer to start of data
|
|
pPtr += tTag.ttOffset; // seek to offset
|
|
memmove(&TiffToDIBData.xResolution,pPtr,sizeof(TIFFRATIONAL)); // read data
|
|
pPtr = ptempPtr; // move pointer back to org. position
|
|
break;
|
|
case TIFF_YRESOLUTION:
|
|
ptempPtr = pPtr; // save current pointer
|
|
pPtr = pSrcDib; // move pointer to start of data
|
|
pPtr += tTag.ttOffset; // seek to offset
|
|
memmove(&TiffToDIBData.yResolution,pPtr,sizeof(TIFFRATIONAL)); // read data
|
|
pPtr = ptempPtr; // move pointer back to org. position
|
|
break;
|
|
case TIFF_RESOLUTIONUNIT:
|
|
TiffToDIBData.ResolutionUnit = tTag.ttOffset;
|
|
break;
|
|
case TIFF_SOFTWARE:
|
|
ptempPtr = pPtr; // save current pointer
|
|
pPtr = pSrcDib; // move pointer to start of data
|
|
pPtr += tTag.ttOffset; // seek to offset
|
|
memmove(TiffToDIBData.Software,pPtr,sizeof(tTag.ttCount)); // read data
|
|
pPtr = ptempPtr; // move pointer back to org. position
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// read next Tagcount to see if there are more TAGS
|
|
//
|
|
//dwReadBytes = file.Read(&TagCount,sizeof(short));
|
|
//if(dwReadBytes != sizeof(short))
|
|
//{
|
|
// AfxMessageBox("Error reading Number of TIFF TAGS");
|
|
// return 0;
|
|
//}
|
|
|
|
//
|
|
// if there are more tags exit for now..
|
|
//
|
|
//if(TagCount >0)
|
|
//{
|
|
//AfxMessageBox("There are more TIFF TAGS in this file");
|
|
//return;
|
|
//}
|
|
|
|
//
|
|
// calculate the rest of the TiffToDIBData
|
|
//
|
|
int BytesPerPixel = 0;
|
|
//
|
|
// 8-bit DATA
|
|
//
|
|
if (TiffToDIBData.bmiHeader.biBitCount == 8) {
|
|
BytesPerPixel = 1;
|
|
if (TiffToDIBData.ColorsUsed == 0)
|
|
TiffToDIBData.bmiHeader.biClrUsed = 256;
|
|
else
|
|
TiffToDIBData.bmiHeader.biClrUsed = TiffToDIBData.ColorsUsed;
|
|
}
|
|
//
|
|
// 24-bit DATA
|
|
//
|
|
else if (TiffToDIBData.bmiHeader.biBitCount == 24) {
|
|
BytesPerPixel = 3;
|
|
TiffToDIBData.bmiHeader.biClrUsed = 0;
|
|
}
|
|
//
|
|
// 4-bit DATA
|
|
//
|
|
else if (TiffToDIBData.bmiHeader.biBitCount == 4) {
|
|
BytesPerPixel = 2;
|
|
TiffToDIBData.bmiHeader.biClrUsed = 256;
|
|
}
|
|
//
|
|
// 1-bit DATA
|
|
//
|
|
else {
|
|
BytesPerPixel = 0;
|
|
TiffToDIBData.bmiHeader.biClrUsed = 2;
|
|
}
|
|
TiffToDIBData.bmiHeader.biSizeImage = WIDTHBYTES((TiffToDIBData.bmiHeader.biWidth)*((DWORD)TiffToDIBData.bmiHeader.biBitCount)) * TiffToDIBData.bmiHeader.biHeight;
|
|
TiffToDIBData.bmiHeader.biPlanes = 1;
|
|
TiffToDIBData.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
//
|
|
// create Palette size if one exists
|
|
//
|
|
RGBQUAD* pPalette = NULL;
|
|
long PaletteSize = 0;
|
|
if (TiffToDIBData.bmiHeader.biClrUsed != 0) {
|
|
PaletteSize = TiffToDIBData.bmiHeader.biClrUsed * sizeof(RGBQUAD);
|
|
pPalette = (RGBQUAD*)GlobalAllocPtr(GHND, PaletteSize);
|
|
if (pPalette == NULL) {
|
|
AfxMessageBox("Failed to Create Palette");
|
|
return 0;
|
|
}
|
|
if (TiffToDIBData.bmiHeader.biBitCount == 8) {
|
|
if (TiffToDIBData.ColorsUsed == 0) {
|
|
//
|
|
// create a grayscale palette
|
|
//
|
|
for (int i = 0;i<(int)TiffToDIBData.bmiHeader.biClrUsed;i++) {
|
|
pPalette[i].rgbRed = (BYTE)i;
|
|
pPalette[i].rgbBlue = (BYTE)i;
|
|
pPalette[i].rgbGreen = (BYTE)i;
|
|
pPalette[i].rgbReserved = 0;
|
|
}
|
|
} else {
|
|
//
|
|
// create the color palette from colormap
|
|
//
|
|
TiffToDIBData.bmiHeader.biClrUsed = TiffToDIBData.ColorsUsed;
|
|
}
|
|
}
|
|
if (TiffToDIBData.bmiHeader.biBitCount == 1) {
|
|
//
|
|
// create a black and white palette
|
|
//
|
|
pPalette[0].rgbRed = 0;
|
|
pPalette[0].rgbBlue = 0;
|
|
pPalette[0].rgbGreen = 0;
|
|
pPalette[0].rgbReserved = 0;
|
|
|
|
pPalette[1].rgbRed = 255;
|
|
pPalette[1].rgbBlue = 255;
|
|
pPalette[1].rgbGreen = 255;
|
|
pPalette[1].rgbReserved = 255;
|
|
}
|
|
}
|
|
|
|
BITMAPFILEHEADER bmfHeader;
|
|
memset(&bmfHeader,0,sizeof(BITMAPFILEHEADER));
|
|
bmfHeader.bfType = DIB_HEADER_MARKER;
|
|
bmfHeader.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + PaletteSize + TiffToDIBData.bmiHeader.biSizeImage;
|
|
bmfHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER)+ PaletteSize;
|
|
|
|
// Allocate memory for DIB info header and possible palette
|
|
m_pBMI = (LPBITMAPINFO)GlobalAllocPtr(GHND, bmfHeader.bfOffBits-sizeof(BITMAPFILEHEADER) + (PaletteSize*2));
|
|
if (m_pBMI == 0)
|
|
return 0;
|
|
|
|
m_pBits = (LPBYTE)GlobalAllocPtr(GHND, TiffToDIBData.bmiHeader.biSizeImage + PaletteSize);
|
|
if (m_pBits == 0) {
|
|
GlobalFreePtr(m_pBMI);
|
|
m_pBMI = NULL;
|
|
return 0;
|
|
}
|
|
BYTE* pData = m_pBits;
|
|
|
|
//
|
|
// set line width (DWORD aligned length)
|
|
//
|
|
long LineWidth = TiffToDIBData.bmiHeader.biSizeImage/TiffToDIBData.bmiHeader.biHeight;
|
|
|
|
DWORD ImageByteCount = 0;
|
|
for (i = 0;i < TiffToDIBData.OffsetCount;i++) {
|
|
//
|
|
// seek to strip
|
|
//
|
|
pPtr = pSrcDib; // move pointer to start of data
|
|
pPtr += TiffToDIBData.pStripOffsets[i]; // seek to offset
|
|
//
|
|
// read strip data (numbytes from pStripBytesCounts.
|
|
//
|
|
CopyMemory(pData,pPtr,TiffToDIBData.pStripByteCountsOffsets[i]); // read data
|
|
|
|
pData += TiffToDIBData.pStripByteCountsOffsets[i];
|
|
ImageByteCount+= TiffToDIBData.pStripByteCountsOffsets[i];
|
|
}
|
|
BYTE ColorValue = 0;
|
|
int LineCount = 1;
|
|
pData = m_pBits;
|
|
|
|
if (TiffToDIBData.bmiHeader.biClrUsed ==0) {
|
|
while (LineCount <= TiffToDIBData.bmiHeader.biHeight) {
|
|
//
|
|
// swap red and blue values
|
|
// if the data is 24-bit
|
|
//
|
|
for (int i = 0;i<LineWidth;i+=3) {
|
|
ColorValue = pData[i];
|
|
pData[i] = pData[i+2];
|
|
pData[i+2] = ColorValue;
|
|
}
|
|
|
|
pData += LineWidth;
|
|
LineCount++;
|
|
}
|
|
}
|
|
|
|
// Write BITMAPINFOHEADER to member
|
|
memmove(m_pBMI,&TiffToDIBData.bmiHeader,sizeof(BITMAPINFOHEADER));
|
|
|
|
if (TiffToDIBData.bmiHeader.biClrUsed >0) {
|
|
memmove(m_pBMI->bmiColors,pPalette,PaletteSize);
|
|
}
|
|
|
|
if (TiffToDIBData.bmiHeader.biBitCount == 1)
|
|
LineWidth = (long)ceil((float)TiffToDIBData.bmiHeader.biWidth/8.0f);
|
|
else
|
|
LineWidth = TiffToDIBData.bmiHeader.biWidth * BytesPerPixel;
|
|
|
|
pData = m_pBits;
|
|
//
|
|
// check DWORD alignment of data
|
|
//
|
|
if ((LineWidth % sizeof(DWORD))) {
|
|
//
|
|
// Pad data
|
|
//
|
|
int PaddedBytes = sizeof(DWORD) - (LineWidth % sizeof(DWORD));
|
|
LineCount = 1;
|
|
BYTE* pCurrent = NULL;
|
|
BYTE* pDest = NULL;
|
|
for (LineCount = TiffToDIBData.bmiHeader.biHeight;LineCount > 1;LineCount--) {
|
|
pCurrent = pData + (LineWidth*(LineCount - 1));
|
|
pDest = pCurrent + (PaddedBytes*(LineCount - 1));
|
|
memmove(pDest,pCurrent,(LineWidth + PaddedBytes));
|
|
}
|
|
}
|
|
|
|
if (pPalette)
|
|
GlobalFreePtr(pPalette);
|
|
if (TiffToDIBData.pStripByteCountsOffsets != NULL)
|
|
GlobalFree(TiffToDIBData.pStripByteCountsOffsets);
|
|
if (TiffToDIBData.pStripOffsets != NULL)
|
|
GlobalFree(TiffToDIBData.pStripOffsets);
|
|
//
|
|
// flip the data because we are converting it
|
|
// to DIB form
|
|
//
|
|
Flip(m_pBits);
|
|
CreatePalette();
|
|
|
|
} else {
|
|
BOOL bTopDown = FALSE;
|
|
LPBYTE pSrcDib = (LPBYTE)GlobalLock(hGlobal);
|
|
LPBITMAPINFO pbmi = NULL;
|
|
pbmi = (LPBITMAPINFO)pSrcDib;
|
|
|
|
// Allocate memory for DIB
|
|
m_pBMI = (LPBITMAPINFO)GlobalAllocPtr(GHND, (sizeof(BITMAPINFO) + pbmi->bmiHeader.biClrUsed * sizeof(RGBQUAD)));
|
|
if (m_pBMI == 0)
|
|
return 0;
|
|
|
|
// copy header.
|
|
memmove(m_pBMI,pbmi,(sizeof(BITMAPINFO) + pbmi->bmiHeader.biClrUsed * sizeof(RGBQUAD)));
|
|
|
|
DWORD dwLength = m_pBMI->bmiHeader.biSizeImage;
|
|
|
|
// if a TOP_DOWN_DIB comes in..adjust it to be displayed
|
|
// this is not a normal thing to do here. It is only so that the
|
|
// image can be displayed for debug reasons.
|
|
if (m_pBMI->bmiHeader.biHeight < 1) {
|
|
bTopDown = TRUE;
|
|
m_pBMI->bmiHeader.biHeight = -m_pBMI->bmiHeader.biHeight;
|
|
}
|
|
|
|
// Alloc memory for bits
|
|
m_pBits = (LPBYTE)GlobalAllocPtr(GHND, dwLength);
|
|
if (m_pBits == 0) {
|
|
GlobalFreePtr(m_pBMI);
|
|
m_pBMI = NULL;
|
|
return 0;
|
|
}
|
|
// move pointer past BITMAPINFOHEADER to bits
|
|
pSrcDib+=sizeof(BITMAPINFOHEADER);
|
|
pSrcDib+=(m_pBMI->bmiHeader.biClrUsed * sizeof(RGBQUAD));
|
|
|
|
if (bTopDown) {
|
|
// flip bitmap and copy bits
|
|
Flip(pSrcDib);
|
|
memmove(m_pBits,pSrcDib,dwLength);
|
|
} else
|
|
// copy bits
|
|
memmove(m_pBits,pSrcDib,dwLength);
|
|
|
|
CreatePalette();
|
|
GlobalUnlock(hGlobal);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::GotImage()
|
|
*
|
|
* Check DIB to see is memory has been allocated and used.
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* none
|
|
*
|
|
* Return Value:
|
|
*
|
|
* status
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
BOOL CDib::GotImage()
|
|
{
|
|
// Make sure all member data that might have been allocated exist.
|
|
if (m_pBits)
|
|
if (m_pBMI)
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::ReadFromBMPFile()
|
|
*
|
|
* Opens and Reads data from a BMP file into DIB form
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* LPSTR- filename (Filename to be opened and read)
|
|
*
|
|
* Return Value:
|
|
*
|
|
* void
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
|
|
void CDib::ReadFromBMPFile(LPSTR filename)
|
|
{
|
|
CFile ImageFile;
|
|
// open & read image file
|
|
ImageFile.Open(filename,CFile::modeRead,NULL);
|
|
Read(ImageFile,BMP_IMAGE);
|
|
// close image file
|
|
ImageFile.Close();
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::ReadFromBMPFile()
|
|
*
|
|
* Opens and Reads data from a BMP file into DIB form
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* CString- filename (Filename to be opened and read)
|
|
*
|
|
* Return Value:
|
|
*
|
|
* void
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
void CDib::ReadFromBMPFile(CString filename)
|
|
{
|
|
CFile ImageFile;
|
|
// open & read image file
|
|
ImageFile.Open(filename,CFile::modeRead,NULL);
|
|
Read(ImageFile,BMP_IMAGE);
|
|
// close image file
|
|
ImageFile.Close();
|
|
}
|
|
/**************************************************************************\
|
|
* CDib::ReadFromTIFFFile()
|
|
*
|
|
* Opens and Reads data from a TIFF file into DIB form
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* CString- filename (Filename to be opened and read)
|
|
*
|
|
* Return Value:
|
|
*
|
|
* void
|
|
*
|
|
* History:
|
|
*
|
|
* 4/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
void CDib::ReadFromTIFFFile(CString filename)
|
|
{
|
|
CFile ImageFile;
|
|
// open & read image file
|
|
ImageFile.Open(filename,CFile::modeRead,NULL);
|
|
|
|
Read(ImageFile,TIFF_IMAGE);
|
|
// close image file
|
|
ImageFile.Close();
|
|
}
|
|
/**************************************************************************\
|
|
* CDib::Flip()
|
|
*
|
|
* Flips a DIB, TOPDOWN to DIB conversion
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* pSrcData - TOPDOWN DIB to be flipped
|
|
*
|
|
* Return Value:
|
|
*
|
|
* status
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
BOOL CDib::Flip(BYTE* pSrcData)
|
|
{
|
|
LONG Width = 0;
|
|
LONG Height = 0;
|
|
LONG Linelength = 0;
|
|
LONG BitCount = 0;
|
|
|
|
Width = m_pBMI->bmiHeader.biWidth;
|
|
Height = m_pBMI->bmiHeader.biHeight;
|
|
BitCount = m_pBMI->bmiHeader.biBitCount;
|
|
|
|
Linelength = (((Width*BitCount+31)/32)*4);
|
|
|
|
LONG nLineWidthInBytes = Linelength;
|
|
PBYTE pLine = new BYTE[nLineWidthInBytes];
|
|
for (int i=0;i<Height/2;i++) {
|
|
PBYTE pSrc = pSrcData + (i * nLineWidthInBytes);
|
|
PBYTE pDst = pSrcData + ((Height-i-1) * nLineWidthInBytes);
|
|
CopyMemory( pLine, pSrc, nLineWidthInBytes );
|
|
CopyMemory( pSrc, pDst, nLineWidthInBytes );
|
|
CopyMemory( pDst, pLine, nLineWidthInBytes );
|
|
}
|
|
delete[] pLine;
|
|
return TRUE;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* CDib::Dump(), CopyToHandle(), ReadFromHandle(), and Serialize()
|
|
*
|
|
* Misc. member functions that are not used at this time
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
* -
|
|
*
|
|
* Return Value:
|
|
*
|
|
* -
|
|
*
|
|
* History:
|
|
*
|
|
* 2/14/1999 Original Version
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#ifdef _DEBUG
|
|
// Dump
|
|
void CDib::Dump(CDumpContext& dc) const
|
|
{
|
|
CObject::Dump(dc);
|
|
}
|
|
#endif
|
|
|
|
// CopyToHandle
|
|
HGLOBAL CDib::CopyToHandle() const
|
|
{
|
|
CSharedFile file;
|
|
try {
|
|
if (Save(file)==0)
|
|
return 0;
|
|
} catch (CFileException* e) {
|
|
e->Delete();
|
|
return 0;
|
|
}
|
|
|
|
return file.Detach();
|
|
}
|
|
|
|
// ReadFromHandle
|
|
DWORD CDib::ReadFromHandle(HGLOBAL hGlobal)
|
|
{
|
|
CSharedFile file;
|
|
file.SetHandle(hGlobal, FALSE);
|
|
DWORD dwResult = Read(file,BMP_IMAGE);
|
|
file.Detach();
|
|
return dwResult;
|
|
}
|
|
|
|
// Serialize
|
|
void CDib::Serialize(CArchive& ar)
|
|
{
|
|
CFile* pFile = ar.GetFile();
|
|
ASSERT(pFile != NULL);
|
|
if (ar.IsStoring()) { // storing code
|
|
Save(*pFile);
|
|
} else { // loading code
|
|
Read(*pFile,BMP_IMAGE);
|
|
}
|
|
}
|
|
|
|
|