//////////
//
//	File:		ImageCompressionUtilities.c
//
//	Contains:	Utilities for compressing images.
//
//	Written by:	Peter Hoddie, Sean Allen, Chris Flick
//	Revised by:	Tim Monroe
//
//	Copyright:	© 1997-2000 by Apple Computer, Inc., all rights reserved.
//
//	Change History (most recent first):
//
//	   <8>	 	11/17/00	rtm		general clean-up to bring this file into conformance with style of other
//									sample code
//	   <7>	 	03/28/00	rtm		changed ((**myPixMap).rowBytes & 0x3fff) to QTGetPixMapHandleRowBytes(myPixMap)
//	   <6>	 	03/17/00	rtm		moved some things to ImageCompressionUtilities.h; made some changes for Carbon
//	   <5>	 	02/25/00	rtm		changed pascal keyword to PASCAL_RTN, for Windows compatibility
//	   <4>	 	12/16/98	rtm		removed orphaned prototype for compressTransparentRLEwithHitTesting
//	   <3>	 	05/28/98	rtm		added some typecasting to minimize MSDev compiler warnings
//	   <2>	 	04/22/98	rtm		made changes to ICUtils_RecompressPictureFileWithTransparency, as per Chris' fixes
//	   <1>	 	03/27/98	rtm		existing file
//
//////////

#ifndef __IMAGECOMPRESSIONUTILITIES__
#include "ImageCompressionUtilities.h"
#endif


//////////
//
// ICUtils_CreateImageDescription
// Create an image description.
//
//////////

/*static*/ ImageDescriptionHandle ICUtils_CreateImageDescription (CodecType theCodecType, PixMapHandle thePixmap)
{
	ImageDescriptionHandle	myDesc = NULL;
	OSErr					myErr = noErr;
	
	if (thePixmap == NULL)
		return(myDesc);
	
	myDesc = (ImageDescriptionHandle)NewHandleClear(sizeof(ImageDescription));
	if (myDesc != NULL) {
		Rect				myRect = (**thePixmap).bounds;

		(**myDesc).idSize 			= sizeof(ImageDescription);
		(**myDesc).cType 			= theCodecType;	
		(**myDesc).spatialQuality 	= codecNormalQuality;
		(**myDesc).width			= myRect.right - myRect.left;
		(**myDesc).height 			= myRect.bottom - myRect.top;
		(**myDesc).hRes 			= 72L << 16;
		(**myDesc).vRes 			= 72L << 16;
		(**myDesc).dataSize 		= (QTGetPixMapHandleRowBytes(thePixmap)) * (**myDesc).height;
		(**myDesc).depth 			= (**thePixmap).pixelSize;
		(**myDesc).clutID 			= -1;
		
		myErr = SetImageDescriptionCTable(myDesc, (**thePixmap).pmTable);
		if (myErr != noErr) {
			DisposeHandle((Handle)myDesc);
			myDesc = NULL;
		}
	}
		
	return(myDesc);
}


//////////
//
// ICUtils_NoDitherBitsProc
//
//////////

PASCAL_RTN void ICUtils_NoDitherBitsProc (const BitMap *theSrcBits, const Rect *theSrcRect, const Rect *theDstRect, short theMode, RgnHandle theMaskRgn)
{
	theMode &= ~ditherCopy;
	StdBits(theSrcBits, theSrcRect, theDstRect, theMode, theMaskRgn);
}


//////////
//
// ICUtils_DrawPictureNoDither
// Draw a QuickTime picture, but convert any use of ditherCopy graphics modes to graphics modes that don't use ditherCopy.
//
//////////

static void ICUtils_DrawPictureNoDither (PicHandle thePicture, const Rect *theRect)
{		
	CQDProcs		myProcs;
	GrafPtr			mySavedPort;
	CQDProcsPtr		mySavedProcs;

	GetPort(&mySavedPort);
	mySavedProcs = GetPortGrafProcs(mySavedPort);
	SetStdCProcs(&myProcs);

	myProcs.bitsProc = NewQDBitsUPP(ICUtils_NoDitherBitsProc);
	SetPortGrafProcs((CGrafPtr)mySavedPort, &myProcs);

	DrawPicture(thePicture, theRect);

	SetPortGrafProcs((CGrafPtr)mySavedPort, mySavedProcs);
	DisposeQDBitsUPP(myProcs.bitsProc);
}


//////////
//
// ICUtils_PrepareFor16BitCompress
//
// Clean up the colors in a picture before being compressed with the Animation compressor in 16-bits at codecNormal quality.
//
// The QuickTime Animation compressor can operate in both a lossless and lossy manner. This routine is meant to help when
// compressing in a lossy manner. Here, "clean up" means to force any colors that are sufficiently close to white to colors
// that are not as close. Since the Animation compressor will perform thresholding of the image's colors when codecNormal
// quality is specified, without this preprocessing, colors very close to white can be mapped to white in the compression.
// If white was chosen as the key color, pixels that are close to white could possibly become transparent as well.
//
// While not used by other routines in this file, ICUtils_PrepareFor16BitCompress is provided as an example of how this might be done.
//
// Note that with codecLossless quality, there is no remapping of colors so this step is unnecessary.
//
//////////

static OSErr ICUtils_PrepareFor16BitCompress (PicHandle *thePicture)
{
	PicHandle				myPicture = NULL;
	Rect					myRect;
	GWorldPtr				myGWorld = NULL;
	CGrafPtr				mySavedPort;
	GDHandle				mySavedDevice;
	short					myRowBytes;
	Ptr						myBaseAddr;
	long					w, h;
	PixMapHandle			myPixMap;
	OSErr					myErr = noErr;

	GetGWorld(&mySavedPort, &mySavedDevice);

	myRect = (***thePicture).picFrame;
	MacOffsetRect(&myRect, (short)-myRect.left, (short)-myRect.top);

	myErr = QTNewGWorld(&myGWorld, 32, &myRect, NULL, NULL, kICMTempThenAppMemory);
	if (myErr != noErr)
		goto bail;

	myPixMap = GetGWorldPixMap(myGWorld);
	LockPixels(myPixMap)
	;
	SetGWorld(myGWorld, NULL);
	EraseRect(&myRect);

	DrawPicture(*thePicture, &myRect);

	myBaseAddr = GetPixBaseAddr(myPixMap);
	myRowBytes = QTGetPixMapHandleRowBytes(myPixMap);;
	for (h =0 ; h < myRect.bottom; h++) {
		long *myPixelPtr = (long *)myBaseAddr;

		for (w = 0; w < myRect.right; w++, myPixelPtr++) {
			UInt8 r, g, b, a;
			long myPixel = *myPixelPtr;

			if ((myPixel & 0x0ffffff) == 0x00ffffff)		// pure white
				continue;

			a = (myPixel >> 24) & 0x0ff;
			r = (myPixel >> 16) & 0x0ff;
			g = (myPixel >>  8) & 0x0ff;
			b = (myPixel >>  0) & 0x0ff;
			if ((r > kThreshold) && (g > kThreshold) && (b > kThreshold)) {
				r = g = b = kThreshold;
				*myPixelPtr = (a << 24) | (kThreshold << 16) | (kThreshold << 8) | (kThreshold << 0);
			}
		}

		myBaseAddr += myRowBytes;
	}

	myPicture = OpenPicture(&myRect);
	CopyBits((BitMapPtr)*GetGWorldPixMap(myGWorld),
			 (BitMapPtr)*GetGWorldPixMap(myGWorld),
			 &myRect,
			 &myRect,
			 ditherCopy,
			 NULL);
			 
	ClosePicture();
	UnlockPixels(myPixMap);

bail:
	if (myGWorld)
		DisposeGWorld(myGWorld);

	if (myErr == noErr) {
		if (myPicture) {
			KillPicture(*thePicture);
			*thePicture = myPicture;
		}
	}

	SetGWorld(mySavedPort, mySavedDevice);

	return(myErr);
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Callback-based routines for compressing with hit-testing and transparency.
//
///////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////
//
// ICUtils_RecompressWithTransparencyFromProc
//
// This routine recompresses some given image data with transparency, using the specified key color.
// It uses a callback procedure (theDrawProc) to get the dimensions of the area of the drawable entity
// and for actually drawing that entity.
//
// This routine is called by _RecompressCompressedImageWithTransparency, _RecompressPictureWithTransparency,
// and _RecompressPictureFileWithTransparency; you can also call it directly. 
//
// Here's a recap of the parameters:
//
//	theDrawProc				the callback procedure that gets area of image and draws it
//	theDrawProcRefCon		a reference constant passed to theDrawProc
//	includeHitTesting		TRUE if hit-testing data should be added to the compressed data
//	theKeyColor				an RGBColor that is to be used as the key color; NULL if no tansparency
//	theHitTestRegion		a RgnHandle specifying an area that is to be used as the hit test area;
//							if you pass this, you must also set includeHitTesting to TRUE; this is
//							optional, as the callback procedure can perform drawing of the hit test area
//							(which is often suitable when both the image and hit test area were painted
//							in a drawing program)
//	theImageDesc			returned ImageDescriptionHandle for the compressed image data
//	theImageData			returned Handle to the compressed image data
// 
//
//////////
 
OSErr ICUtils_RecompressWithTransparencyFromProc (
										CompressDrawProc theDrawProc,
										void *theDrawProcRefCon, 
										Boolean includeHitTesting,
										RGBColor *theKeyColor, 
										RgnHandle theHitTestRegion,
										ImageDescriptionHandle *theImageDesc,
										Handle *theImageData)
{
	Rect						myRect;
	CGrafPtr					mySavedPort;
	GDHandle					mySavedDevice;
	GWorldPtr					myGWImage = NULL;		// always used
	GWorldPtr					myGWPrev = NULL;		// used if compressing with transparency (via key color)
	GWorldPtr					myGWMap = NULL;			// used if compressing with hittesting data
	ImageDescriptionHandle                          myDesc = NULL;			// resulting image description
	ImageDescriptionHandle                          myGWMapDesc = NULL;
	ImageSequence                                   mySeqID = 0;			// compression sequence
	ImageSequenceDataSource                         myMapSource = 0L;
	Ptr                                             myData = NULL;
	long 						myDataSize;
	UInt8 						mySimilarity;
	Boolean						includeTransparency = false;
	RGBColor					mySaveBackColor;
	OSErr 						myErr = noErr;
	
	// get the current graphics port and device
	GetGWorld(&mySavedPort, &mySavedDevice);
	
	if ((theDrawProc == NULL) || (theImageDesc == NULL) || (theImageData == NULL)) {
		myErr = paramErr;
		goto bail;
	}
	
	//////////
	//
	// allocate and configure any storage we'll need for recompressing the image data
	//
	//////////
	
	// tell the callback procedure that it should initialize any storage it needs
	myErr = theDrawProc(kRecoProcInitMsg, NULL, NULL, 0, theDrawProcRefCon);
	if (myErr != noErr)
		goto bail;
	
	// determine the bounds to use for compression
	myErr = theDrawProc(kRecoProcGetBoundsMsg, &myRect, NULL, 0, theDrawProcRefCon);
	if (myErr != noErr)
		goto bail;
	
	myErr = QTNewGWorld(&myGWImage, kCompressDepth, &myRect, NULL, NULL, kICMTempThenAppMemory);
	if (myErr != noErr)
		goto bail;

	if (theKeyColor != NULL)
		includeTransparency = true;
	
	// if we are to include transparency, we need a previous buffer and an 8-bit GWorld for the mask data
        
        
	// lock our GWorld pixmaps
	LockPixels(GetGWorldPixMap(myGWImage));
	
	if (myGWPrev != NULL)
		LockPixels(GetGWorldPixMap(myGWPrev));
	
	if (myGWMap != NULL)
		LockPixels(GetGWorldPixMap(myGWMap));
	
	//////////
	//
	// set up the GWorlds
	//
	//////////
	
	// erase the previous GWorld
	if (myGWPrev != NULL) {
		SetGWorld(myGWPrev, NULL);
		ClipRect(&myRect);
		
		GetBackColor(&mySaveBackColor);
		if (theKeyColor != NULL)
			RGBBackColor(theKeyColor);
		
		EraseRect(&myRect);
		RGBBackColor(&mySaveBackColor);
	}
	
	// erase the image GWorld
	SetGWorld(myGWImage, NULL);
        //RGBBackColor(theKeyColor);
	ClipRect(&myRect);
	EraseRect(&myRect);
        //PaintRect(&myRect);
	
	//////////
	//
	// set up the compression sequence
	//
	// we pass codecLosslessQuality so that the key color (if any) is matched exactly; this avoids colors within
	// some threshhold different from the key color being taken as equivalent to the key color; alternatively,
	// we could perform some threshold processing on the source image's pixels and pass codecNormalQuality
	//
	//////////

	myDesc = (ImageDescriptionHandle)NewHandle(sizeof(ImageDescription));

        // we're not hit-testing, so we only need the image buffer
        myErr = CompressSequenceBegin(&mySeqID, GetGWorldPixMap(myGWImage), NULL, &myRect, NULL, kCompressDepth, kAnimationCodecType, 0, codecLosslessQuality, codecLosslessQuality, 2, NULL, 0, myDesc);
        //myErr = CompressSequenceBegin(&mySeqID, GetGWorldPixMap(myGWImage), NULL, &myRect, NULL, kCompressDepth, kJPEGCodecType, 0, codecMinQuality, codecMinQuality, 2, NULL, 0, myDesc);
        if (myErr != noErr)
            goto bail;
		
        // What's the maximum size the compressed data could be?
        myErr = GetCSequenceMaxCompressionSize(mySeqID, GetGWorldPixMap(myGWImage), &myDataSize);
	
	if (myErr != noErr)
		goto bail;
	
	//////////
	//
	// compress the image data
	//
	//////////

	myData = NewPtr(myDataSize);
	myErr = MemError();
	if (myErr != noErr)
		goto bail;
	
        if (includeTransparency) {
		// for transparency without hit-testing, we get by with only using a single buffer
	
		// compress the GWorld painted with the theKeyColor exclusively
            myErr = CompressSequenceFrame(mySeqID, GetGWorldPixMap(myGWImage), NULL, codecFlagUpdatePrevious, myData, &myDataSize, &mySimilarity, NULL);
            if (myErr != noErr)
			goto bail;

		// draw the image into the GWorld over the area painted with theKeyColor, so that if the picture is already transparent,
		// the areas it doesn't paint will be in the key color
            SetGWorld(myGWImage, NULL);
		
            GetBackColor(&mySaveBackColor);
            if (theKeyColor != NULL)
                mySaveBackColor = *theKeyColor;
            if (theKeyColor != NULL)
                RGBBackColor(theKeyColor);
			
            EraseRect(&myRect);
            RGBBackColor(&mySaveBackColor);
	
            myErr = theDrawProc(kRecoProcDrawMsg, &myRect, myGWImage, kRecoProcOriginalImageType, theDrawProcRefCon);
            if (myErr != noErr)
			goto bail;

		// now compress the GWorld holding the image drawn on top of the theKeyColor
            myErr = CompressSequenceFrame(mySeqID, GetGWorldPixMap(myGWImage), NULL, codecFlagUpdatePrevious, myData, &myDataSize, &mySimilarity, NULL);
            if (myErr != noErr)
			goto bail;
		
		// at this point, myData points to the image data for just the difference between the two (thus generating transparency) 
		// also, hit-testing data is contained in the image data if so specified
	} else {
		// no hit-testing and no transparency....
		SetGWorld(myGWImage, NULL);

		// draw the image into the GWorld
		myErr = theDrawProc(kRecoProcDrawMsg, &myRect, myGWImage, kRecoProcOriginalImageType, theDrawProcRefCon);
		if (myErr != noErr)
			goto bail;

		// compress the GWorld containing the image painted on white
		myErr = CompressSequenceFrame(mySeqID, GetGWorldPixMap(myGWImage), NULL, 0, myData, &myDataSize, &mySimilarity, NULL);
		if (myErr != noErr)
			goto bail;
		
		// at this point, myData points to the image data for just the image, newly compressed; also, hit - data is contained
		// in the image data if it was specified
	}
	
	//////////
	//
	// end the compression sequence and clean up
	//
	//////////

	CDSequenceEnd(mySeqID);
	mySeqID = 0;
	
	// free the GWorlds and drop references so we have more memory for PtrToHand
	if (myGWImage != NULL)
		DisposeGWorld(myGWImage);
	myGWImage = NULL;
	
	if (myGWMap != NULL)
		DisposeGWorld(myGWMap);
	myGWMap = NULL;
	
	if (myGWPrev != NULL)
		DisposeGWorld(myGWPrev);
	myGWPrev = NULL;
	
	// return the image data and the image description to the caller
	myErr = PtrToHand(myData, theImageData, myDataSize);
	if (myErr) goto bail;
	
	*theImageDesc = myDesc;
	myDesc = NULL;				// forget about this name for ImageDescriptionHandle so dispose below doesn't catch it
	
bail:
	// tell callback to dispose of anything it allocated; we pass 'err ' in theImageType if an error occurred
	theDrawProc(kRecoProcDisposeMsg, NULL, NULL, myErr ? FOUR_CHAR_CODE('err ') : 0, theDrawProcRefCon);
	
	if (mySeqID != 0)
		CDSequenceEnd(mySeqID);
	
	// restore the original graphics port and device
	SetGWorld(mySavedPort, mySavedDevice);
	
	if (myGWImage != NULL)
		DisposeGWorld(myGWImage);
		
	if (myGWMap != NULL)
		DisposeGWorld(myGWMap);
		
	if (myGWPrev != NULL)
		DisposeGWorld(myGWPrev);
		
	if (myDesc != NULL)
		DisposeHandle((Handle) myDesc);
		
	if (myGWMapDesc != NULL)
		DisposeHandle((Handle) myGWMapDesc);
		
	if (myData != NULL)
		DisposePtr(myData);
		
	return(myErr);
}


//////////
//
// ICUtils_PictureCompressDrawProc
//
// Helper routine to be used with ICUtils_RecompressWithTransparencyFromProc to compress QuickDraw pictures.
//
//////////

static PASCAL_RTN OSErr ICUtils_PictureCompressDrawProc (short theMessage, Rect *theRect, GWorldPtr theDrawingPort, OSType theImageType, void *theRefCon)
{
#if TARGET_OS_MAC
#pragma unused(theDrawingPort)
#endif
	ICUtils_PictureCompressProcData		*myData = theRefCon;
	Rect								myRect;
	OSErr								myErr = noErr;
	
	switch (theMessage) {
		case kRecoProcInitMsg:
			break;
			
		case kRecoProcDisposeMsg:
			break;
			
		case kRecoProcGetBoundsMsg:
			myRect = (**myData->picture).picFrame;
			
			myRect.left = EndianS16_BtoN(myRect.left);
			myRect.top = EndianS16_BtoN(myRect.top);
			myRect.bottom = EndianS16_BtoN(myRect.bottom);
			myRect.right = EndianS16_BtoN(myRect.right);
			MacOffsetRect(&myRect, (short)-myRect.left, (short)-myRect.top);
			
			*theRect = myRect;
			break;
			
		case kRecoProcDrawMsg:
			myRect = (**myData->picture).picFrame;
			
			myRect.left = EndianS16_BtoN(myRect.left);
			myRect.top = EndianS16_BtoN(myRect.top);
			myRect.bottom = EndianS16_BtoN(myRect.bottom);
			myRect.right = EndianS16_BtoN(myRect.right);
			MacOffsetRect(&myRect, (short)-myRect.left, (short)-myRect.top);

			if (theImageType == kRecoProcOriginalImageType)
				ICUtils_DrawPictureNoDither(myData->picture, &myRect);
			break;
			
		default:
			myErr = -1;
	}

	return(myErr);
}	
	

//////////
//
// ICUtils_ImageCompressDrawProc
//
// Helper routine to be used with ICUtils_RecompressWithTransparencyFromProc to compress QuickTime compressed image data.
//
//////////

static PASCAL_RTN OSErr ICUtils_ImageCompressDrawProc (short theMessage, Rect *theRect, GWorldPtr theDrawingPort, OSType theImageType, void *theRefCon)
{
#if TARGET_OS_MAC
#pragma unused(theImageType)
#endif

	ICUtils_CompressedImageCompressProcData		*myData = theRefCon;
	Rect										myRect;
	OSErr										myErr = noErr;
	
	switch(theMessage) {
		case kRecoProcInitMsg:
			break;
			
		case kRecoProcDisposeMsg:
			break;
			
		case kRecoProcGetBoundsMsg:
			myRect.left = myRect.top = 0;
			myRect.right = (**myData->imageDesc).width;
			myRect.bottom = (**myData->imageDesc).height;
			
			*theRect = myRect;
			break;
			
		case kRecoProcDrawMsg:
			{
				SignedByte		mySavedState;
				
				myRect.left = myRect.top = 0;
				myRect.right = (**myData->imageDesc).width;
				myRect.bottom = (**myData->imageDesc).height;
				
				mySavedState = HGetState(myData->imageData);
				HLockHi(myData->imageData);
				
				if (theImageType == kRecoProcOriginalImageType)
					myErr = DecompressImage(*myData->imageData, myData->imageDesc, GetGWorldPixMap(theDrawingPort), &myRect, &myRect, srcCopy, NULL);
				
				HSetState(myData->imageData, mySavedState);
			}
			break;
			
		default:
			myErr = -1;
	}

	return(myErr);
}	


//////////
//
// ICUtils_RecompressCompressedImageWithTransparency
//
// Given an ImageDescriptionHandle and a handle to some image data, generate new RLE compressed data with
// optional hit-testing and transparency.
//
//////////

OSErr ICUtils_RecompressCompressedImageWithTransparency (
										ImageDescriptionHandle theOrigDesc,
										Handle theOrigImageData,
										RGBColor *theKeyColor, 
										RgnHandle theHitTestRegion,
										ImageDescriptionHandle *theImageDesc,
										Handle *theImageData)
{
	ICUtils_CompressedImageCompressProcData		myParams;
	OSErr 										myErr = noErr;
	
	myParams.imageDesc = theOrigDesc;
	myParams.imageData = theOrigImageData;
	
	myErr = ICUtils_RecompressWithTransparencyFromProc(
										ICUtils_ImageCompressDrawProc,
										&myParams, 
										(Boolean)(theHitTestRegion != NULL), 
										theKeyColor, 
										theHitTestRegion, 
										theImageDesc,
										theImageData);
	
	return(myErr);
}


//////////
//
// ICUtils_RecompressPictureWithTransparency
//
// Given a QuickDraw PicHandle, generate new RLE compressed data with optional hit-testing and transparency.
//
//////////

OSErr ICUtils_RecompressPictureWithTransparency (
										PicHandle theOrigPicture,
										RGBColor *theKeyColor, 
										RgnHandle theHitTestRegion,
										ImageDescriptionHandle *theImageDesc,
										Handle *theImageData)
{
	ICUtils_PictureCompressProcData		myParams;
	OSErr 								myErr = noErr;
	
	myParams.picture = theOrigPicture;
	
	myErr = ICUtils_RecompressWithTransparencyFromProc(
										ICUtils_PictureCompressDrawProc,
										&myParams, 
										(Boolean)(theHitTestRegion != NULL), 
										theKeyColor, 
										theHitTestRegion, 
										theImageDesc,
										theImageData);
	return(myErr);
}


//////////
//
// ICUtils_RecompressPictureFileWithTransparency
//
// Given a QuickDraw PICT file, generate new RLE compressed data with optional hit -testing and transparency.
// This function uses ICUtils_RecompressPictureWithTransparency to do the actual work on the PicHandle retrieved from
// the PICT file.
//
//////////

OSErr ICUtils_RecompressPictureFileWithTransparency (
										FSSpec *theFSSpec, 
										RGBColor *theKeyColor, 
										RgnHandle theHitTestRegion,
										ImageDescriptionHandle *theImageDesc,
										Handle *theImageData)
{
	short		myRefNum = 0;
	PicHandle	myPicture = NULL;
	long		myEOF;
	long		myCount;
	OSErr 		myErr = noErr;
	
	*theImageDesc = NULL;
	*theImageData = NULL;	
	
	myErr = FSpOpenDF(theFSSpec, fsRdPerm, &myRefNum);
	if (myErr != noErr)
		goto bail;
	
	myErr = GetEOF(myRefNum, &myEOF);
	if (myErr != noErr)
		goto bail;
	myEOF -= 512;
	
	myErr = SetFPos(myRefNum, fsFromStart, 512);
	if (myErr != noErr)
		goto bail;
			
	myPicture = (PicHandle)NewHandle(myEOF);
	myErr = MemError();
	if (myErr != noErr)
		goto bail;

	myCount = myEOF;
	HLock((Handle)myPicture);
	
	myErr = FSRead(myRefNum, &myCount, *myPicture);
	if (myErr != noErr)
		goto bail;
	
	HUnlock((Handle)myPicture);
	
	myErr = ICUtils_RecompressPictureWithTransparency(myPicture, theKeyColor, theHitTestRegion, theImageDesc, theImageData);
								
bail:
	if (myPicture != NULL)
		DisposeHandle((Handle)myPicture);
		
	if (myRefNum != 0)
		FSClose(myRefNum);
		
	return(myErr);
}

