DIBUtil Class Reference

Contains static functions for handy DIB manipulation. Never instantiate one of these. That would be silly. More...

#include <dibutil.h>

List of all members.

Static Public Member Functions
static UINT32	ScanlineSize (UINT32 Width, UINT32 Depth)
	Used in calculating bitmap memory requirements. Based on Gavin's code in GDraw_SetDIBitmap, which it had better agree with!
static UINT32	ScanlineBytes (UINT32 Width, UINT32 Depth)
	Used in calculating offsets along scanlines. NOTE! Differs from ScanlineSize in that it DOES NOT word align the result!!!
static BOOL	PlotDeepDIB (wxDC *phDC, LPBITMAPINFO lpBitmapInfo, LPBYTE lpBits, INT32, INT32, INT32, INT32, INT32, INT32, BitmapConvertHint, HPALETTE=NULL)
	Plot a deep DIB on a device which does not understand deep DIBs. Works by converting to a 24-bit DIB in slices. The DIB must be using the 'standard' RGB arrangements. If this is called on a non-True Colour device then it will take a very very long time, as 24->8 GDI conversions are terribly slow, unless CONVHINT_SCREEN8/4 is used.
static BOOL	CanReadFromFile (const BitmapInfo *pInfo)
	To check to see if a .bmp file can be read into memory using ReadFromFile. At present, ReadFromFile only likes 8- & 24- & 32-bit BMPs and so we must tell the caller that this is the case. This is for the old OS/2 1.0 style BMPs. Scope: Static.
static BOOL	CanReadFromFile (const LPBITMAPCOREHEADER pCoreHeader)
	To check to see if a .bmp file can be read into memory using ReadFromFile. At present, ReadFromFile only likes 8- & 24- & 32-bit BMPs and so we must tell the caller that this is the case. This is for the old OS/2 1.0 style BMPs. Scope: Static.
static BOOL	CanReadFromFile (const LPBITMAPINFOHEADER pInfoHeader)
	To check to see if a .bmp file can be read into memory using ReadFromFile. At present, ReadFromFile only likes 8- & 24- & 32-bit BMPs and so we must tell the caller that this is the case. This is for the Win 3.0+ style BMPs. Scope: Static.
static BOOL	ReadFromFile (CCLexFile *, LPBITMAPINFO *Info, LPBYTE *Bits, BOOL=TRUE, String_64 *ProgressString=NULL, BaseCamelotFilter *pFilter=NULL)
	Read a .bmp file into memory. ONLY READS 8- & 24- & 32-bit BMPs currently***. Errors on 16-bit builds*** A progress hourglass can be shown if required.
static BOOL	WriteToFile (CCLexFile *, LPBITMAPINFO Info, LPBYTE Bits, String_64 *ProgressString=NULL, BOOL WriteHeader=TRUE, BaseCamelotFilter *pFilter=NULL)
	Write a bitmap in memory straight out to file with now rendering or conversion. Errors on 16-bit builds*** A progress hourglass can be shown if required. This function is used by the save bitmap button on the bitmap gallery. All other bitmap export uses the OutputDIB class instead as this copes with using a render region and converting from 32 to the destination format. (caller should close file).
static BOOL	WriteToFile (CCLexFile *, LPBYTE Bits, UINT32 Width, UINT32 Height, UINT32 Depth, String_64 *ProgressString=NULL)
	Generates a BITMAPINFO structor and then saves out the DIB.
static void	Convert16to24 (INT32 PixelWidth, LPBYTE InputBits, LPBYTE OutputBits)
static void	Convert32to24 (INT32 PixelWidth, LPBYTE InputBits, LPBYTE OutputBits)
static void	Convert32to24Alpha (INT32 PixelWidth, LPBYTE InputBits, LPBYTE OutputBits, COLORREF Colour)
static void	Convert32to32 (INT32 PixelWidth, LPBYTE InputBits, LPBYTE OutputBits)
static void	Convert8to8 (INT32 PixelWidth, LPBYTE InputBits, LPBYTE OutputBits)
static HPALETTE	MakeIdentityPalette (PALETTEENTRY aRGB[], INT32 nColors)
static BitmapConvertHint	CalcConvertHint (DWORD ScreenBPP, wxDC *pTestHDC)
	Determines RGB arrangements for 15/16-bit devices which is needed during dithering in those modes. User is responsible for preserving the state of the pixel at 0,0 if required. Returns CONVHINT_NONE if an error occurs.
static DWORD	GetGavinBlitFormat (DWORD ScreenBPP, DWORD BitmapBPP, BitmapConvertHint ScreenHint)
	Determines, from the given inputs, what number should be passed to Gavin routines SetSolidColour and SetUpBitmap (the BPP and BitmapFormat params) in order to get the best possible result (and/or to ensure no dithering occurs). Generally, this is only needed in 16bpp screen modes, but may be called at any time, as it returns safe defaults if not in 16bpp.
static BOOL	MakeTransparentBitmap (LPBITMAPINFO pPseudoColourInfo, LPBYTE pPseudoColourBits, LPBITMAPINFO pMonochromeInfo, LPBYTE pMonochromeBits, const BYTE TransCol)
	Applies the monochrome bitmap as a mask to a bitmap, setting pixels in the to the image to the TransColour if the equivelent pixel in the mask is not set.
static BOOL	MakeBitmapMask (LPBITMAPINFO pPseudoColourInfo, LPBYTE pPseudoColourBits, LPBITMAPINFO pMonochromeInfo, LPBYTE pMonochromeBits, const BYTE TransCol)
	Makes the monochrome bitmap (created with) into a mask for displaying the Pseudocolour bitmap. The mask must be 8bpp instead of the implied of 1bpp as applying it as a transparency requires this.
static BOOL	MakeBitmapSmaller (UINT32 OldWidth, UINT32 OldHeight, UINT32 BaseX, UINT32 BaseY, UINT32 NewWidth, UINT32 NewHeight, UINT32 BPP, LPBYTE pBits)
	Resizes a bitmap.
static BOOL	Init ()
	Reads our prefs.
static UINT32	CalcPaletteSize (UINT32 Depth, bool bUsingBitFields, UINT32 UsedColours=0)
static BOOL	CopyBitmap (LPBITMAPINFO pSourceInfo, LPBYTE pSourceBits, LPBITMAPINFO *pDestInfo, LPBYTE *pDestBits)
static BOOL	CopyEntireBitmap (LPBITMAPINFO pSourceInfo, LPBYTE pSourceBits, LPBITMAPINFO *pDestInfo, LPBYTE *pDestBits)
	Allocates a new DIB information header block and bits data and copies the source bitmap data across to the new bitmap. At present, just copies the actual bits data, the header will be the defaults plus width, height and colour depth. Not interested in the palette and other information stored in the bitmap info header. Same as CopyBitmap but actually copies the rest of the data as well. This includes:- Palette information Header information Bits information.
static BOOL	CopyPalette (LPRGBQUAD pSourcePalette, LPRGBQUAD pDestPalette, UINT32 NumberOfColours)
	Copy a palette from a bitmap which has been duplicated and so has the same colour depth and number of palette entries, to a destination bitmap. Assumes palettes already allocated as part of the duplication process.
static KernelBitmap *	CopyKernelBitmap (KernelBitmap *pKernelBitmap, BOOL IsTemp=FALSE)
	Allocates a new CWxBitmap and KernelBitmap pointing to it. Note these are completely new versions containing the same data as the old ones.
static BOOL	CountColoursUsed (BITMAPINFO *pInfo, BYTE *pBits, UINT32 **pResultsArray)
	Counts the usage for each palette index in the bitmap. NOTE: Caller is responsible for CCFreeing the results array.
static INT32	FindLeastUsedColour (BITMAPINFO *pInfo, UINT32 *pResultsArray)
	Takes the results from DIBUtil::CountColoursUsed and works out which colour is the best one to use as a transparent colour by finding the least used. NOTE: Caller is responsible for CCFreeing the results array.
static BOOL	CopyBitmapSection (LPBITMAPINFO pSourceInfo, LPBYTE pSourceBits, LPBITMAPINFO pDestInfo, LPBYTE pDestBits, INT32 SourceTop, INT32 SourceLeft)
	To copy a section of the source bitmap to the destination. Note that unlike the other copy functions in this file the destination header must in not allocated so you must do it yourself. Likewise palette info.
static BOOL	Optimal4bppPaletteInitialise_1stPass ()
static BOOL	Optimal4bppPaletteInitialise_2ndPass ()
static BOOL	GenOptimal4bppPaletteStats_1stPass (RGBQUAD *pBitmap, size_t Size)
static BOOL	GenOptimal4bppPaletteStats_2ndPass (RGBQUAD *pBitmap, size_t Size)
static BOOL	GenOptimal4bppPalette (PLOGPALETTE pPalette, const size_t MaxColours)
static size_t	GetOptimal8bppPaletteWorkspaceSize ()
static BOOL	Optimal8bppPaletteInitialise (INT32 *Stats)
static BOOL	GenOptimal8bppPaletteStats (INT32 *Stats, RGBQUAD *pBitmap, size_t Size)
static BOOL	GenOptimal8bppPalette (INT32 *Stats, PLOGPALETTE pPalette, const size_t MaxColours)
static size_t	GetOptimalPaletteWorkspaceSize ()
	Returns size of workspace required by optimal palette routines.
static BOOL	OptimalPaletteInitialise (void *Stats)
	Initialises workspace required by optimal palette routines. Stats should have INT32 size of GetOptimalPaletteWorkspaceSize().
static BOOL	ExactPaletteInitialise (LPLOGPALETTE pExactPalette)
static BOOL	GenOptimalPaletteStats (void *Stats, RGBQUAD *pBitmap, size_t Size)
	The purpose of this function is to build a table of statistics about one or more bitmaps prior to calling GenOptimalPalette.
static BOOL	GenOptimalPalette (void *Stats, PLOGPALETTE pPalette, const size_t MaxColours)
	The purpose of this function is to generate an optimal palette suitable for the bitmaps for which statistics have previously been generated.
static BOOL	GenGreyscalePalette (LPRGBQUAD lpPalette, const size_t PaletteSize)
	Generate a greyscale palette for a greyscale DIB.
static BOOL	Convert24to8 (LPBITMAPINFO pSourceInfo, LPBYTE pSourceBits, LPBITMAPINFO *pDestInfo, LPBYTE *pDestBits, RGBTRIPLE *pPalette, UINT32 NumberOfPaletteEntries)
	Generate an 8 bit form of a bitmap from a 24 bit form using the given palette.
static BOOL	Convert32to8 (LPBITMAPINFO pSourceInfo, LPBYTE pSourceBits, LPBITMAPINFO *pDestInfo, LPBYTE *pDestBits, RGBTRIPLE *pPalette, UINT32 NumberOfPaletteEntries)
	Generate an 8 bit form of a bitmap from a 32 bit form using the given palette.
static BOOL	Convert8to32 (LPBITMAPINFO pSourceInfo, LPBYTE pSourceBits, RGBQUAD *pPalette, LPBITMAPINFO pDestInfo, LPBYTE pDestBits)
	Generates a 32bit form of the input 8bit bitmap, note that the destination bitmapinfo and bitmap must be allocated prior to this function.
static OILBitmap *	Create8bppGreyscaleBitmap (KernelBitmap *pSrcBitmap)
	Designed to be used to create an 8bpp greyscale bitmap from a 24bpp, 4bpp or 1bpp bitmaps.
static BOOL	ConvertTo8Greyscale (LPBITMAPINFO pSourceInfo, LPBYTE pSourceBits, LPBITMAPINFO *ppDestInfo, LPBYTE *ppDestBits)
	Generates an 8bpp greyscale bitmap from the given 1bpp, 4bpp or 8bpp bitmap.
static BOOL	GenGreyscalePaletteTriple (RGBTRIPLE *pPalette, const size_t PaletteSize)
	Generate a packed greyscale palette for a greyscale DIB.
static BOOL	GenerateDifferenceBitmap (LPBITMAPINFO pPreviousInfo, LPBYTE pPreviousBits, LPBITMAPINFO pCurrentInfo, LPBYTE pCurrentBits, LPBITMAPINFO *ppDestInfo, LPBYTE *ppDestBits, INT32 TransColour, BOOL *pFoundBadOverlay=NULL)
static BOOL	GenerateSubRegionBitmap (LPBITMAPINFO pSourceInfo, LPBYTE pSourceBits, LPBITMAPINFO *ppDestInfo, LPBYTE *ppDestBits, INT32 TransColour, UINT32 *pLeftOffset, UINT32 *pTopOffset)
static LPLOGPALETTE	AllocateLogPalette (const UINT32 PaletteSize)
	To allocate a LOGPALETTE ready for use. The caller is responsible for cleaning up the memmory allocation.
static LPLOGPALETTE	CopyBitmapPaletteIntoLogPalette (KernelBitmap *pBitmap)
	To allocate a LOGPALETTE and then copy the palette from inside the bitmap across to the LOGPALETTE. The caller is responsible for cleaning up the memmory allocation.
static BOOL	IsGreyscaleBitmap (KernelBitmap *pKB)
	Determines whether or not a bitmap is 32bpp.
static BOOL	IsGreyscaleBitmap (OILBitmap *pOilBmp)
	Determines whether or not a bitmap is 32bpp.
static BOOL	CalculateNumberOfColoursInBitmap (LPLOGPALETTE pExactPalette, RGBQUAD *pBitmap, size_t Size)
static void	InvertAlpha (LPBITMAPINFO lpBitmapInfo, LPBYTE lpBits)
	Camelot uses a different transparency scheme to the rest of the world, in that 255 is clear, and 0 is opaque. Until the rest of the world catches up, it's necessary to invert the alpha channel to make exported files compatible with other programs.
static void	MakeAlphaIntoGreyscale (LPBITMAPINFO lpBitmapInfo, LPBYTE lpBits)
	Camelot uses a different transparency scheme to the rest of the world, in that 255 is clear, and 0 is opaque. Until the rest of the world catches up, it's necessary to invert the alpha channel to make exported files compatible with other programs.

---

Detailed Description

Contains static functions for handy DIB manipulation. Never instantiate one of these. That would be silly.

Author:

Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com>

Date:

9/6/94

Definition at line 164 of file dibutil.h.

---

Member Function Documentation

LPLOGPALETTE DIBUtil::AllocateLogPalette (  const UINT32  PaletteSize  )  [static]

To allocate a LOGPALETTE ready for use. The caller is responsible for cleaning up the memmory allocation. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 03/07/97 Parameters: The  number of entries in the palette [INPUTS] Returns: A pointer to the allocated LOGPALETTE or null. Definition at line 4681 of file dibutil.cpp. { ERROR2IF(PaletteSize == 0 || PaletteSize > 256,NULL,"AllocateLogPalette Bad PaletteSize"); LPLOGPALETTE pPalette = NULL; const size_t TotalPal = sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * PaletteSize ); pPalette = (LPLOGPALETTE)CCMalloc( TotalPal ); if (pPalette == NULL) return NULL; pPalette->palNumEntries = PaletteSize; pPalette->palVersion = 0x300; return pPalette; }

BitmapConvertHint DIBUtil::CalcConvertHint (  DWORD  ScreenBPP, wxDC *  pDC )  [static]

Determines RGB arrangements for 15/16-bit devices which is needed during dithering in those modes. User is responsible for preserving the state of the pixel at 0,0 if required. Returns CONVHINT_NONE if an error occurs. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (Rewrote Andy's original function) Date: 4/7/95 (21/2/95) Parameters: ScreenBPP  - Indicates the output BPP for which the hint is required [INPUTS] hDC - should be a device that supports SetPixel. (May be NULL if ScreenBPP is less than 16) Returns: Suitable value for hinting in bitmap conversions. (CONVHINT_SCREEN4 or _SCREEN8, or any of the 16 or 24 bit CONVHINT_FINAL? values) See also: BitmapConvertHint; DIBUtil::GetGavinBlitFormat Definition at line 2038 of file dibutil.cpp. { switch(ScreenBPP) { case 4: return(CONVHINT_SCREEN4); case 8: return(CONVHINT_SCREEN8); case 16: case 24: case 32: // Drop through to the code below to determine a proper 16/24bpp hint // (Note: Some cards say they are 24bpp when in fact they're 16bpp, so we must // do this for both values) break; default: ERROR2(CONVHINT_NONE, "Unknown output screen BPP"); } // Writes all 256 values to each gun, and counts the number of different values which are // returned - i.e. a 5 bit gun cannot return more than 32 values BYTE LastValue[3] = {0, 0, 0}; BYTE Count[3] = {0, 0, 0}; wxMemoryDC memdc; wxBitmap bitmap( 1, 1 ); memdc.SelectObject( bitmap ); for ( UINT32 Value=0x00; Value<0x100; Value++ ) { wxColour colour; memdc.SetPen(wxPen(wxColour(Value,Value,Value))); memdc.DrawPoint(0,0); memdc.GetPixel(0,0,&colour); if ( colour.Red()!=LastValue[0] ) { LastValue[0] = colour.Red(); Count[0]++; } if ( colour.Green()!=LastValue[1] ) { LastValue[1] = colour.Green(); Count[1]++; } if ( colour.Blue()!=LastValue[2] ) { LastValue[2] = colour.Blue(); Count[2]++; } } memdc.SelectObject( wxNullBitmap ); // Now determine how many bits would be needed to store the number of values we generated // for each gun. Note that this code will return (eg) 5 bits for all values between 17-32 inclusive for (INT32 Gun = 0; Gun < 3; Gun++) { INT32 BitPos = 0; while (Count[Gun] > 0) { BitPos++; Count[Gun] /= 2; } Count[Gun] = BitPos; } TRACEALL( wxT("16bpp RGB gun configuration auto-detected as %ld.%ld.%ld\n"), Count[0], Count[1], Count[2]); // OK. Now determine the enum constant which represents this configuration (if any) switch(Count[0]) { case 5: if (Count[2] == 5) { if (Count[1] == 5) return(CONVHINT_FINAL555); if (Count[1] == 6) return(CONVHINT_FINAL565); } break; case 6: if (Count[1] == 5 && Count[2] == 5) return(CONVHINT_FINAL655); if (Count[1] == 6 && Count[2] == 4) return(CONVHINT_FINAL664); break; case 8: if (Count[1] == 8 && Count[2] == 8) return(CONVHINT_FINAL24); break; } // Nope. It's an unknown signature. We'll just have to try 555 and hope for the best TRACEALL( wxT("Unknown 16bpp RGB gun configuration (%ld.%ld.%ld). Defaulting to CONVHINT_NONE\n"), Count[0], Count[1], Count[2]); return(CONVHINT_NONE); }

UINT32 DIBUtil::CalcPaletteSize (  UINT32  Depth, bool  bUsingBitFields, UINT32  UsedColours = 0 )  [static]

Definition at line 2680 of file dibutil.cpp. { ERROR3IF((bUsingBitFields && (Depth != 16 || Depth != 32)), "Invalid use of DIBUtil::CalcPaletteSize()"); // Calculate the size of the DIB data UINT32 extras = 0; switch (Depth) { case 1: if (UsedColours > 0 && UsedColours <= 2) extras = UsedColours; else extras = 2; break; case 4: if (UsedColours > 0 && UsedColours <= 16) extras = UsedColours; else extras = 16; break; case 8: if (UsedColours > 0 && UsedColours <= 256) extras = UsedColours; else extras = 256; break; case 16: case 32: if (bUsingBitFields) extras = 3; break; } ERROR3IF(extras == 0 && Depth != 16 && Depth != 24 && Depth != 32, "Unsupported DIB depth!"); return(extras * sizeof(RGBQUAD)); }

BOOL DIBUtil::CalculateNumberOfColoursInBitmap (  LPLOGPALETTE  pExactPalette, RGBQUAD *  pBitmap, size_t  Size )  [static]

Definition at line 3476 of file dibutil.cpp. { ERROR3IF(pExactPalette == NULL, "NULL palette pointer passed to DIBUtil::CalculateNumberOfColoursInBitmap"); if (pExactPalette == NULL) return FALSE; ERROR3IF(pBitmap == NULL, "NULL Bitmap pointer passed to DIBUtil::CalculateNumberOfColoursInBitmap"); if (pBitmap == NULL) return FALSE; ERROR3IF(Size == 0, "Bad size passed to DIBUtil::CalculateNumberOfColoursInBitmap"); if (Size == 0) return FALSE; // return ::CalculateNumberOfColoursInBitmap( pExactPalette, pBitmap, Size ); ASSERT(0); return FALSE; }

BOOL DIBUtil::CanReadFromFile (  const LPBITMAPINFOHEADER  pInfoHeader  )  [static]

To check to see if a .bmp file can be read into memory using ReadFromFile. At present, ReadFromFile only likes 8- & 24- & 32-bit BMPs and so we must tell the caller that this is the case. This is for the Win 3.0+ style BMPs. Scope: Static. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 2/2/95 Parameters: LPBITMAPFILEINFO  points to a bitmap info structure to look at. [INPUTS] -  [OUTPUTS] Returns: TRUE if ReadFromFile will cope with it, FALSE otherwise. See also: DIBUtil::ReadFromFile; Definition at line 1096 of file dibutil.cpp. { ERROR2IF(pInfoHeader==NULL,FALSE,"CanReadFromFile InfoHeader pointer is null"); BOOL Understand = FALSE; // Check the depth in the supplied info header to see if we like it or not INT32 Depth = pInfoHeader->biBitCount; TRACEUSER( "Neville", wxT("DIBUtil::CanReadFromFile Win 3.0+ type depth = %d\n"), Depth ); if (Depth == 32) Understand = TRUE; // it is one of our 32bpp bmp so we definitely like it else Understand = FALSE; // Not sure that we can cope with this return Understand; }

BOOL DIBUtil::CanReadFromFile (  const LPBITMAPCOREHEADER  pCoreHeader  )  [static]

To check to see if a .bmp file can be read into memory using ReadFromFile. At present, ReadFromFile only likes 8- & 24- & 32-bit BMPs and so we must tell the caller that this is the case. This is for the old OS/2 1.0 style BMPs. Scope: Static. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 2/2/95 Parameters: LPBITMAPCOREHEADER  points to a bitmap info structure to look at. [INPUTS] -  [OUTPUTS] Returns: TRUE if ReadFromFile will cope with it, FALSE otherwise. See also: DIBUtil::ReadFromFile; Definition at line 1062 of file dibutil.cpp. { ERROR2IF(pCoreHeader==NULL,FALSE,"CanReadFromFile CoreHeader pointer is null"); BOOL Understand = FALSE; // Check the depth in the supplied info header to see if we like it or not INT32 Depth = pCoreHeader->bcBitCount; TRACEUSER( "Neville", wxT("DIBUtil::CanReadFromFile OS/2 type depth = %d\n"), Depth ); if (Depth == 32) Understand = TRUE; // it is one of our 32bpp bmp so we definitely like it else Understand = FALSE; // Not sure that we can cope with this return Understand; }

BOOL DIBUtil::CanReadFromFile (  const BitmapInfo *  pInfo  )  [static]

To check to see if a .bmp file can be read into memory using ReadFromFile. At present, ReadFromFile only likes 8- & 24- & 32-bit BMPs and so we must tell the caller that this is the case. This is for the old OS/2 1.0 style BMPs. Scope: Static. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 2/2/95 Parameters: pInfo  points to a kernel (BitmapInfo) bitmap info structure to look at. [INPUTS] -  [OUTPUTS] Returns: TRUE if ReadFromFile will cope with it, FALSE otherwise. See also: DIBUtil::ReadFromFile; Definition at line 1028 of file dibutil.cpp. { ERROR2IF(pInfo==NULL,FALSE,"CanReadFromFile BitmapInfo pointer is null"); BOOL Understand = FALSE; // Check the depth in the supplied info header to see if we like it or not INT32 Depth = pInfo->PixelDepth; TRACEUSER( "Neville", wxT("DIBUtil::CanReadFromFile depth = %d\n"), Depth ); if (Depth == 32) Understand = TRUE; // it is one of our 32bpp bmp so we definitely like it else Understand = FALSE; // Not sure that we can cope with this return Understand; }

void DIBUtil::Convert16to24 (  INT32  PixelWidth, LPBYTE  InputBits, LPBYTE  OutputBits )  [static]

Definition at line 507 of file dibutil.cpp. { LPWORD Source = (LPWORD)InputBits; while (PixelWidth--) { const WORD Data = *Source++; // get five-bit RGB values, which we then double-up just like Quickdraw does // to get an 8-bit result const BYTE Blue = Data & 0x1F; *OutputBits++ = EXPAND(Blue); const BYTE Green = (Data>>5) & 0x1F; *OutputBits++ = EXPAND(Green); const BYTE Red = (Data>>10) & 0x1F; *OutputBits++ = EXPAND(Red); } }

BOOL DIBUtil::Convert24to8 (  LPBITMAPINFO  pSourceInfo, LPBYTE  pSourceBits, LPBITMAPINFO *  pDestInfo, LPBYTE *  pDestBits, RGBTRIPLE *  pPalette, UINT32  NumberOfPaletteEntries )  [static]

Generate an 8 bit form of a bitmap from a 24 bit form using the given palette. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 4/9/96 Parameters: pSourceInfo  - A information header for the bitmap to be copied [INPUTS] pSourceBits - the actual bits for the bitmap to be copied pPalette - pointer to the palette in RGBTIPLE format to use when converting NumberOfPaletteEntries - entries in this palette pDestInfo  - pointer to the copied information block [OUTPUTS] pDestBits - pointer ot the copied bits data Returns: True if copied ok, false otherwise Definition at line 3671 of file dibutil.cpp. { // In case of early set these return pointers to NULL *pDestInfo = NULL; *pDestBits = NULL; ERROR2IF(pSourceInfo == NULL || pSourceBits == NULL, FALSE, "DIBUtil::Convert24to8 bad source bitmap"); ERROR2IF(pPalette == NULL || NumberOfPaletteEntries == 0, FALSE, "DIBUtil::Convert24to8 bad palette info"); // Get a pointer to the useful bitmap header information for things like the size of the // bitmap and colour depth. LPBITMAPINFOHEADER pSourceInfoHeader = &(pSourceInfo->bmiHeader); ERROR2IF(pSourceInfoHeader->biBitCount != 24,FALSE,"DIBUtil::Convert24to8 bad source depth"); // Try and allocate the detsination bitmap to be the same size and colour depth as the source *pDestInfo = AllocDIB( pSourceInfoHeader->biWidth, pSourceInfoHeader->biHeight, 8, pDestBits ); // failed to allocate the bitmap so return false. if (*pDestInfo == NULL || *pDestBits == NULL ) return FALSE; LPBITMAPINFOHEADER pDestInfoHeader = &((*pDestInfo)->bmiHeader); // We will need the palette in LOGPALETTE for use in the conversion // We must allocate the palette to be the maximum size as otherwise people like Gavin // blow up LPLOGPALETTE pLogPalette = NULL; const UINT32 MaxColours = 256; pLogPalette = DIBUtil::AllocateLogPalette(MaxColours); if (pLogPalette == NULL) return FALSE; // Now copy the RGBTRIPLE palette into this and into the destination bitmap // Get a pointer to the palette in the destination bitmap LPRGBQUAD lpPalette = NULL; lpPalette = &((*pDestInfo)->bmiColors[0]); // pointer to colours table //pLogPalette->palVersion = 0x300; pLogPalette->palNumEntries = NumberOfPaletteEntries; RGBTRIPLE *pPal = pPalette; for (UINT32 i = 0; i < NumberOfPaletteEntries; i++) { lpPalette->rgbRed = pPal->rgbtRed; pLogPalette->palPalEntry[i].peRed = pPal->rgbtRed; lpPalette->rgbGreen = pPal->rgbtGreen; pLogPalette->palPalEntry[i].peGreen = pPal->rgbtGreen; lpPalette->rgbBlue = pPal->rgbtBlue; pLogPalette->palPalEntry[i].peBlue = pPal->rgbtBlue; pLogPalette->palPalEntry[i].peFlags = 0x00; lpPalette->rgbReserved = 0x00; lpPalette++; pPal++; } // Fill in all other entries as black and do not use for (UINT32 i = NumberOfPaletteEntries; i < MaxColours; i++) { pLogPalette->palPalEntry[i].peRed = 0x00; pLogPalette->palPalEntry[i].peGreen = 0x00; pLogPalette->palPalEntry[i].peBlue = 0x00; pLogPalette->palPalEntry[i].peFlags = 0xFF; // mark as do not use lpPalette->rgbRed = 0x00; lpPalette->rgbGreen = 0x00; lpPalette->rgbBlue = 0x00; lpPalette->rgbReserved = 0xFF; // mark as do not use lpPalette++; } UINT32 DitherType = XARADITHER_NONE; // request no dithering DIBConvert *pDoConvert = NULL; // the convert DIB // Do some conversion using the DIBConvert class pDoConvert = DIBConvert::Create( pSourceInfoHeader->biBitCount, pDestInfoHeader->biBitCount, pSourceInfoHeader->biWidth, pLogPalette, DitherType); // If this fails then exit now if (pDoConvert == NULL) { if (pLogPalette) CCFree(pLogPalette); return FALSE; } // Do the actual conversion process INT32 ChunkHeight = 16; // We will do the conversion in chunks, in case we ask for dithering INT32 Height = pSourceInfoHeader->biHeight; INT32 SourceWidth = DIBUtil::ScanlineSize( pSourceInfoHeader->biWidth, pSourceInfoHeader->biBitCount ) * ChunkHeight; INT32 DestWidth = DIBUtil::ScanlineSize( pDestInfoHeader->biWidth, pDestInfoHeader->biBitCount ) * ChunkHeight; BOOL IsFirstStrip = TRUE; // Whether we are on the first strip or not INT32 CurrentYPos = 0; // current line number LPBYTE SourceData = pSourceBits; // pointer to the source data LPBYTE DestData = *pDestBits; // pointer to the destination data while (CurrentYPos < Height) { // Work out the size of the export chunk left, normally ExportChunkHeight but // if at the end of export may be a small strip left. const UINT32 ThisBit = min( UINT32(Height - CurrentYPos), (UINT32)ChunkHeight ); if (!pDoConvert->Convert( SourceData, DestData, ThisBit, IsFirstStrip )) return FALSE; // stop if conversion failed IsFirstStrip = FALSE; // Done first strip SourceData += SourceWidth; // Move on by a lines worth DestData += DestWidth; // Move on by a lines worth CurrentYPos += INT32(ThisBit); // Move down by a strips worth } // Put back the recommended palette by destructing the convert function. if (pDoConvert) { delete pDoConvert; pDoConvert = NULL; } if (pLogPalette) { CCFree(pLogPalette); pLogPalette = NULL; } // If we got this far then more than likely we have waht we want return TRUE; }

void DIBUtil::Convert32to24 (  INT32  PixelWidth, LPBYTE  InputBits, LPBYTE  OutputBits )  [static]

Definition at line 529 of file dibutil.cpp. { // source form is B,G,R,spare // dest is B,G,R // Note: if not little-endian, is this still true? while (PixelWidth--) { OutputBits[0] = InputBits[0]; OutputBits[1] = InputBits[1]; OutputBits[2] = InputBits[2]; OutputBits += 3; InputBits += 4; } }

void DIBUtil::Convert32to24Alpha (  INT32  PixelWidth, LPBYTE  InputBits, LPBYTE  OutputBits, COLORREF  Colour )  [static]

Definition at line 546 of file dibutil.cpp. { // source form is B,G,R,spare // dest is B,G,R // Note: if not little-endian, is this still true? const BYTE RedBG = (BYTE)(Colour & 0xFF); const BYTE GreenBG = (BYTE)((Colour >> 8) & 0xFF); const BYTE BlueBG = (BYTE)((Colour >> 16) & 0xFF); while (PixelWidth--) { const BYTE Trans = InputBits[3]; const BYTE Alpha = 255 - Trans; OutputBits[0] = ((InputBits[0] * Alpha) + (RedBG * Trans)) / 255; OutputBits[1] = ((InputBits[1] * Alpha) + (GreenBG * Trans)) / 255; OutputBits[2] = ((InputBits[2] * Alpha) + (BlueBG * Trans)) / 255; OutputBits += 3; InputBits += 4; } }

void DIBUtil::Convert32to32 (  INT32  PixelWidth, LPBYTE  InputBits, LPBYTE  OutputBits )  [static]

Definition at line 569 of file dibutil.cpp. { // done as DWORDs for speed LPDWORD Source = (LPDWORD)InputBits; LPDWORD Dest = (LPDWORD)OutputBits; while (PixelWidth--) { // *Dest++ = *Source++ & 0x00FFFFFF; <- MarkH What for? We can deal with 32BMP Alpha channels! *Dest++ = *Source++; } }

BOOL DIBUtil::Convert32to8 (  LPBITMAPINFO  pSourceInfo, LPBYTE  pSourceBits, LPBITMAPINFO *  pDestInfo, LPBYTE *  pDestBits, RGBTRIPLE *  pPalette, UINT32  NumberOfPaletteEntries )  [static]

Generate an 8 bit form of a bitmap from a 32 bit form using the given palette. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/2005 Parameters: pSourceInfo  - A information header for the bitmap to be copied [INPUTS] pSourceBits - the actual bits for the bitmap to be copied pPalette - pointer to the palette in RGBTIPLE format to use when converting NumberOfPaletteEntries - entries in this palette pDestInfo  - pointer to the copied information block [OUTPUTS] pDestBits - pointer ot the copied bits data Returns: True if copied ok, false otherwise Definition at line 3817 of file dibutil.cpp. { // In case of early set these return pointers to NULL *pDestInfo = NULL; *pDestBits = NULL; ERROR2IF(pSourceInfo == NULL || pSourceBits == NULL, FALSE, "DIBUtil::Convert32to8 bad source bitmap"); ERROR2IF(pPalette == NULL || NumberOfPaletteEntries == 0, FALSE, "DIBUtil::Convert32to8 bad palette info"); // Get a pointer to the useful bitmap header information for things like the size of the // bitmap and colour depth. LPBITMAPINFOHEADER pSourceInfoHeader = &(pSourceInfo->bmiHeader); ERROR2IF(pSourceInfoHeader->biBitCount != 32,FALSE,"DIBUtil::Convert32to8 bad source depth"); // Try and allocate the detsination bitmap to be the same size and colour depth as the source *pDestInfo = AllocDIB( pSourceInfoHeader->biWidth, pSourceInfoHeader->biHeight, 8, pDestBits ); // failed to allocate the bitmap so return false. if (*pDestInfo == NULL || *pDestBits == NULL ) return FALSE; LPBITMAPINFOHEADER pDestInfoHeader = &((*pDestInfo)->bmiHeader); // We will need the palette in LOGPALETTE for use in the conversion // We must allocate the palette to be the maximum size as otherwise people like Gavin // blow up LPLOGPALETTE pLogPalette = NULL; const UINT32 MaxColours = 256; pLogPalette = DIBUtil::AllocateLogPalette(MaxColours); if (pLogPalette == NULL) return FALSE; // Now copy the RGBTRIPLE palette into this and into the destination bitmap // Get a pointer to the palette in the destination bitmap LPRGBQUAD lpPalette = NULL; lpPalette = &((*pDestInfo)->bmiColors[0]); // pointer to colours table //pLogPalette->palVersion = 0x300; pLogPalette->palNumEntries = NumberOfPaletteEntries; RGBTRIPLE *pPal = pPalette; for (UINT32 i = 0; i < NumberOfPaletteEntries; i++) { lpPalette->rgbRed = pPal->rgbtRed; pLogPalette->palPalEntry[i].peRed = pPal->rgbtRed; lpPalette->rgbGreen = pPal->rgbtGreen; pLogPalette->palPalEntry[i].peGreen = pPal->rgbtGreen; lpPalette->rgbBlue = pPal->rgbtBlue; pLogPalette->palPalEntry[i].peBlue = pPal->rgbtBlue; pLogPalette->palPalEntry[i].peFlags = 0x00; lpPalette->rgbReserved = 0x00; lpPalette++; pPal++; } // Fill in all other entries as black and do not use for (UINT32 i = NumberOfPaletteEntries; i < MaxColours; i++) { pLogPalette->palPalEntry[i].peRed = 0x00; pLogPalette->palPalEntry[i].peGreen = 0x00; pLogPalette->palPalEntry[i].peBlue = 0x00; pLogPalette->palPalEntry[i].peFlags = 0xFF; // mark as do not use lpPalette->rgbRed = 0x00; lpPalette->rgbGreen = 0x00; lpPalette->rgbBlue = 0x00; lpPalette->rgbReserved = 0xFF; // mark as do not use lpPalette++; } UINT32 DitherType = XARADITHER_NONE; // request no dithering DIBConvert *pDoConvert = NULL; // the convert DIB // Do some conversion using the DIBConvert class pDoConvert = DIBConvert::Create( pSourceInfoHeader->biBitCount, pDestInfoHeader->biBitCount, pSourceInfoHeader->biWidth, pLogPalette, DitherType); // If this fails then exit now if (pDoConvert == NULL) { if (pLogPalette) CCFree(pLogPalette); return FALSE; } // Do the actual conversion process INT32 ChunkHeight = 16; // We will do the conversion in chunks, in case we ask for dithering INT32 Height = pSourceInfoHeader->biHeight; INT32 SourceWidth = DIBUtil::ScanlineSize( pSourceInfoHeader->biWidth, pSourceInfoHeader->biBitCount ) * ChunkHeight; INT32 DestWidth = DIBUtil::ScanlineSize( pDestInfoHeader->biWidth, pDestInfoHeader->biBitCount ) * ChunkHeight; BOOL IsFirstStrip = TRUE; // Whether we are on the first strip or not INT32 CurrentYPos = 0; // current line number LPBYTE SourceData = pSourceBits; // pointer to the source data LPBYTE DestData = *pDestBits; // pointer to the destination data while (CurrentYPos < Height) { // Work out the size of the export chunk left, normally ExportChunkHeight but // if at the end of export may be a small strip left. const UINT32 ThisBit = min( UINT32(Height - CurrentYPos), (UINT32)ChunkHeight ); if (!pDoConvert->Convert( SourceData, DestData, ThisBit, IsFirstStrip )) return FALSE; // stop if conversion failed IsFirstStrip = FALSE; // Done first strip SourceData += SourceWidth; // Move on by a lines worth DestData += DestWidth; // Move on by a lines worth CurrentYPos += INT32(ThisBit); // Move down by a strips worth } // Put back the recommended palette by destructing the convert function. if (pDoConvert) { delete pDoConvert; pDoConvert = NULL; } if (pLogPalette) { CCFree(pLogPalette); pLogPalette = NULL; } // If we got this far then more than likely we have waht we want return TRUE; }

BOOL DIBUtil::Convert8to32 (  LPBITMAPINFO  pSourceInfo, LPBYTE  pSourceBits, RGBQUAD *  pPalette, LPBITMAPINFO  pDestInfo, LPBYTE  pDestBits )  [static]

Generates a 32bit form of the input 8bit bitmap, note that the destination bitmapinfo and bitmap must be allocated prior to this function. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/2000 Parameters: pSourceInfo  - A information header for the bitmap to be copied [INPUTS] pSourceBits - the actual bits for the bitmap to be copied pPalette - pointer to the palette pDestInfo - pointer to an ALLOCATED bitmapinfo structure pDestBits - pointer to an ALLOCATED 32bit bitmap pDestInfo  - pointer to the copied information block [OUTPUTS] pDestBits - pointer ot the copied bits data Returns: True if copied ok, false otherwise Definition at line 3966 of file dibutil.cpp. { ERROR2IF(pSourceBits == NULL, FALSE, "NULL source bitmap"); ERROR2IF(pSourceInfo == NULL, FALSE, "NULL source info"); ERROR2IF(pDestInfo == NULL, FALSE, "NULL destination info"); ERROR2IF(pDestBits == NULL, FALSE, "Null destination bitmap"); // most info will be the same so memcpy is the quickest way //memcpy(pSourceInfo, pDestInfo, sizeof(BITMAPINFO)); // these will all be the same pDestInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); pDestInfo->bmiHeader.biWidth = pSourceInfo->bmiHeader.biWidth; pDestInfo->bmiHeader.biHeight = pSourceInfo->bmiHeader.biHeight; pDestInfo->bmiHeader.biPlanes = pSourceInfo->bmiHeader.biPlanes; pDestInfo->bmiHeader.biCompression = pSourceInfo->bmiHeader.biCompression; pDestInfo->bmiHeader.biXPelsPerMeter = pSourceInfo->bmiHeader.biXPelsPerMeter; pDestInfo->bmiHeader.biYPelsPerMeter = pSourceInfo->bmiHeader.biYPelsPerMeter; pDestInfo->bmiHeader.biClrImportant = 0; // get the size of the new bitmap INT32 size = pDestInfo->bmiHeader.biWidth * pDestInfo->bmiHeader.biHeight * 4; //these will be different from source pDestInfo->bmiHeader.biBitCount = 32; pDestInfo->bmiHeader.biSizeImage = size; pDestInfo->bmiHeader.biClrUsed = 0; // convert from 8 bit to 32 bit INT32 bmpsize = pSourceInfo->bmiHeader.biWidth * pSourceInfo->bmiHeader.biHeight; INT32 padding = pSourceInfo->bmiHeader.biWidth % 4; if (padding) padding = 4 - padding; LPBYTE pSource = pSourceBits; LPBYTE pDest = pDestBits; for (INT32 i = 0; i < bmpsize; i ++) { if (i && i % pSourceInfo->bmiHeader.biWidth == 0) pSource += padding; *pDest = pPalette[*pSource].rgbBlue; pDest++; *pDest = pPalette[*pSource].rgbGreen; pDest++; *pDest = pPalette[*pSource].rgbRed; pDest++; *pDest = pPalette[*pSource].rgbReserved; pDest++; pSource++; } return TRUE</