OutputGIF Class Reference

Contains functions to write a DIB to a GIF in segments, optionally with compression, optionally converting from one depth to another. To use: Open a CCLexFile for write. Call StartFile to write out the header. Call WriteBlock to write out each block of the bitmap, starting from low memory. When you're done, call TidyUp. Similar to OutputDIB but strangely enough writes the data as a GIF instead of a BMP or via the AccusoftFilters. More...

#include <outptgif.h>

Inheritance diagram for OutputGIF:

List of all members.

Public Member Functions
	OutputGIF ()
	Default constructor for the class. Just sets up the pointers to our buffers that may be used to be null so that the TidyUp function can do its job.
virtual	~OutputGIF ()
virtual BOOL	StartFile (LPBITMAPINFOHEADER lpHeader, LPLOGPALETTE Palette, UINT32 OutputDepth, DWORD CompressionType, UINT32 FinalHeight, INT32 ExportSize, UINT32 DitherType)
	Prepare to start the export of a GIF.
virtual BOOL	ReStartFile (LOGPALETTE *pNewPal)
	Called to reset output before outputing another in a run of multiple images.
virtual BOOL	WriteBlock (UINT32 YPos, UINT32 Height, LPBYTE BlockStart, UINT32 InputBPP=32, INT32 ProgressOffset=0)
	Writes a chunk of bitmap data to the device. Assumes a progress hourglass is required and the caller has started an hourglass with a size of 100 and will end it. Notes: Originally this routine assumed that it was being given a 32bpp bmp, but using the InputBPP param it will now handle 8bpp bmps as well...
virtual BOOL	SetUpInfoHeader (const LPBITMAPINFOHEADER lpHeader, const UINT32 OutputDepth, const DWORD CompressionType, const UINT32 LIneWidth, const UINT32 FinalHeight, INT32 *PalSize)
	Set up the information header for the DIB.
virtual BOOL	TidyUp ()
	When everything has been done via WriteBlock, call this to update the header etc. The caller is responsible for closing the file. The class CANNOT be used for further output until StartFile is called again.
BOOL	OutputGifFileHeader (CCLexFile *File, LPBITMAPINFOHEADER pInfo, BOOL Enhanced, INT32 TransColour, LPLOGPALETTE pPalette=NULL, LPRGBQUAD pQuadPalette=NULL)
	Output a GIF file header for the specified bitmap to the file.
BOOL	OutputGifFileHeader (CCLexFile *File, BOOL Enhanced, INT32 TransColour)
	Writes out the file header for the cached bitmap within this class.
BOOL	OutputGifImageExtensionHeader (CCLexFile *File, BOOL InterlaceState, INT32 TransparentColour, UINT32 Delay, UINT32 RestoreType)
	Output a GIF image header for the specified bitmap to the file.
BOOL	OutputGifImageBits (CCLexFile *File, LPBYTE pBlockStart, BOOL Interlace, BOOL LocalColourTable, BaseCamelotFilter *pFilter=NULL, UINT32 NewWidth=0, UINT32 NewHeight=0, UINT32 LeftOffset=0, UINT32 TopOffset=0, LPRGBQUAD pDestPalette=NULL, UINT32 PaletteColourDepth=0, UINT32 NewBitsPerPixel=0)
	Output the actual bits of a bitmap as compressed GIF data. Assumes that a header has already been output, possibly using OutputGifHeader. Assumes that all the data is present. The GIF specifcation allows us to output the next bitmap in an animation such that it is a subregion of a previous image. In this case we need to specify a new width and height plus a left and top offset.
BOOL	OutputGifTerminator (CCLexFile *File)
	Outputs the GIF terminator sequence.
BOOL	OutputAnimationControl (CCLexFile *File, unsigned short Repeats)
	Outputs a Netscape Animation Control block into the GIF file NOTE Must be inserted after file header but before image data.
virtual LPBITMAPINFO	GetDestBitmapInfo (void)
	Access function to DestBitmapInfo.
virtual LPBYTE	GetDestBitmapBits (void)
	Access function to DestBitmapBytes.
INT32	GetColourDepth (INT32 NumberOfColours)
	Converts the number of colours given into the colour depth that is required to output that number. This is not restricted to the colour depths of Window's DIBs i.e. 8, 4 and 1 but can be any colour depth less than 8 bpps.
Protected Types
typedef unsigned char	char_type
Protected Member Functions
void	CompressBlockToFile (LPBYTE Buffer, INT32 init_bits)
	Compress the specified bitmap out to the file specified in the class variable OutputFile. Assumes that variables such as Width, Height, WidthOfLine have been set up by the caller from the bitmap we are about to compress. This is done by the usual calling function of this OutputGifBits and OutputGifHeader.
void	OutputCode (code_int code)
	Output the given code. This assumes that chars are 8 bits long. It maintains a GIFBITS character INT32 buffer (so that 8 codes will fit in it exactly). When the buffer fills up empty it and start over.
void	ClearBlock ()
	Clear out the hash table for block compress.
void	ClearHashTable (count_int hsize)
	reset the code table back to the default values
void	CharacterInit ()
	Set up the 'byte output' routine.
void	OutputCharacter (INT32 c)
	Add a character to the end of the current packet, and if it is 254 characters, flush the packet to disk.
void	FlushCharacters ()
	Flush the packet to disk, and reset the accumulator (class variable a_count).
INT32	GIFNextPixel ()
	-Return the next pixel from the image using the class variables curx, cury as the current positions and afterwards moving them to the next positions. Takes into account if interlacing is on.
void	BumpPixel ()
	Bump the class variables 'curx' and 'cury' to point to the next pixel taking into account interlacing if it is on.
Protected Attributes
LPBITMAPINFO	DestBitmapInfo
LPBYTE	DestBitmapBytes
LPBYTE	pNextStrip
BaseCamelotFilter *	pCamFilter
INT32	Width
INT32	Height
INT32	curx
INT32	cury
INT32	CurrentLine
INT32	CountDown
BOOL	InterlacingOn
INT32	Pass
WORD	BitsPerPixel
INT32	InitCodeSize
INT32	Background
LPBYTE	DataBuffer
UINT32	WidthOfLine
INT32	n_bits
code_int	maxcode
count_int	htab [5003]
unsigned short	codetab [5003]
code_int	free_ent
INT32	clear_flg
INT32	offset
INT32	in_count
INT32	out_count
INT32	g_init_bits
INT32	ClearCode
INT32	EOFCode
UINT32	cur_accum
INT32	cur_bits
INT32	a_count
char	accum [256]

---

Detailed Description

Contains functions to write a DIB to a GIF in segments, optionally with compression, optionally converting from one depth to another. To use: Open a CCLexFile for write. Call StartFile to write out the header. Call WriteBlock to write out each block of the bitmap, starting from low memory. When you're done, call TidyUp. Similar to OutputDIB but strangely enough writes the data as a GIF instead of a BMP or via the AccusoftFilters.

Author:

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

Date:

24/4/95

See also:

OutputDIB;

Definition at line 142 of file outptgif.h.

---

Member Typedef Documentation

typedef unsigned char OutputGIF::char_type [protected]

Definition at line 206 of file outptgif.h.

---

Constructor & Destructor Documentation

OutputGIF::OutputGIF (   )

Default constructor for the class. Just sets up the pointers to our buffers that may be used to be null so that the TidyUp function can do its job. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/4/95 See also: OutputGIF::TidyUp OutputDIB; Definition at line 129 of file outptgif.cpp. { OutputFile = NULL; lpBitmap = NULL; ExportBuffer = NULL; DoExportConvert = NULL; OutputForward = FALSE; DestBitmapInfo = NULL; DestBitmapBytes = NULL; InterlacingOn = FALSE; pCamFilter = NULL; }

virtual OutputGIF::~OutputGIF (   )  [inline, virtual]

Definition at line 147 of file outptgif.h. {}

---

Member Function Documentation

void OutputGIF::BumpPixel (   )  [protected]

Bump the class variables 'curx' and 'cury' to point to the next pixel taking into account interlacing if it is on. Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 1696 of file outptgif.cpp. { // Bump the current X position ++curx; // If we are at the end of a scan line, set curx back to the beginning // If we are interlaced, bump the cury to the appropriate spot, // otherwise, just increment it. if( curx == Width ) { // Reset x to start of next line curx = 0; CurrentLine++; // If Interlacing off then just increment the line we are on if( !InterlacingOn ) ++cury; else { // Otherwise get the next interlaced line in the sequence // Use the same style of code that we use for import in GIFUtil switch (Pass) { case 0: case 1: cury += 8; break; case 2: cury += 4; break; case 3: cury += 2; break; } while (cury >= Height && Pass <= 3) { ++Pass; switch (Pass) { case 1: cury = 4; break; case 2: cury = 2; break; case 3: cury = 1; break; default: cury = 0; break; } } } // Show a progress bar if (pCamFilter == NULL) { // Andy, 13-12-00: We don't want another progress bar if we're exporting //ContinueSlowJob( (INT32)(100 * CurrentLine/(Height)) ); } else pCamFilter->IncProgressBarCount(1); } }

void OutputGIF::CharacterInit (   )  [protected]

Set up the 'byte output' routine. Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 1511 of file outptgif.cpp. { a_count = 0; // set accumlator to zero }

void OutputGIF::ClearBlock (   )  [protected]

Clear out the hash table for block compress. Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 1441 of file outptgif.cpp. { ClearHashTable( (count_int) hsize ); free_ent = ClearCode + 2; clear_flg = 1; OutputCode( (code_int)ClearCode ); }

void OutputGIF::ClearHashTable (  count_int  hsize  )  [protected]

reset the code table back to the default values Parameters: hsize  size of the maximum code size [INPUTS] -  [OUTPUTS] Returns: - Definition at line 1461 of file outptgif.cpp. { // These used to have register in front of them count_int *htab_p = htab + hsize; INT32 i; INT32 m1 = -1; i = hsize - 16; do { *(htab_p - 16) = m1; *(htab_p - 15) = m1; *(htab_p - 14) = m1; *(htab_p - 13) = m1; *(htab_p - 12) = m1; *(htab_p - 11) = m1; *(htab_p - 10) = m1; *(htab_p - 9) = m1; *(htab_p - 8) = m1; *(htab_p - 7) = m1; *(htab_p - 6) = m1; *(htab_p - 5) = m1; *(htab_p - 4) = m1; *(htab_p - 3) = m1; *(htab_p - 2) = m1; *(htab_p - 1) = m1; htab_p -= 16; } while ((i -= 16) >= 0); for ( i += 16; i > 0; --i ) *--htab_p = m1; }

void OutputGIF::CompressBlockToFile (  LPBYTE  Buffer, INT32  init_bits )  [protected]

Compress the specified bitmap out to the file specified in the class variable OutputFile. Assumes that variables such as Width, Height, WidthOfLine have been set up by the caller from the bitmap we are about to compress. This is done by the usual calling function of this OutputGifBits and OutputGifHeader. Parameters: Buffer  pointer to the bits to be compressed [INPUTS] init_bits initial number of bits -  [OUTPUTS] See also: OutputGIF::OutputGifHeader; OutputGIF::OutputGifBits; Definition at line 1255 of file outptgif.cpp. { // These used to have register before them INT32 fcode; code_int i; //= 0; INT32 c; code_int ent; code_int disp; code_int hsize_reg; INT32 hshift; // Note the passed in buffer and size in our class variables DataBuffer = Buffer; // Calculate number of bits we are expecting CountDown = (INT32)Width * (INT32)Height; // Work out the word/byte rounded line width rather than the pixel width WidthOfLine = DIBUtil::ScanlineSize( Width, BitsPerPixel ); // Set up the globals: g_init_bits - initial number of bits g_init_bits = init_bits; // Set up the necessary values offset = 0; out_count = 0; clear_flg = 0; in_count = 1; maxcode = MAXCODE(n_bits = init_bits); ClearCode = (1 << (init_bits - 1)); EOFCode = ClearCode + 1; free_ent = ClearCode + 2; // Indicate which pass we are on (if interlace) Pass = 0; // Set up the current x and y position curx = 0; cury = 0; CurrentLine = 0; cur_accum = 0; cur_bits = 0; CharacterInit(); // a_count = 0; ent = GIFNextPixel(); hshift = 0; for ( fcode = (INT32) hsize; fcode < 65536L; fcode *= 2L ) ++hshift; hshift = 8 - hshift; // set hash code range bound // clear hash table hsize_reg = hsize; ClearHashTable( (count_int) hsize_reg); OutputCode( (code_int)ClearCode ); while ( (c = GIFNextPixel()) != EOF ) { ++in_count; fcode = (INT32) (((INT32) c << maxbits) + ent); i = (((code_int)c << hshift) ^ ent); // xor hashing if ( HashTabOf(i) == fcode ) { ent = CodeTabOf(i); continue; } else if ( (INT32)HashTabOf(i) < 0 ) // empty slot goto nomatch; disp = hsize_reg - i; // secondary hash (after G. Knott) if ( i == 0 ) disp = 1; probe: if ( (i -= disp) < 0 ) i += hsize_reg; if ( HashTabOf(i) == fcode ) { ent = CodeTabOf(i); continue; } if ( (INT32)HashTabOf(i) > 0 ) goto probe; nomatch: OutputCode( (code_int) ent ); ++out_count; ent = c; if ( free_ent < maxmaxcode ) { CodeTabOf(i) = free_ent++; /* code -> hashtable */ HashTabOf(i) = fcode; } else ClearBlock(); } // Put out the final code. OutputCode( (code_int) ent ); ++out_count; OutputCode( (code_int) EOFCode ); }

void OutputGIF::FlushCharacters (   )  [protected]

Flush the packet to disk, and reset the accumulator (class variable a_count). Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 1546 of file outptgif.cpp. { if( a_count > 0 ) { OutputFile->put( a_count ); OutputFile->write( &accum, a_count); a_count = 0; } }

INT32 OutputGIF::GetColourDepth (  INT32  NumberOfColours  )

Converts the number of colours given into the colour depth that is required to output that number. This is not restricted to the colour depths of Window's DIBs i.e. 8, 4 and 1 but can be any colour depth less than 8 bpps. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 27/5/97 Parameters: NumberOfColours  The number of colours in the palette of the bitmap [INPUTS] -  [OUTPUTS] Returns: The colour depth Definition at line 773 of file outptgif.cpp. { INT32 ColourDepth = 8; if (NumberOfColours <= 2) // Changed by Craig Hamilton 14/9/00. ColourDepth = 1; // End changed. else if (NumberOfColours <= 4) ColourDepth = 2; else if (NumberOfColours <= 8) ColourDepth = 3; else if (NumberOfColours <= 16) ColourDepth = 4; else if (NumberOfColours <= 32) ColourDepth = 5; else if (NumberOfColours <= 64) ColourDepth = 6; else if (NumberOfColours <= 128) ColourDepth = 7; else if (NumberOfColours <= 256) ColourDepth = 8; return ColourDepth; }

LPBYTE OutputGIF::GetDestBitmapBits (  void   )  [virtual]

Access function to DestBitmapBytes. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 29/6/00 Parameters: pPalette  - Palette information that we want to copy from [INPUTS] Returns: A pointer to the bitmap itself. Reimplemented from OutputDIB. Definition at line 753 of file outptgif.cpp. { return DestBitmapBytes; }

LPBITMAPINFO OutputGIF::GetDestBitmapInfo (  void   )  [virtual]

Access function to DestBitmapInfo. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 29/6/00 Parameters: pPalette  - Palette information that we want to copy from [INPUTS] Returns: A pointer to the bitmap information structure. Reimplemented from OutputDIB. Definition at line 736 of file outptgif.cpp. { return DestBitmapInfo; }

INT32 OutputGIF::GIFNextPixel (   )  [protected]

-Return the next pixel from the image using the class variables curx, cury as the current positions and afterwards moving them to the next positions. Takes into account if interlacing is on. Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the value of the specified pixel or 0 if badly specified Definition at line 1607 of file outptgif.cpp. { INT32 Pixel; // First, check whether we have done all the pixels in the image if( CountDown == 0 ) return EOF; // Decrement our pixel count --CountDown; //r = GetPixel(curx, cury); if ( !(((cury < 0) || (cury >= Height)) || ((curx < 0) || (curx >= Width))) && DataBuffer ) { // Our DIBs are the wrong way up so we must output the data from the last // line of the image and go up to the start // -1 as height = 1 .. Height whereas y goes from 0 .. Height - 1 // Use the word/byte rounded line width rather than the pixel width // always compresses a byte regardless of colour depth. switch (BitsPerPixel) { case 8: { // If 8 bpp then just use the whole byte straight LPBYTE pData = DataBuffer + curx + ((Height - 1 - cury) * WidthOfLine); Pixel = *(pData); } break; case 4: { // 4bpp so we must get the high or low nibble. This will be dependent on // whether we are on an odd or even pixel. So test the LSBit of the curx, // if set we will be odd. Only move onto next byte every other pixel hence // curx/2. LPBYTE pData = DataBuffer + curx/2 + ((Height - 1 - cury) * WidthOfLine); Pixel = *(pData); if (curx & 1) Pixel = (Pixel & 0x0F); // take low nibble else Pixel = (Pixel & 0xF0) >> 4; // take top nibble } break; case 1: { // 1bpp - pixels are stored in bits. LPBYTE pData = DataBuffer + curx/8 + ((Height - 1 - cury) * WidthOfLine); BYTE Mask = 0x80 >> (curx % 8); if (((*pData) & Mask) == 0) Pixel = 0; else Pixel = 1; } break; default: ERROR3("Unknown export depth"); Pixel = 0; // bad bpp but should not get here } } else { ERROR3("Something bad has happened"); Pixel = 0; } // Move the curx, cury to the next pixel on the image taking into account interlacing BumpPixel(); // Check that the pixel is not outside of the allowed range // If it is then what do we do with it? Set it 0 for now. ERROR3IF(Pixel >= ClearCode,"Trying to output pixel >= ClearCode"); if (Pixel >= ClearCode) Pixel = 0; return Pixel; }

BOOL OutputGIF::OutputAnimationControl (  CCLexFile *  File, unsigned short  Repeats )

Outputs a Netscape Animation Control block into the GIF file NOTE Must be inserted after file header but before image data. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/96 Parameters: File  - file to output to [INPUTS] -  [OUTPUTS] Returns: TRUE if worked, FALSE if failed Definition at line 686 of file outptgif.cpp. { ERROR2IF(File==NULL,FALSE,"OutputGIF::OutputAnimationControl File pointer is null"); BOOL OldThrowingState = File->SetThrowExceptions( TRUE ); BOOL OldReportingState = File->SetReportErrors( FALSE ); try { // Generate the Netscape Extension block BYTE Block[19]; Block[0] = 0x21; // GIF extension code Block[1] = 0xFF; // Application extension Block[2] = 0x0B; // Length of application string memcpy(Block+3, "NETSCAPE2.0", 0x0B); // Application string Block[14] = 0x03; // Length of data sub-block Block[15] = 0x01; // ?? Block[16] = Repeats & 0xFF; // Low byte of repeats Block[17] = Repeats >> 8; // High byte of repeats Block[18] = 0; // Terminator File->write(Block, 19); File->SetThrowExceptions( OldThrowingState ); File->SetReportErrors( OldReportingState ); return TRUE; } catch(...) { File->SetThrowExceptions( OldThrowingState ); File->SetReportErrors( OldReportingState ); return FALSE; } ERROR2( FALSE, "Escaped exception clause somehow" ); }

void OutputGIF::OutputCharacter (  INT32  c  )  [protected]

Add a character to the end of the current packet, and if it is 254 characters, flush the packet to disk. Parameters: c  character to add to the output stream [INPUTS] -  [OUTPUTS] Returns: - Definition at line 1528 of file outptgif.cpp. { accum[ a_count++ ] = c; if( a_count >= 255 ) // was 254 until 16/4/97 - Gavin suggested tweak FlushCharacters(); }

void OutputGIF::OutputCode (  code_int  code  )  [protected]

Output the given code. This assumes that chars are 8 bits long. It maintains a GIFBITS character INT32 buffer (so that 8 codes will fit in it exactly). When the buffer fills up empty it and start over. Parameters: code  A n_bits-bit integer. If == -1, then EOF. [INPUTS] This assumes that n_bits =< (INT32)wordsize - 1. Outputs  code to the file. [OUTPUTS] Definition at line 1377 of file outptgif.cpp. { cur_accum &= masks[ cur_bits ]; if( cur_bits > 0 ) cur_accum |= ((INT32)code << cur_bits); else cur_accum = code; cur_bits += n_bits; while( cur_bits >= 8 ) { OutputCharacter( (UINT32)(cur_accum & 0xff) ); cur_accum >>= 8; cur_bits -= 8; } // If the next entry is going to be too big for the code size, then increase it, // if possible. if ( free_ent > maxcode || clear_flg ) { if( clear_flg ) { maxcode = MAXCODE(n_bits = g_init_bits); clear_flg = 0; } else { ++n_bits; if ( n_bits == maxbits ) maxcode = maxmaxcode; else maxcode = MAXCODE(n_bits); } } if( code == EOFCode ) { // At EOF, write the rest of the buffer. while( cur_bits > 0 ) { OutputCharacter( (UINT32)(cur_accum & 0xff) ); cur_accum >>= 8; cur_bits -= 8; } FlushCharacters(); OutputFile->flush(); } }

BOOL OutputGIF::OutputGifFileHeader (  CCLexFile *  File, BOOL  Enhanced, INT32  TransColour )

Writes out the file header for the cached bitmap within this class. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/96 Parameters: File  - output file object [INPUTS] Enhanced - TRUE if enhanced GIF features are required (eg transpacency) TransColour - the index of the transparent colour (-1 for no transparency) -  [OUTPUTS] Returns: TRUE if worked, FALSE if failed See also: OutputGIF::OutputGifFileHeader (the other one) Definition at line 418 of file outptgif.cpp. { return OutputGifFileHeader(File, &(DestBitmapInfo->bmiHeader), Enhanced, TransColour, OutputPalette); }

BOOL OutputGIF::OutputGifFileHeader (  CCLexFile *  File, LPBITMAPINFOHEADER  pInfo, BOOL  Enhanced, INT32  TransColour, LPLOGPALETTE  pPalette = NULL, LPRGBQUAD  pQuadPalette = NULL )

Output a GIF file header for the specified bitmap to the file. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 28/4/95 Parameters: File  file to output to [INPUTS] pInfo pointer to the bitmap info header Enhanced TRUE if useing advanced GIF features such as transparency or animation TransColour The transparent index or -1 if no transparency pPalette pointer to a palette in LOGPALETTE form (defaults to NULL) OR pQuadPalette pointer to a palette in RGBQUAD form (defaults to NULL) -  [OUTPUTS] Returns: TRUE if worked, FALSE if failed (error will be set accordingly but not reported) Errors: Calls SetError on FALSE returns. See also: OutputGIF::StartFile; OutputGIF::WriteBlock; OutputGIF::TidyUp Scope: static Definition at line 445 of file outptgif.cpp. { ERROR2IF(File==NULL,FALSE,"OutputGIF::OutputGifHeader File pointer is null"); ERROR2IF(pInfo==NULL,FALSE,"OutputGIF::OutputGifHeader BitmapInfo pointer is null"); ERROR2IF(pPalette==NULL && pQuadPalette==NULL,FALSE,"OutputGIF::OutputGifHeader Bitmap palette pointer is null"); // Note file in our class variable as used by all the low level routines OutputFile = File; // Must set the exception throwing flag to True and force reporting of errors to False. // This means that the caller must report an error if the function returns False. // Any calls to CCFile::GotError will now throw a file exception and should fall into // the catch handler at the end of the function. // Replaces the goto's that handled this before. BOOL OldThrowingState = File->SetThrowExceptions( TRUE ); BOOL OldReportingState = File->SetReportErrors( FALSE ); try { // Set up the class variables // First the width/height of the bitmap Width = pInfo->biWidth; Height = pInfo->biHeight; INT32 PalSize = pInfo->biClrUsed; // Translate this into a bits per pixel which is not limited to 8, 4 and 1. INT32 ColourDepth = GetColourDepth(PalSize); // ColourDepth will be rounded to nearest power of two so need to output // that many palette entries INT32 NewPalSize = 1 << ColourDepth; InitCodeSize = ColourDepth; BitsPerPixel = pInfo->biBitCount; TRACEUSER( "Neville", _T("OutputGifFileHeader - Colour depth = %d\n"),ColourDepth); // Write out the unique GIF header GIFINFOHEADER Header; if (Enhanced) memcpy(Header.giName, "GIF89a", 6); else memcpy(Header.giName, "GIF87a", 6); // Indicate that there is a global colour map BYTE Flags = 0; // global colour table flag, colour resoltion sort flag and // size of global colour table if ((pPalette || pQuadPalette) && (PalSize > 0)) Flags = 0x80; // Flag there is a colour map // 3 bit colour resolution value = number of bits per primary colour - 1 Flags |= ((BitsPerPixel - 1) & 0x07) << 4; // OR in the colour resolution // 3 bit size of global colour table = number of bits - 1 Flags |= (ColourDepth - 1) & 0x07; // OR in global colour table size Header.giWidth = (WORD)Width; Header.giHeight = (WORD)Height; Header.giFlags = Flags; Header.giBackground = TransColour==-1 ? 0 : TransColour; Header.giAspect = 0; // This is really sizeof(GIFINFOHEADER) but this returns 14 instead of 13 // as it rounds to the nearest word boundary const size_t HeaderSize = sizeof(char)* 6 + sizeof(WORD) * 2 + sizeof(BYTE) * 3; File->write( &Header, HeaderSize ); if (pQuadPalette && NewPalSize > 0) { // Palette supplied in RGBQUAD form // write it to disk in GIFRGBTRIPLE format GIFRGBTRIPLE TempRGB; for (INT32 i = 0; i < NewPalSize; i++) { // If we are using transparency then bodge the transparent colour to // be White. Otherwise, if we load it back it then we could have a strange // colour being shown as we don't support transparency on loading. if (TransColour >= 0 && i == TransColour) { // Make transparent colour white TempRGB.grgbtRed = 0xFF; TempRGB.grgbtGreen = 0xFF; TempRGB.grgbtBlue = 0xFF; } else if (i > PalSize) { // Make blank palette entries black TempRGB.grgbtRed = 0x00; TempRGB.grgbtGreen = 0x00; TempRGB.grgbtBlue = 0x00; } else { TempRGB.grgbtRed = pQuadPalette->rgbRed; TempRGB.grgbtGreen = pQuadPalette->rgbGreen; TempRGB.grgbtBlue = pQuadPalette->rgbBlue; } File->write( &TempRGB, sizeof(GIFRGBTRIPLE) ); // skip to the next palette entry pQuadPalette++; } } else if (pPalette && NewPalSize > 0) { // Palette supplied in LOGPALETTE form // write it to disk in GIFRGBTRIPLE format GIFRGBTRIPLE TempRGB; for (INT32 i = 0; i < NewPalSize; i++) { // If we are using transparency then bodge the transparent colour to // be White. Otherwise, if we load it back it then we could have a strange // colour being shown as we don't support transparency on loading. if (TransColour >= 0 && i == TransColour) { // Make transparent colour white TempRGB.grgbtRed = 0xFF; TempRGB.grgbtGreen = 0xFF; TempRGB.grgbtBlue = 0xFF; } else if (i > PalSize) { // Make blank palette entries black TempRGB.grgbtRed = 0x00; TempRGB.grgbtGreen = 0x00; TempRGB.grgbtBlue = 0x00; } else { TempRGB.grgbtRed = pPalette->palPalEntry[i].peRed; TempRGB.grgbtGreen = pPalette->palPalEntry[i].peGreen; TempRGB.grgbtBlue = pPalette->palPalEntry[i].peBlue; } File->write( &TempRGB, sizeof(GIFRGBTRIPLE) ); } } else ERROR3("OutputGIF::OutputGifHeader No palette specified"); // Must set the exception throwing and reporting flags back to their entry states File->SetThrowExceptions( OldThrowingState ); File->SetReportErrors( OldReportingState ); // er, we seem to have finished OK so say so return TRUE; } catch(...) { // catch our form of a file exception TRACE( _T("OutputGIF::OutputGifHeader CC catch handler\n")); // Must set the exception throwing and reporting flags back to their entry states File->SetThrowExceptions( OldThrowingState ); File->SetReportErrors( OldReportingState ); return FALSE; } ERROR2( FALSE, "Escaped exception clause somehow" ); }

BOOL OutputGIF::OutputGifImageBits (  CCLexFile *  File, LPBYTE  pBlockStart, BOOL  Interlace, BOOL  LocalColourTable, BaseCamelotFilter *  pFilter = NULL, UINT32  NewWidth = 0, UINT32  NewHeight = 0, UINT32  LeftOffset = 0, UINT32  TopOffset = 0, LPRGBQUAD  pDestPalette = NULL, UINT32  PaletteColourDepth = 0, UINT32  NewBitsPerPixel = 0 )

Output the actual bits of a bitmap as compressed GIF data. Assumes that a header has already been output, possibly using OutputGifHeader. Assumes that all the data is present. The GIF specifcation allows us to output the next bitmap in an animation such that it is a subregion of a previous image. In this case we need to specify a new width and height plus a left and top offset. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 28/4/95 Parameters: File  pointer to file to output to [INPUTS] pBlockStart actual bitmap data to write out Interlace TRUE if image should be interlaced LocalColourTable True if need to specify a local colour table, False if the global one is all that is required pFilter is an alternative way of handling the progress bar, assume the progress bar has been start and just call the IncProgressBarCount in BaseCamelotFilter to do the progress bar update. Defaults to NULL i.e. no progress bar. NewWidth The new width of this bitmap, defaults to 0 meaning none NewHeight The new height of this bitmap, defaults to 0 meaning none LeftOffset The offset of this bitmap from the left hand side, defaults to 0 TopOffset The offset of this bitmap from the top hand side, defaults to 0 pDestPalette The local palette to output NumberOfPalColours The number of colours in this local palette NewBitsPerPixel The new bits per pixel of the bitmap, defaults to 0 meaning none -  [OUTPUTS] Returns: TRUE if worked, FALSE if failed (error will be set accordingly but not reported) Errors: Calls SetError on FALSE returns. See also: OutputGIF::OutputGifHeader; SeeAlo: OutputGIF::StartFile; OutputGIF::WriteBlock; OutputGIF::TidyUp Scope: static Note: If we use the NewWidth and NewHeight input variables then we must ALWAYS input the height and width of the bitmap. Definition at line 842 of file outptgif.cpp. { ERROR2IF(File==NULL,FALSE,"OutputGIF::OutputGifHeader File pointer is null"); ERROR2IF(pBlockStart==NULL,FALSE,"OutputGIF::OutputGifHeader BitmapInfo pointer is null"); // Note file in our class variable as used by all the low level routines OutputFile = File; InterlacingOn = Interlace; // Set up our pointer to the alternative way of handling the progress bar // If it is the NULL default then do not use. pCamFilter = pFilter; if (NewWidth > 0 && NewHeight > 0) { // Set the statics to the new values. If we use this method then we must ALWAYS input // the height and width of the bitmap. Width = NewWidth; Height = NewHeight; } ERROR3IF(NewBitsPerPixel > 8,"Bad BPP in OutputGifImageBits"); if (NewBitsPerPixel > 0 && NewBitsPerPixel <= 8) BitsPerPixel = NewBitsPerPixel; // Must set the exception throwing flag to True and force reporting of errors to False. // This means that the caller must report an error if the function returns False. // Any calls to CCFile::GotError will now throw a file exception and should fall into // the catch handler at the end of the function. // Replaces the goto's that handled this before. BOOL OldThrowingState = File->SetThrowExceptions( TRUE ); BOOL OldReportingState = File->SetReportErrors( FALSE ); try { // Write an Image separator File->put(0x2C); // The initial code size if( BitsPerPixel <= 1 ) InitCodeSize = 2; else InitCodeSize = BitsPerPixel; UINT32 ColourDepth = 1; if (pDestPalette && PaletteColourDepth > 0) { // Translate the number of colours into a bits per pixel which is not limited to 8, 4 and 1. ColourDepth = GetColourDepth(PaletteColourDepth); InitCodeSize = ColourDepth; } else { // Direct saving a bitmap has this set to null //ERROR3IF(DestBitmapInfo == NULL,"Bad DestBitmapInfo in OutputGifImageBits"); if (DestBitmapInfo) { ColourDepth = DestBitmapInfo->bmiHeader.biBitCount; InitCodeSize = GetColourDepth(DestBitmapInfo->bmiHeader.biClrUsed); } else ColourDepth = BitsPerPixel; } // Sanity check on the code size if (InitCodeSize > 8) InitCodeSize = 8; if (InitCodeSize < 2) InitCodeSize = 2; TRACEUSER( "Neville", _T("OutputGifImageBits - Colour depth = %d\n"),ColourDepth); // Write the Image header GIFIMAGEBLOCK ImageHeader; ImageHeader.gibLeft = (WORD)LeftOffset; // Left Offset defaults to zero ImageHeader.gibTop = (WORD)TopOffset; // Top Offset defaults to zero ImageHeader.gibWidth = (WORD)Width; ImageHeader.gibDepth = (WORD)Height; // Flags consists of:- // Local Color Table Flag 1 Bit // Interlace Flag 1 Bit // Sort Flag 1 Bit // Reserved 2 Bits // Size of Local Color Table 3 Bits ImageHeader.gibFlags = (LocalColourTable ? 0x80 : 0) | (Interlace ? 0x40 : 0) | (LocalColourTable ? (ColourDepth - 1) : 0); File->write(&ImageHeader, 9); // Save the local colour table - it follows straight on if (LocalColourTable) { if (pDestPalette && PaletteColourDepth > 0) { TRACEUSER( "Neville", _T("OutputGifImageBits - Output local palette table (Extended)\n")); // Somebody supplied a palette in RGBQUAD form for us to output so do so. // write it to disk in GIFRGBTRIPLE format GIFRGBTRIPLE TempRGB; for (INT32 loop = 0; loop < ((1 << ColourDepth)); loop++) { TempRGB.grgbtRed = pDestPalette->rgbRed; TempRGB.grgbtGreen = pDestPalette->rgbGreen; TempRGB.grgbtBlue = pDestPalette->rgbBlue; pDestPalette++; File->write( &TempRGB, sizeof(GIFRGBTRIPLE) ); } } else if (OutputPalette && ColourDepth > 0) { TRACEUSER( "Neville", _T("OutputGifImageBits - Output local palette table\n")); //ERROR3IF(OutputPalette == NULL,"Bad OutputPalette in OutputGifImageBits") // Use the palette stored inside the DestBitmapInfo and OutputPalette class variables GIFRGBTRIPLE TempRGB; for (INT32 loop = 0; loop < ((1 << ColourDepth)); loop++) { TempRGB.grgbtRed = OutputPalette->palPalEntry[loop].peRed; TempRGB.grgbtGreen = OutputPalette->palPalEntry[loop].peGreen; TempRGB.grgbtBlue = OutputPalette->palPalEntry[loop].peBlue; File->write( &TempRGB, sizeof(GIFRGBTRIPLE) ); } } else ERROR3("Trying to output local palette when none specified!"); } // Write out the initial code size File->put( InitCodeSize ); // It is now ready to go and put that data onto the disc // so wait for the bitmap data to be prepared // Go and actually compress the data CompressBlockToFile( pBlockStart, InitCodeSize + 1 ); // Write out a Zero-length packet (to end the series) File->put( 0 ); // Must set the exception throwing and reporting flags back to their entry states File->SetThrowExceptions( OldThrowingState ); File->SetReportErrors( OldReportingState ); return TRUE; } catch(...) { // catch our form of a file exception TRACE( _T("OutputGIF::OutputGifHeader CC catch handler\n")); // Must set the exception throwing and reporting flags back to their entry states File->SetThrowExceptions( OldThrowingState ); File->SetReportErrors( OldReportingState ); return FALSE; } ERROR2( FALSE, "Escaped exception clause somehow" ); }

BOOL OutputGIF::OutputGifImageExtensionHeader (  CCLexFile *  File, BOOL  InterlaceState, INT32  TransparentColour, UINT32  Delay, UINT32  RestoreType )

Output a GIF image header for the specified bitmap to the file. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> - from Neville code Date: 14/6/96 Parameters: File  file to output to [INPUTS] InterlaceState TRUE if image should be interlaced TransparentColour index of transparent colour or -1 for no transparency Delay Delay in millseconds between this frame and the previous one RestoreType GIF image restore type (0-3) -  [OUTPUTS] Returns: TRUE if worked, FALSE if failed Definition at line 618 of file outptgif.cpp. { ERROR2IF(File==NULL,FALSE,"OutputGIF::OutputGifHeader File pointer is null"); ERROR3IF(RestoreType > 3, "Unknown GIF image restore type"); // Note file in our class variable as used by all the low level routines OutputFile = File; InterlacingOn = InterlaceState; UINT32 TranspFlag = (TransparentColour >= 0) ? 1 : 0; // Must set the exception throwing flag to True and force reporting of errors to False. // This means that the caller must report an error if the function returns False. // Any calls to CCFile::GotError will now throw a file exception and should fall into // the catch handler at the end of the function. // Replaces the goto's that handled this before. BOOL OldThrowingState = File->SetThrowExceptions( TRUE ); BOOL OldReportingState = File->SetReportErrors( FALSE ); try { GIFTRANSBLOCK TransBlock; TransBlock.gtbBlockStart = EXTENSIONBLOCK; TransBlock.gtbIdentifier = TRANSPARENTBLOCK; TransBlock.gtbBlockSize = 4; TransBlock.gtbFlags = TranspFlag | ((RestoreType & 0x03) << 2); TransBlock.gtbDelay = Delay; // TransBlock.gtbTransparency = TranspFlag ? TransparentColour : 0; TransBlock.gtbTerminator = 0; // This is really sizeof(GIFTRANSBLOCK) but this returns 14 instead of 13 // as it rounds to the nearest word boundary const size_t TransBlockSize = sizeof(WORD) * 1 + sizeof(BYTE) * 6; File->write( &TransBlock, TransBlockSize ); // Must set the exception throwing and reporting flags back to their entry states File->SetThrowExceptions( OldThrowingState ); File->SetReportErrors( OldReportingState ); return TRUE; } catch(...) { // catch our form of a file exception TRACE( _T("OutputGIF::OutputGifHeader CC catch handler\n")); // Must set the exception throwing and reporting flags back to their entry states File->SetThrowExceptions( OldThrowingState ); File->SetReportErrors( OldReportingState ); return FALSE; } ERROR2( FALSE, "Escaped exception clause somehow" ); }

BOOL OutputGIF::OutputGifTerminator (  CCLexFile *  File  )

Outputs the GIF terminator sequence. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 28/4/95 Parameters: File  pointer to file to output to [INPUTS] -  [OUTPUTS] Returns: TRUE if worked, FALSE if failed Definition at line 1020 of file outptgif.cpp. { ERROR2IF(File==NULL,FALSE,"OutputGIF::OutputGifTerminator File pointer is null"); BOOL OldThrowingState = File->SetThrowExceptions( TRUE ); BOOL OldReportingState = File->SetReportErrors( FALSE ); try { // Write the GIF file terminator File->put( ';' ); // Must set the exception throwing and reporting flags back to their entry states File->SetThrowExceptions( OldThrowingState ); File->SetReportErrors( OldReportingState ); // er, we seem to have finished OK so say so return TRUE; } catch(...) { // Must set the exception throwing and reporting flags back to their entry states File->SetThrowExceptions( OldThrowingState ); File->SetReportErrors( OldReportingState ); return FALSE; } ERROR2( FALSE, "Escaped exception clause somehow" ); }

BOOL OutputGIF::ReStartFile (  LOGPALETTE *  pNewPal  )  [virtual]

Called to reset output before outputing another in a run of multiple images. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/96 Parameters: pNewPal  - New (optimised) palette to use [INPUTS] Returns: TRUE if worked, FALSE if failed See also: OutputGIF::StartFile Definition at line 291 of file outptgif.cpp. { // Reset member variables IsFirstStrip = TRUE; HeightWritten = 0; pNextStrip = DestBitmapBytes; if (pNewPal!=NULL) { ERROR2IF(OutputPalette==NULL, FALSE, "No output palette"); ERROR3IF(pNewPal->palNumEntries != OutputPalette->palNumEntries, "Different sized palettes"); const size_t PalSize = sizeof(PALETTEENTRY) * pNewPal->palNumEntries-1; memcpy( OutputPalette->palPalEntry, pNewPal->palPalEntry, PalSize ); } return TRUE; }

BOOL OutputGIF::SetUpInfoHeader (  const LPBITMAPINFOHEADER  lpHeader, const UINT32  OutputDepth, const DWORD  CompressionType, const UINT32  LineWidth, const UINT32  FinalHeight, INT32 *  pPalSize )  [virtual]

Set up the information header for the DIB. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 9/11/94 Parameters: lpHeader  contains width & DPI of source & dest. biHeight & depth ignored. [INPUTS] OutputDepth depth of bitmap required on disk CompressionType BI_RGB only supported (or CC_BMPTYPE for 32-bit with trans) LineWidth destination line width FinalHeight output of entire bitmap on disk pPalSize  pointer to an integer PalSize variable which is the palette size [OUTPUTS] Returns: TRUE if worked, FALSE if failed (error will be set accordingly but not reported) Errors: Calls SetError on FALSE returns. See also: OutputGIF::StartFile; OutputGIF::WriteBlock; OutputGIF::TidyUp Scope: Public Definition at line 333 of file outptgif.cpp. { SourceBitmapDepth = lpHeader->biBitCount; BitmapInfo.biBitCount = OutputDepth; const WORD DestDepth = BitmapInfo.biBitCount; // source bitmap not necessarily same as required file depth // make sure we can handle conversion BOOL FormatOK = FALSE; switch (SourceBitmapDepth) { case 32: { switch (DestDepth) { case 8: { // 32->8 is OK FormatOK = TRUE; *pPalSize = 256; } break; case 4: { // 32->4 is OK FormatOK = TRUE; *pPalSize = 16; } break; case 1: { // 32->1 is OK FormatOK = TRUE; *pPalSize = 2; } break; default: // other source formats here break; } } break; case 8: if (DestDepth==8) { // 8->8 is OK FormatOK = TRUE; *pPalSize = 256; } break; default: // other source formats here break; } if (!FormatOK) { Error::SetError( _R(IDE_FORMATNOTSUPPORTED) ); return FALSE; } BitmapInfo.biSizeImage = LineWidth * FinalHeight; return TRUE; }

BOOL OutputGIF::StartFile (  LPBITMAPINFOHEADER  lpHeader, LPLOGPALETTE  Palette, UINT32  OutputDepth, DWORD  CompressionType, UINT32  FinalHeight, INT32  ExportSize, UINT32  DitherType )  [virtual]

Prepare to start the export of a GIF. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 5/6/96 Parameters: lpHeader  contains width & DPI of source & dest. biHeight & depth ignored. [INPUTS] Palette pointer to bmiColor struct, or NULL if not used (can be temporary) OutputDepth depth of bitmap required on disk CompressionType in this case is used to pass in the transparency and interlace information as GIFs are always compressed. Passed in as a number between 0 .. 3 which maps onto the TI_GIF filter types. FinalHeight output of entire bitmap on disk ExportSize The set progress bar size DitherType Returns: TRUE if worked, FALSE if failed (error will be set accordingly but not reported) See also: OutputGIF::WriteBlock; OutputGIF::TidyUp Reimplemented from OutputDIB. Definition at line 192 of file outptgif.cpp. { ERROR2IF( lpHeader==NULL, FALSE, "NULL lpHeader param"); ERROR2IF( Palette==NULL, FALSE, "NULL Palette param"); // Set member variables if (DestBitmapInfo && DestBitmapBytes) { FreeDIB( DestBitmapInfo, DestBitmapBytes ); DestBitmapInfo = NULL; DestBitmapBytes = NULL; } if (OutputPalette) { CCFree(OutputPalette); OutputPalette = NULL; } IsFirstStrip = TRUE; HeightWritten = 0; // remember input args BitmapInfo = *lpHeader; // take a copy of user's header CurrentExportSize = ExportSize; // size set up for the progress bar HeightWanted = FinalHeight; // the actual height of the export required Dither = DitherType; // We will need to have the entire image present before writing out so that we can // cope with interlacing and transparency, so create that DIB // Set up the information header for the dib which we hold during export UINT32 LineWidth = DIBUtil::ScanlineSize( BitmapInfo.biWidth, OutputDepth ); INT32 PalSize = 0; BOOL ok = SetUpInfoHeader(lpHeader, OutputDepth, CompressionType, LineWidth, FinalHeight, &PalSize); // Claim memory for the bitmap if (ok) { DestBitmapInfo = AllocDIB( BitmapInfo.biWidth, FinalHeight, OutputDepth, &DestBitmapBytes ); ok = (DestBitmapInfo != NULL) && (DestBitmapBytes != NULL); } // Transfer across the required other bits of info if (ok) { DestBitmapInfo->bmiHeader.biXPelsPerMeter = BitmapInfo.biXPelsPerMeter; DestBitmapInfo->bmiHeader.biYPelsPerMeter = BitmapInfo.biYPelsPerMeter; DestBitmapInfo->bmiHeader.biClrUsed = PalSize; } // Point the place to put the next strip of data at the start ready for the first strip pNextStrip = DestBitmapBytes; // Take a copy of the palette if (ok) { const size_t TotalPal = sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * PalSize ); OutputPalette = (LPLOGPALETTE)CCMalloc( TotalPal ); if (OutputPalette != NULL) memcpy( OutputPalette, Palette, TotalPal ); else ok = FALSE; } // Clean up if an error happened if (!ok) { // Free up the DIB that we have just created FreeDIB( DestBitmapInfo, DestBitmapBytes ); DestBitmapInfo = NULL; DestBitmapBytes = NULL; if (OutputPalette != NULL) { CCFree(OutputPalette); OutputPalette = NULL; } } return ok; }

BOOL OutputGIF::TidyUp (   )  [virtual]

When everything has been done via WriteBlock, call this to update the header etc. The caller is responsible for closing the file. The class CANNOT be used for further output until StartFile is called again. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 4/8/94 Returns: TRUE if worked, FALSE if failed (error will be set accordingly but not reported) Errors: Calls SetError on FALSE returns. Scope: Public Reimplemented from OutputDIB. Definition at line 1181 of file outptgif.cpp. { // Free up the DIB that we have just created if (DestBitmapInfo && DestBitmapBytes) { FreeDIB( DestBitmapInfo, DestBitmapBytes ); DestBitmapInfo = NULL; DestBitmapBytes = NULL; } // Call the baseclass version to do its stuff const BOOL ok = OutputDIB::TidyUp(); return ok; }

BOOL OutputGIF::WriteBlock (  UINT32  YPos, UINT32  Height, LPBYTE  BlockStart, UINT32  InputBPP = 32, INT32  ProgressOffset = 0 )  [virtual]

Writes a chunk of bitmap data to the device. Assumes a progress hourglass is required and the caller has started an hourglass with a size of 100 and will end it. Notes: Originally this routine assumed that it was being given a 32bpp bmp, but using the InputBPP param it will now handle 8bpp bmps as well... Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/4/95 Parameters: YPos  pixel co-ord of the chunk of DIB we are about to write out (0=bottom, [INPUTS] increasing as it goes up). Height height in pixels of this chunk BlockStart the start address of the bytes of this chunk (optional) InputBPP BPP of the input image (assumed 32 by default - 8 also works) ProgressOffset value to add to value passed to ContinueSlowJob (default 0). Returns: TRUE if worked, FALSE if failed (error will be set accordingly but not reported) Errors: Calls SetError on FALSE returns. Scope: Public Reimplemented from OutputDIB. Definition at line 1080 of file outptgif.cpp. { ERROR2IF(DestBitmapInfo == NULL, FALSE,"OutputGIF::WriteBlock destination bitmap info null"); ERROR2IF(DestBitmapBytes == NULL, FALSE,"OutputGIF::WriteBlock destination bitmap bits null"); ERROR2IF(pNextStrip == NULL, FALSE,"OutputGIF::WriteBlock next strip pointer is null"); FNPTR_SCANLINE ConvertFn = NULL; LPBYTE Buffer = NULL; size_t BufSize = 0L; size_t ChunkHeight = 1; DIBConvert *DoConvert = NULL; // Set up the size and other information for the dib block that we require. This is // dependent on the export depth or bpp required. if ( !SetUpBlock( &BufSize, &ChunkHeight, &DoConvert, &ConvertFn ) ) return FALSE; // Error details already set up if (BufSize) { Buffer = (LPBYTE)CCMalloc( BufSize ); if (Buffer==NULL) return FALSE; } if ( DoConvert ) { // use new classes to do it // 8bpp, 4bpp and 1bpp conversion INT32 h = Height; INT32 count = 0; LPBYTE Data = BlockStart; const size_t SourceWidth = DIBUtil::ScanlineSize( BitmapInfo.biWidth, InputBPP ) * ChunkHeight; const size_t DestWidth = DIBUtil::ScanlineSize( BitmapInfo.biWidth, BitmapInfo.biBitCount ); while (h) { ENSURE(h >= 0, "bad looping"); const size_t ThisBit = min( h, (INT32)ChunkHeight ); if (!DoConvert->Convert( Data, Buffer, ThisBit, IsFirstStrip )) break; // stop if conversion failed IsFirstStrip = FALSE; // Copy this block to our destination bitmap // pNextStrip should be pointing at the next place to copy the data to memcpy(pNextStrip, Buffer, ThisBit * DestWidth); Data += SourceWidth; h -= ThisBit; pNextStrip += ThisBit * DestWidth; // now update the progress display, started with CurrentExportSize // CurrentExport size is now the point to go from in the export count++; //ContinueSlowJob( (INT32)(ProgressOffset + count) ); //ContinueSlowJob( (INT32)(100*count/(Height)) ); } } else if ( ConvertFn && Buffer ) { // Write via conversion function // 24 bpp convert ERROR2(FALSE,"OutputGIF::WriteBlock trying to write using ConvertFunction"); } else { ERROR2(FALSE,"OutputGIF::WriteBlock trying to write in one go"); } // If present, get rid of our export function if (DoConvert) { delete DoConvert; DoConvert = NULL; } CCFree( Buffer ); Buffer = NULL; HeightWritten += Height; // remember we wrote this lot return TRUE; }

---

Member Data Documentation

INT32 OutputGIF::a_count [protected]

Definition at line 234 of file outptgif.h.

char OutputGIF::accum[256] [protected]

Definition at line 235 of file outptgif.h.

INT32 OutputGIF::Background [protected]

Definition at line 200 of file outptgif.h.

WORD OutputGIF::BitsPerPixel [protected]

Definition at line 198 of file outptgif.h.

INT32 OutputGIF::clear_flg [protected]

Definition at line 218 of file outptgif.h.

INT32 OutputGIF::ClearCode [protected]

Definition at line 227 of file outptgif.h.

unsigned short OutputGIF::codetab[5003] [protected]

Definition at line 212 of file outptgif.h.

INT32 OutputGIF::CountDown [protected]

Definition at line 194 of file outptgif.h.

UINT32 OutputGIF::cur_accum [protected]

Definition at line 231 of file outptgif.h.

INT32 OutputGIF::cur_bits [protected]

Definition at line 232 of file outptgif.h.

INT32 OutputGIF::CurrentLine [protected]

Definition at line 193 of file outptgif.h.

INT32 OutputGIF::curx [protected]

Definition at line 191 of file outptgif.h.

INT32 OutputGIF::cury [protected]

Definition at line 192 of file outptgif.h.

LPBYTE OutputGIF::DataBuffer [protected]

Definition at line 202 of file outptgif.h.

LPBYTE OutputGIF::DestBitmapBytes [protected]

Definition at line 181 of file outptgif.h.

LPBITMAPINFO OutputGIF::DestBitmapInfo [protected]

Definition at line 180 of file outptgif.h.

INT32 OutputGIF::EOFCode [protected]

Definition at line 228 of file outptgif.h.

code_int OutputGIF::free_ent [protected]

Definition at line 214 of file outptgif.h.

INT32 OutputGIF::g_init_bits [protected]

Definition at line 225 of file outptgif.h.

INT32 OutputGIF::Height [protected]

Definition at line 190 of file outptgif.h.

count_int OutputGIF::htab[5003] [protected]

Definition at line 211 of file outptgif.h.

INT32 OutputGIF::in_count [protected]

Definition at line 221 of file outptgif.h.

INT32 OutputGIF::InitCodeSize [protected]

Definition at line 199 of file outptgif.h.

BOOL OutputGIF::InterlacingOn [protected]

Definition at line 195 of file outptgif.h.

code_int OutputGIF::maxcode [protected]

Definition at line 209 of file outptgif.h.

INT32 OutputGIF::n_bits [protected]

Definition at line 208 of file outptgif.h.

INT32 OutputGIF::offset [protected]

Definition at line 220 of file outptgif.h.

INT32 OutputGIF::out_count [protected]

Definition at line 222 of file outptgif.h.

INT32 OutputGIF::Pass [protected]

Definition at line 196 of file outptgif.h.

BaseCamelotFilter* OutputGIF::pCamFilter [protected]

Definition at line 186 of file outptgif.h.

LPBYTE OutputGIF::pNextStrip [protected]

Definition at line 182 of file outptgif.h.

INT32 OutputGIF::Width [protected]

Definition at line 189 of file outptgif.h.

UINT32 OutputGIF::WidthOfLine [protected]

Definition at line 204 of file outptgif.h.

---

The documentation for this class was generated from the following files:

• wxOil/outptgif.h (r1785/r1348)
• wxOil/outptgif.cpp (r1785/r1348)

---