/*
 * MiniMPEG4.c
 *
 * Main file for MPEG4
 *
 * This wizard-generated code is based on code adapted from the
 * stationery files distributed as part of the Palm OS SDK 4.0.
 *
 * Copyright (c) 1999-2004 PalmOne, Inc. or its subsidiaries.
 * All rights reserved.
 */
 
#include <PalmOS.h>
#include <VFSMgr.h>
#include <MemGlue.h>
#include <HsNav.h>
#include "Common.h"
#include "MiniMPEG4.h"
#include "MiniMPEG4Rsc.h"
#include "FileBrowserForm.h"
#include "FileBrowserFormRsrc.h"
#include "PalmOneCodecPluginMgr.h"
#include "PalmOneCodecFormat.h"
#include "ColorButtonGadget.h"
#include "PalmLcdOverlay.h"
#include "PalmOneCamera.h"

#define ourMinVersion    sysMakeROMVersion(3,0,0,sysROMStageDevelopment,0)
#define kPalmOS20Version sysMakeROMVersion(2,0,0,sysROMStageDevelopment,0)

#define Allocate(n)	MemPtrNew(n)

#define DATA_BUFFER_SIZE	16384
#define USE_RATE_CONTROL	1

/** Holds basic encoder/decoder info. */
typedef struct {
	Char	inputFileName[256];
	Char	outputFileName[256];
	
	FileRef inputFileRef;
	FileRef outputFileRef;
	
	UInt32 	width;
	UInt32 	height;
	UInt32 	frameRate;
	UInt32 	bitRate;
	UInt32 	keyFrame;
	UInt32 	IQuantization;
	UInt32	searchRange;
	
	UInt16 	codecMgrLibRefNum;
	PalmCodecSession session;
	UInt32 imageFormat;

	Boolean loadFileInMemory;
	Boolean outputToSD;
	Boolean encoding;
	Boolean	loop;
	
} MPEG4Info;

#if 0
#pragma mark Globals
#endif

/** Internal Globals. */
static MPEG4Info 	gMPEG4Info;
static UInt32		gFrameCount	= 0;
static UInt32		gStartTicks	= 0;
static UInt32		gLastTick	= 0;
static UInt32		gRateControl= 0;

static Char			*gGOButtonLabel[] = { "Go", "Stop" };
static Char			gLoadingText[] = "Loading";

static UInt32	gScreenDepth = 16;
static UInt32	gPreviousScreenDepth = 0;

RGBColorType	gStartColor = { 0, 255, 255, 255 };
RGBColorType	gEndColor = { 0, 0, 0, 255 };

static const RGBColorType	gWhite = { 0, 255, 255, 255 };
static const RGBColorType	gBlack = { 0, 0, 0, 0 };

// Extra
static UInt16	gLCDOverlayRefNum = sysInvalidRefNum;
static Boolean	gUseOverlay = true;
//static UInt16	gCameraRefNum = sysInvalidRefNum;

#if 0
#pragma mark -
#endif


/***********************************************************************
 *
 * FUNCTION:    		HandleMenu
 *
 * DESCRIPTION: 		Deals with menu commands issued
 *
 * PARAMETERS:  		itemID -> ID of the Menu which has been selected
 *
 * RETURNED:    		Nothing
 *
 * REVISION HISTORY:
 *
 *
 ***********************************************************************/
static void HandleMenu(UInt16 itemID)
{
	FormType *frmAboutP = NULL;
	
	switch(itemID)
	{		
		case AboutForm:
			frmAboutP = FrmInitForm(AboutForm);
			FrmDoDialog(frmAboutP);					// Display the About Box.
			FrmDeleteForm(frmAboutP);
			
			break;
			
	}
}


/**
 * Read and Encode the parameters
 */
static Err PrvReadParameters(Boolean encoding)
{
	Err err = errNone;
	FieldType *fldP = NULL;
	FormType *frmP = FrmGetActiveForm();
	
	// Get the width & height
	fldP = FrmGetPtr(frmP, MainWidthField);
	if(FldGetTextPtr(fldP))
		gMPEG4Info.width = StrAToI(FldGetTextPtr(fldP));
	fldP = FrmGetPtr(frmP, MainHeightField);
	if(FldGetTextPtr(fldP))
		gMPEG4Info.height = StrAToI(FldGetTextPtr(fldP));
		
	// Read the file names
	
	fldP = FrmGetPtr(frmP, MainInputField);
	if (FldGetTextPtr(fldP))
		StrCopy(gMPEG4Info.inputFileName, FldGetTextPtr(fldP));
	else
		StrCopy(gMPEG4Info.inputFileName, "");
	fldP = FrmGetPtr(frmP, MainOutputField);
	
		StrCopy(gMPEG4Info.outputFileName, FldGetTextPtr(fldP));
	// Get the SearchRange & BitRate
	fldP = FrmGetPtr(frmP, MainSearchRangeField);
	if(FldGetTextPtr(fldP))
		gMPEG4Info.searchRange = StrAToI(FldGetTextPtr(fldP));
	fldP = FrmGetPtr(frmP, MainBitRateField);
	if(FldGetTextPtr(fldP))
		gMPEG4Info.bitRate = StrAToI(FldGetTextPtr(fldP));
		
	// Get the KeyFrame & IQuantization
	fldP = FrmGetPtr(frmP, MainKeyFrameField);
	if(FldGetTextPtr(fldP))
		gMPEG4Info.keyFrame = StrAToI(FldGetTextPtr(fldP));
	fldP = FrmGetPtr(frmP, MainIQuantizationField);
	if(FldGetTextPtr(fldP))
		gMPEG4Info.IQuantization = StrAToI(FldGetTextPtr(fldP));
	
//Done:	
	return err;
}

/**
 * Open input file
 */
static Err PrvFileOpenInput()
{
	Err err = errNone;
	UInt32 volumeIterator = 0;
	UInt16 firstVolume = 0;
	
	// Get first card
	volumeIterator = vfsIteratorStart;
	err = VFSVolumeEnumerate(&firstVolume, &volumeIterator);
	if( err == expErrEnumerationEmpty ) {
		goto Done;
	}
	
	// If we have a file path, open the file
	if(gMPEG4Info.inputFileName[0]!=NULL)
	{
		err = VFSFileOpen(firstVolume, gMPEG4Info.inputFileName, vfsModeRead, &gMPEG4Info.inputFileRef);
		if( err ) goto Done;
	}

Done:	
	return err;
}

/**
 * Open output file
 */
static Err PrvFileOpenOutput()
{
	Err err = errNone;
	UInt32 volumeIterator = 0;
	UInt16 firstVolume = 0;
	
	// Get first card
	volumeIterator = vfsIteratorStart;
	err = VFSVolumeEnumerate(&firstVolume, &volumeIterator);
	if( err == expErrEnumerationEmpty ) {
		goto Done;
	}
	
	// If we have a file path, open the file
	if(gMPEG4Info.outputFileName[0]!=NULL)
	{
		err = VFSFileOpen(firstVolume, gMPEG4Info.outputFileName, vfsModeWrite|vfsModeCreate|vfsModeTruncate, &gMPEG4Info.outputFileRef);
		if( err ) goto Done;
	}

Done:	
	return err;
}

/**
 * File info callback.
 * This function is called by the file browser
 */
static void PrvGetInputFileInfoCallback(UInt16 volume, const Char* path, const Char* file)
{
	// Create the full path name
	StrCopy(gMPEG4Info.inputFileName, path);

	// Internally, we expect full path
	StrCat(gMPEG4Info.inputFileName, file);
}

/**
 * Load a file in memory.
 * Draws a fill rectangle with specified colors.
 *
 */
static UInt32 PrvLoadFileInMemory(FileRef srcFile, UInt32 inputBufferSize, UInt8 *fileBufferP, Boolean useFtr)
{
	UInt32 read = 0;
	UInt32 total = 0;
	UInt32 current = 0;
	UInt32 xPosition = 80 - FntCharsWidth(gLoadingText, StrLen(gLoadingText)) / 2;
	RGBColorType oldColor;
	EventType event;
	UInt8 *tempBufferP = NULL;
	RectangleType goButtonBounds;
	WinDrawOperation oldOperation;
	UInt32 toRead = inputBufferSize / 100;
	RectangleType rect = { { 30, 147 }, { 1, 10 } };
	RGBColorType color = { 0, 0, 0, 0 };
	Int32 R, G, B;
	Int32 sR, sG, sB;
	Err err=errNone;
	
	
	// FtrPtrNew - Allocate temporary buffer
	if(useFtr) {
		tempBufferP = MemPtrNew(4096);
	}
	
	// Save old color
	WinSetBackColorRGB(&color, &oldColor);
	
	R = (UInt32)gStartColor.r << 8; G = (UInt32)gStartColor.g << 8; B = (UInt32)gStartColor.b << 8;
	
	// Color steps
	sR = (((Int32)gEndColor.r - (Int32)gStartColor.r) << 8) / 101;
	sG = (((Int32)gEndColor.g - (Int32)gStartColor.g) << 8) / 101;
	sB = (((Int32)gEndColor.b - (Int32)gStartColor.b) << 8) / 101;
	
	// Get the bounds for the Go button
	FrmGetObjectBounds(FrmGetActiveForm(), FrmGetObjectIndex(FrmGetActiveForm(),MainGoButton), &goButtonBounds);
	
	while(1)
	{
		EvtGetEvent(&event, 0);
		if(event.eType == penDownEvent && RctPtInRectangle(event.screenX, event.screenY, &goButtonBounds)) {
			total = 0;
			goto Done;
		}
			
		if(useFtr) {
			err=VFSFileRead(srcFile, 4096, tempBufferP, &read);
			DmWrite(fileBufferP, total, tempBufferP, read);
		} else {
			err=VFSFileRead(srcFile, toRead, fileBufferP, &read);
			fileBufferP += read;
		}

		if(err!=errNone) break;
		
		if(!read)
			break;
		
		total += read;
	
		current = (total * 100) / inputBufferSize + 31;
		
		if( current > rect.topLeft.x)
		{
			R += sR; G += sG; B += sB;
			if(R < 0) R = 0; if(R > 65536) R = 65536;
			if(G < 0) G = 0; if(G > 65536) G = 65536;
			if(B < 0) B = 0; if(B > 65536) B = 65536;
			color.r = R >> 8;
			color.g = G >> 8;
			color.b = B >> 8;
					
			WinSetBackColorRGB(&color, NULL);
			WinFillRectangle(&rect, 0);
			oldOperation = WinSetDrawMode(winOverlay);
			WinPaintChars(gLoadingText, StrLen(gLoadingText), xPosition, 146);
			WinSetDrawMode(oldOperation);		
			rect.topLeft.x = current;
		}
	}

Done:
	if(tempBufferP)
		MemPtrFree(tempBufferP);
	WinSetBackColorRGB(&oldColor, NULL);
	return total;
}

/**
 * Update the current UI
 * Displays the frmae count, the average FPS and the current FPS
 */
static void PrvUpdateUI()
{
	Char text[32];
	FieldType *fldP = NULL;
	UInt32 curTicks =  TimGetTicks();
	UInt32 fps = curTicks - gStartTicks;
	
	if(fps)
		fps = (sysTicksPerSecond * gFrameCount) / fps;
	
	// Average FPS
	StrIToA(text, fps);
	fldP = FrmGetPtr(FrmGetActiveForm(), MainAverageFPSField);
	SetFieldTextFromStr(fldP, text, true);
	
	// Current FPS
	fps = ( curTicks - gLastTick );
	if(fps)
		fps = sysTicksPerSecond / fps;
	
	StrIToA(text, fps);
	fldP = FrmGetPtr(FrmGetActiveForm(), MainCurrentFPSField);
	SetFieldTextFromStr(fldP, text, true);
	
	gLastTick = curTicks;
	
	// Current Frame Count
	StrPrintF(text, "%04ld", gFrameCount);
	fldP = FrmGetPtr(FrmGetActiveForm(), MainFramesField);
	SetFieldTextFromStr(fldP, text, true);
}

/**
 * DrawLaoding rectangle
 */
static void PrvDrawLoadingRect()
{
	RGBColorType oldColor;
	RectangleType rect = { { 30, 147 }, { 101, 10 } };
	
	// Draw the progress bar
	WinSetForeColorRGB(&gWhite, &oldColor);
	WinDrawRectangle(&rect, 0);
	WinSetForeColorRGB(&gBlack, NULL);
	WinDrawRectangleFrame(rectangleFrame, &rect);
	
	// Restore
	WinSetForeColorRGB(&oldColor, NULL);
}

#if 0
#pragma mark -
#endif

/**
 * Load a frame from memory.
 */
static void PrvLoadFrameFromMemory(UInt8 *bufferP, PalmImagePlanarType *planarImage, UInt32 imageFormat)
{
	switch(imageFormat)
	{
		case palmCodecImageYCbCr420Planar:
			planarImage->planeP[0] = bufferP;
			bufferP += planarImage->width * planarImage->height;
			planarImage->planeP[1] = bufferP;
			bufferP += planarImage->width * planarImage->height / 4;
			planarImage->planeP[2] = bufferP;
			break;
			
		case palmCodecImageYCbCr422Planar:
			planarImage->planeP[0] = bufferP;
			bufferP += planarImage->width * planarImage->height;
			planarImage->planeP[1] = bufferP;
			bufferP += planarImage->width * planarImage->height / 2;
			planarImage->planeP[2] = bufferP;
			break;
	}	
}

/**
 * Laos a frame from file
 */
static Err PrvLoadFrameFromFile(FileRef fileRef, PalmImagePlanarType *planarImage, UInt32 imageFormat)
{
	Err 	err = errNone;
	UInt32	read = 0;
//	UInt32 	width = 0;
	UInt32 	height = 0;
	UInt32	YHeight = 0;
	UInt32	YWidth = 0;
	UInt32	CHeight = 0;
	UInt32	CWidth = 0;
	UInt8	*planeP = NULL;	
	
	switch(imageFormat)
	{
		case palmCodecImageYCbCr420Planar:
			YWidth 	= planarImage->width;
			YHeight = planarImage->height;
			CWidth 	= planarImage->width / 2;
			CHeight = planarImage->height / 2;
			break;
			
		case palmCodecImageYCbCr422Planar:
			YWidth 	= planarImage->width;
			YHeight = planarImage->height;
			CWidth	= planarImage->width / 2;
			CHeight	= planarImage->height;
			break;
		
		default:
			err = appErrorClass;
			goto Done;
	}
	
	// Load the Y components
	planeP = planarImage->planeP[0];
	for(height = 0; height < YHeight; height++)
	{
		err = VFSFileRead(fileRef, YWidth, planeP, &read);
		if(err || read != YWidth) {
			err = vfsErrFileEOF; 
			goto Done;
		}	
		planeP += YWidth;
	}
	
	// Load the Cb components
	planeP = planarImage->planeP[1];
	for(height = 0; height < CHeight; height++)
	{
		err = VFSFileRead(fileRef,CWidth, planeP, &read);
		if(err || read != CWidth) {
			err = vfsErrFileEOF;
			goto Done;
		}
		planeP += CWidth;
	}
	
	// Load the Cr components
	planeP = planarImage->planeP[2];
	for(height = 0; height < CHeight; height++)
	{
		err = VFSFileRead(fileRef, CWidth, planeP, &read);
		if(err || read != CWidth) {
			err = vfsErrFileEOF;
			goto Done;
		}
		planeP += CWidth;
	}
	
Done:
	return err;
}

#if 0
#pragma mark -
#endif


/**
 * Run the MPEG4 Decoder
 *
 * The loop option is done by resetting the decoder since the
 * next loop will have to read again the VO & VOL header.
 */
static Err PrvStartDecoder()
{
	Err err = errNone;
	EventType event;
	UInt32 inSize = 0;
	UInt32 outSize = 0;
	Boolean useFtr = false;
	UInt32 inputBufferSize = 0;
	UInt8 *inputBufferP = NULL;
	UInt8 *currentBufferP = NULL;
//	UInt8 *offScreenP = NULL;
//	WinHandle offScreenH = NULL;
	RectangleType goButtonBounds;
	PalmImagePlanarType planarImage;
	PalmImagePlanarType *swapImageP = NULL;
	PalmImageParamType *imageParamP = NULL;
	UInt32 read = 0;
	
	// Make sure atack data is clean
	MemSet(&planarImage, sizeof(PalmImagePlanarType), 0);
	
	// Read parameters and check
	err = PrvReadParameters(false);
	if(err)
		goto Done;
		
	// Open the input and output files
	err = PrvFileOpenInput();
	if(err)
		goto Done;
	
	if(gMPEG4Info.outputToSD) {	
		err = PrvFileOpenOutput();
		if(err)
			goto Done;
	}
	
	// Allocate image structure	
	imageParamP = (PalmImageParamType*)MemPtrNew(sizeof(PalmImageParamType));
	if(!imageParamP) {
		err = memErrNotEnoughSpace;
		FrmCustomAlert(ErrorAlert, "Not enough memory", NULL, NULL);
		goto Done;
	}
	MemSet(imageParamP, sizeof(PalmImageParamType), 0);
	
	// Allocate swap image	
	swapImageP = (PalmImagePlanarType*)MemPtrNew(sizeof(PalmImagePlanarType));
	if(!swapImageP) {
		err = memErrNotEnoughSpace;
		FrmCustomAlert(ErrorAlert, "Not enough memory", NULL, NULL);
		goto Done;
	}
	MemSet(swapImageP, sizeof(PalmImagePlanarType), 0);
	
	// Set Image Params
	imageParamP->width = 0; // Don't care
	imageParamP->height = 0; // Don't care
	imageParamP->rowByte = 0; // Don't care
	imageParamP->endianess = 0; // Don't care
	
	// Create the MPEG4 Decoding session
	//err = CodecMgrCreateSession(gMPEG4Info.codecMgrLibRefNum,  palmCodecVideoMPEG4, NULL, gMPEG4Info.imageFormat, imageParamP, &gMPEG4Info.session);	
	err = CodecMgrCreateSessionByID(gMPEG4Info.codecMgrLibRefNum, palmCodecVideoMPEG4, NULL, gMPEG4Info.imageFormat, imageParamP, 'mp4d', 0, &gMPEG4Info.session);
	if(err) {
		FrmCustomAlert(ErrorAlert, "Unable to create session", NULL, NULL);
		goto Done;
	}
	
	// Set the planar image
	planarImage.width = gMPEG4Info.width;
	planarImage.height = gMPEG4Info.height;
	planarImage.planeCount = 3;
	
	switch(gMPEG4Info.imageFormat)
	{
		case palmCodecImageYCbCr420Planar:
			planarImage.planeP[0] = Allocate( (3 * planarImage.width * planarImage.height) / 2);
			planarImage.planeP[1] = (UInt8*)planarImage.planeP[0] + planarImage.width * planarImage.height;
			planarImage.planeP[2] = (UInt8*)planarImage.planeP[1] + (planarImage.width * planarImage.height / 4);
			planarImage.planeWidth[0] = planarImage.width;
			planarImage.planeWidth[1] = planarImage.width / 2;
			planarImage.planeWidth[2] = planarImage.width / 2;
			break;
			
		default:
			FrmCustomAlert(ErrorAlert, "Bad image format", NULL, NULL);
			goto Done;
			break;
	}
	
	if(!planarImage.planeP[0]) {
		err = memErrNotEnoughSpace;
		FrmCustomAlert(ErrorAlert, "Not enough memory", NULL, NULL);
		goto Done;
	}
	
	// Use a byte-swapped copy for the CPM
	swapImageP->width = Swap32(planarImage.width);
	swapImageP->height = Swap32(planarImage.height);
	swapImageP->planeCount = Swap32(planarImage.planeCount);
	swapImageP->planeP[0] = (void*)Swap32(planarImage.planeP[0]);
	swapImageP->planeP[1] = (void*)Swap32(planarImage.planeP[1]);
	swapImageP->planeP[2] = (void*)Swap32(planarImage.planeP[2]);	
	swapImageP->planeWidth[0] = Swap32(planarImage.planeWidth[0]);
	swapImageP->planeWidth[1] = Swap32(planarImage.planeWidth[1]);
	swapImageP->planeWidth[2] = Swap32(planarImage.planeWidth[2]);
	
	// Running from file
	if(gMPEG4Info.loadFileInMemory)
	{	
		// Get the file size
		err = VFSFileSize(gMPEG4Info.inputFileRef, &inputBufferSize);	
		if(err || !inputBufferSize)
			goto Done;
				
		currentBufferP = inputBufferP = (UInt8*)Allocate(inputBufferSize);
		if(!inputBufferP) {
			// Try with FtrPtr
			err = FtrPtrNew(appFileCreator, 0, inputBufferSize, (void*)&inputBufferP);
			if(err) {
				err = memErrNotEnoughSpace;
				FrmCustomAlert(ErrorAlert, "Not enough memory", NULL, NULL);
				goto Done;
			}
			
			currentBufferP = inputBufferP;
			useFtr = true;
		}
		
		// Load the file
		if(!PrvLoadFileInMemory(gMPEG4Info.inputFileRef, inputBufferSize, inputBufferP, useFtr))
			goto Done;
	}
	else
	{
		// Allocate buffer for VFS
		inputBufferP = (UInt8*)Allocate(DATA_BUFFER_SIZE);
		
		// Load first input buffer
		currentBufferP = inputBufferP;
		err = VFSFileRead(gMPEG4Info.inputFileRef, DATA_BUFFER_SIZE, inputBufferP, &inputBufferSize);
		if(err)
			goto Done;
	}
	
	// Get the bounds for the Go button
	FrmGetObjectBounds(FrmGetActiveForm(), FrmGetObjectIndex(FrmGetActiveForm(),MainGoButton), &goButtonBounds);
	
		
	// LCD Overlay
	if( gUseOverlay)
	{
		LcdOverlayLibSettingType overlaySetting;
		RectangleType rect = { { 0, 0 }, { 0, 0 } };
		
		rect.extent.x = planarImage.width / 2;
		rect.extent.y = planarImage.height / 2;
		
		overlaySetting.type = kLcdOverlayLibDataFormatYCbCr420Planar;
		err = LcdOverlayLibControl(gLCDOverlayRefNum, kLcdOverlayLibCtrlFormatSet, (void*)&overlaySetting);
		err |= LcdOverlayLibControl(gLCDOverlayRefNum, kLcdOverlayLibCtrlRectSet, &rect);
		err |= LcdOverlayLibControl(gLCDOverlayRefNum, kLcdOverlayLibCtrlStart, NULL);
		
		if(err) {
			FrmCustomAlert(ErrorAlert, "LCD Overlay Init failed!!!", NULL, NULL);
			goto Done;
		}
	}

	
	// Get the current time here we we go!
	gFrameCount = 0;
	gRateControl = sysTicksPerSecond / 15; // Rate control: 15 FPS
	gStartTicks = gLastTick = TimGetTicks();

	// Decode Frames
	while(true)
	{
		// Set input params		
		inSize = inputBufferSize;
		outSize = sizeof(PalmImagePlanarType);
		
		// Check the event queue
		EvtGetEvent(&event, 0);
		if(event.eType == penDownEvent && RctPtInRectangle(event.screenX, event.screenY, &goButtonBounds))
			goto Done;
		
		// Decode a frame
		err = CodecMgrEncodeDecode(gMPEG4Info.codecMgrLibRefNum, gMPEG4Info.session, currentBufferP, &inSize, swapImageP, &outSize);
		
		
		
		switch(err)
		{	
			//UInt32 read = 0;
			
			case kCodecSyncNotFound:
				if(gMPEG4Info.loadFileInMemory) {
					if(gMPEG4Info.loop)
					{
						err=VFSFileSize(gMPEG4Info.inputFileRef, &inputBufferSize);	
						if(err!=errNone) return err;
						currentBufferP = inputBufferP;
						err = CodecMgrResetSession(gMPEG4Info.codecMgrLibRefNum, gMPEG4Info.session);
					}
					else
					{
						FrmCustomAlert(InfoAlert, "Decoding done!", NULL, NULL);
						goto Done;
					}
				} else {
					// Reload the buffer
					MemMove(inputBufferP, currentBufferP, inputBufferSize);
					err = VFSFileRead(gMPEG4Info.inputFileRef, DATA_BUFFER_SIZE - inputBufferSize, inputBufferP + inputBufferSize, &read);
					if(!read) {
						if(gMPEG4Info.loop)
						{
							VFSFileSeek(gMPEG4Info.inputFileRef, vfsOriginBeginning, 0);	
							currentBufferP = inputBufferP;
							err=VFSFileRead(gMPEG4Info.inputFileRef, DATA_BUFFER_SIZE, inputBufferP, &inputBufferSize);
							if(err!=errNone) return err;
							err = CodecMgrResetSession(gMPEG4Info.codecMgrLibRefNum, gMPEG4Info.session);
						}
						else
						{
							if(gUseOverlay)
								err = LcdOverlayLibControl(gLCDOverlayRefNum, kLcdOverlayLibCtrlStop, NULL);
							FrmCustomAlert(InfoAlert, "Decoding done!", NULL, NULL);
							goto Done;
						}
					}
					// Set current buffer
					inputBufferSize += read;
					currentBufferP = inputBufferP;
				}				
				
				break;
				
			// Real error
			case kCodecMgrLibNotSupported:
			case kCodecErrBadParam:
				if(gUseOverlay)
					err = LcdOverlayLibControl(gLCDOverlayRefNum, kLcdOverlayLibCtrlStop, NULL);
				FrmCustomAlert(InfoAlert, "Decoding done!", NULL, NULL);
				goto Done;
				
			default:
				break;
		}
				
		// Update the input buffer size
		inputBufferSize -= inSize;
		currentBufferP += inSize;
		
		// Update the Frame counter
		if(outSize)
		{
			gFrameCount++;
			
			if(gUseOverlay)
			{
				err = LcdOverlayLibControl(gLCDOverlayRefNum, kLcdOverlayLibCtrlDraw, planarImage.planeP[0]);
			}
			
			if(gMPEG4Info.outputToSD)
			{
				UInt32 written = 0;
				UInt32 YSize = planarImage.width * planarImage.height;
				UInt32 CSize = planarImage.width * planarImage.height / 4;
				
				// Write the Y components
				err = VFSFileWrite(gMPEG4Info.outputFileRef, YSize, planarImage.planeP[0], &written);
				if(err || written != YSize) {
					FrmCustomAlert(ErrorAlert, "Error during file write!", NULL, NULL);
					goto Done;
				}
				// Write the Cb components
				err = VFSFileWrite(gMPEG4Info.outputFileRef, CSize, planarImage.planeP[1], &written);
				if(err || written != CSize) {
					FrmCustomAlert(ErrorAlert, "Error during file write!", NULL, NULL);
					goto Done;
				}
				// Write the Cr components
				err = VFSFileWrite(gMPEG4Info.outputFileRef, CSize, planarImage.planeP[2], &written);
				if(err || written != CSize) {
					FrmCustomAlert(ErrorAlert, "Error during file write!", NULL, NULL);
					goto Done;
				}
			}
		}
	
#if USE_RATE_CONTROL == 1
		if((TimGetTicks() - gLastTick) < gRateControl)
			SysTaskDelay(gRateControl - TimGetTicks() + gLastTick);
#endif
		
		// Update the UI frame count
		PrvUpdateUI();
	}
			
Done:
//DEADCODE, not reachable
//	if(offScreenH)
//		WinDeleteWindow(offScreenH, false);
	if(inputBufferP){
		if(useFtr)	
			FtrPtrFree(appFileCreator, 0);
		else
			MemPtrFree(inputBufferP);
	}
	if(planarImage.planeP[0])
		MemPtrFree(planarImage.planeP[0]);

	if(imageParamP)
		MemPtrFree(imageParamP);

	if(swapImageP)
		MemPtrFree(swapImageP);
		
	// Close overlay
	if( gUseOverlay)
		err = LcdOverlayLibControl(gLCDOverlayRefNum, kLcdOverlayLibCtrlStop, NULL);
				
	// Delete the session
	if(gMPEG4Info.session)
		CodecMgrDeleteSession(gMPEG4Info.codecMgrLibRefNum, &gMPEG4Info.session);
	
	// Close files
	if(gMPEG4Info.inputFileRef) {
		VFSFileClose(gMPEG4Info.inputFileRef);
		gMPEG4Info.inputFileRef = NULL;
	}
	
    if(gMPEG4Info.outputFileRef) {
    	VFSFileClose(gMPEG4Info.outputFileRef);
    	gMPEG4Info.outputFileRef = NULL;
    }
    
    // Quick refresh
    if(gUseOverlay)
	    FrmDrawForm(FrmGetActiveForm());
    		
	return err;
}

/**
 * Run the MPEG4 Encoder
 *
 * The loop option is done by simply rewinding the file or stream.
 */
static Err PrvStartEncoder()
{
	Err err = errNone;
	EventType event;
	Boolean useFtr = false;
	UInt32 inSize = 0;
	UInt32 outSize = 0;
	UInt32 inputBufferSize = 0;
	UInt32 fileOffset = 0;
	UInt8 *inputBufferP = NULL;
	UInt8 *outputBufferP = NULL;
	UInt8 *savedPlaneP[3] = { NULL, NULL, NULL };
	RectangleType goButtonBounds;
	PalmImagePlanarType planarImage;
	PalmImagePlanarType *swapImageP = NULL;
	PalmImageParamType *imageParamP = NULL;
	PalmVideoMPEG4EncodeParamType *mpeg4ParamP = NULL;
	
	// Make sure atack data is clean
	MemSet(&planarImage, sizeof(PalmImagePlanarType), 0);
	
	// Read parameters and check
	err = PrvReadParameters(false);
	if(err)
		goto Done;
		
	// Open the input and output files
	err = PrvFileOpenInput();
	if(err)
		goto Done;
	
	if(gMPEG4Info.outputToSD) {	
		err = PrvFileOpenOutput();
		if(err)
			goto Done;
	}
	
	// Allocate image structure	
	imageParamP = (PalmImageParamType*)MemPtrNew(sizeof(PalmImageParamType));
	if(!imageParamP) {
		err = memErrNotEnoughSpace;
		FrmCustomAlert(ErrorAlert, "Not enough memory", NULL, NULL);
		goto Done;
	}
	MemSet(imageParamP, sizeof(PalmImageParamType), 0);
	
	// Allocate swap image	
	swapImageP = (PalmImagePlanarType*)MemPtrNew(sizeof(PalmImagePlanarType));
	if(!swapImageP) {
		err = memErrNotEnoughSpace;
		FrmCustomAlert(ErrorAlert, "Not enough memory", NULL, NULL);
		goto Done;
	}
	MemSet(swapImageP, sizeof(PalmImagePlanarType), 0);
	
	// Allocate MPEG4 param	
	mpeg4ParamP = (PalmVideoMPEG4EncodeParamType*)MemPtrNew(sizeof(PalmVideoMPEG4EncodeParamType));
	if(!mpeg4ParamP) {
		err = memErrNotEnoughSpace;
		FrmCustomAlert(ErrorAlert, "Not enough memory", NULL, NULL);
		goto Done;
	}
	MemSet(mpeg4ParamP, sizeof(PalmVideoMPEG4EncodeParamType), 0);
	
	// Set Image Params
	imageParamP->width = Swap32(gMPEG4Info.width);
	imageParamP->height = Swap32(gMPEG4Info.height);
	imageParamP->rowByte = 0; // Don't care
	imageParamP->endianess = 0; // Don't care
	
	// Set MPEG4 Params 
	mpeg4ParamP->profile = 0; // Don't care for now
	mpeg4ParamP->volWidth = Swap32(gMPEG4Info.width);
	mpeg4ParamP->volHeight = Swap32(gMPEG4Info.height);
	mpeg4ParamP->keyFrame =  Swap32(gMPEG4Info.keyFrame);
	mpeg4ParamP->frameRate = Swap32(gMPEG4Info.frameRate);
	mpeg4ParamP->bitRate = Swap32(gMPEG4Info.bitRate);
	mpeg4ParamP->algorithm = Swap32(palmCodecMPEG4MVFAST);
	mpeg4ParamP->IVOPQuantization = Swap32(gMPEG4Info.IQuantization);
	mpeg4ParamP->VOVOLVersionID = Swap32(2);
	
	// Set the planar image
	planarImage.width = gMPEG4Info.width;
	planarImage.height = gMPEG4Info.height;
	switch(gMPEG4Info.imageFormat)
	{
		case palmCodecImageYCbCr420Planar:
			planarImage.planeP[0] = Allocate(planarImage.width * planarImage.height);
			planarImage.planeP[1] = Allocate(planarImage.width * planarImage.height / 4);
			planarImage.planeP[2] = Allocate(planarImage.width * planarImage.height / 4);
			planarImage.planeWidth[0] = planarImage.width;
			planarImage.planeWidth[1] = planarImage.width / 2;
			planarImage.planeWidth[2] = planarImage.width / 2;
			break;
			
		case palmCodecImageYCbCr422Planar:
			planarImage.planeP[0] = Allocate(planarImage.width * planarImage.height);
			planarImage.planeP[1] = Allocate(planarImage.width * planarImage.height / 2);
			planarImage.planeP[2] = Allocate(planarImage.width * planarImage.height / 2);
			planarImage.planeWidth[0] = planarImage.width;
			planarImage.planeWidth[1] = planarImage.width / 2;
			planarImage.planeWidth[2] = planarImage.width / 2;
			break;
			
		default:
			FrmCustomAlert(ErrorAlert, "Bad image format", NULL, NULL);
			goto Done;
			break;
	}
	
	// Check for memory 
	if(!planarImage.planeP[0] || !planarImage.planeP[1] || !planarImage.planeP[2]) {
		err = memErrNotEnoughSpace;
		FrmCustomAlert(ErrorAlert, "Not enough memory", NULL, NULL);
		goto Done;
	}
	
	// Save plane pointers since they can be modified
	savedPlaneP[0] = planarImage.planeP[0];
	savedPlaneP[1] = planarImage.planeP[1];
	savedPlaneP[2] = planarImage.planeP[2];
	
	// Create a copy for the CPM
	swapImageP->width = Swap32(planarImage.width);
	swapImageP->height = Swap32(planarImage.height);
	swapImageP->planeP[0] = (void*)Swap32(planarImage.planeP[0]);
	swapImageP->planeP[1] = (void*)Swap32(planarImage.planeP[1]);
	swapImageP->planeP[2] = (void*)Swap32(planarImage.planeP[2]);
	swapImageP->planeWidth[0] = Swap32(planarImage.planeWidth[0]);
	swapImageP->planeWidth[1] = Swap32(planarImage.planeWidth[1]);
	swapImageP->planeWidth[2] = Swap32(planarImage.planeWidth[2]);
		
	// Create the MPEG4 Encoding session
	err = CodecMgrCreateSession(gMPEG4Info.codecMgrLibRefNum, gMPEG4Info.imageFormat, imageParamP, palmCodecVideoMPEG4, mpeg4ParamP, &gMPEG4Info.session);
	if(err) {
		FrmCustomAlert(ErrorAlert, "Unable to create session", NULL, NULL);
		goto Done;
	}
	
	// Allocate output buffer	
	outputBufferP = (UInt8*)Allocate(planarImage.width * planarImage.height * 2);
	if(!outputBufferP) {
		err = memErrNotEnoughSpace;
		FrmCustomAlert(ErrorAlert, "Not enough memory", NULL, NULL);
		goto Done;
	}
	MemSet(mpeg4ParamP, sizeof(PalmVideoMPEG4EncodeParamType), 0);
	
	// Running from file
	if(gMPEG4Info.loadFileInMemory)
	{	
		// Get the file size
		err = VFSFileSize(gMPEG4Info.inputFileRef, &inputBufferSize);	
		if(err || !inputBufferSize)
			goto Done;
		
		// Might work....	
		inputBufferP = (UInt8*)Allocate(inputBufferSize);
		if(!inputBufferP) {
		
			// Try with FtrPtr
			err = FtrPtrNew(appFileCreator, 0, inputBufferSize, (void*)&inputBufferP);
			if(err) {
				err = memErrNotEnoughSpace;
				FrmCustomAlert(ErrorAlert, "Not enough memory", NULL, NULL);
				goto Done;
			}
			
			useFtr = true;
		}
		
		
		// Load the file
		if(!PrvLoadFileInMemory(gMPEG4Info.inputFileRef, inputBufferSize, inputBufferP, useFtr))
			goto Done;
	}
	
	// Get the bounds for the Go button
	FrmGetObjectBounds(FrmGetActiveForm(), FrmGetObjectIndex(FrmGetActiveForm(),MainGoButton), &goButtonBounds);
	
	// Get the current time here we we go!
	gFrameCount = 0;
	gStartTicks = gLastTick = TimGetTicks();

	// Decode Frames
	while(true)
	{
		// Load raw data from input file
		if(gMPEG4Info.loadFileInMemory)
		{
			if( gMPEG4Info.loop && fileOffset < inputBufferSize)
				fileOffset = 0;
			
			if( fileOffset < inputBufferSize )
			{
				PrvLoadFrameFromMemory(inputBufferP + fileOffset, &planarImage, gMPEG4Info.imageFormat);
				swapImageP->planeP[0] = (void*)Swap32(planarImage.planeP[0]);
				swapImageP->planeP[1] = (void*)Swap32(planarImage.planeP[1]);
				swapImageP->planeP[2] = (void*)Swap32(planarImage.planeP[2]);
				switch(gMPEG4Info.imageFormat)
				{
					case palmCodecImageYCbCr420Planar:
						fileOffset += ( 3 * planarImage.width * planarImage.height ) / 2;
						break;
						
					case palmCodecImageYCbCr422Planar:
						fileOffset += ( 2 * planarImage.width * planarImage.height );
						break;
				}
			}
			else
			{
				FrmCustomAlert(InfoAlert, "Encoding done!", NULL, NULL);
				goto Done;
			}
		}
		else
		{
			// Load from file
			err = PrvLoadFrameFromFile(gMPEG4Info.inputFileRef, &planarImage, gMPEG4Info.imageFormat);
			if(err) {
				if(gMPEG4Info.loop) {
					VFSFileSeek(gMPEG4Info.inputFileRef, vfsOriginBeginning, 0);	
					err = PrvLoadFrameFromFile(gMPEG4Info.inputFileRef, &planarImage, gMPEG4Info.imageFormat);
				} else {
					FrmCustomAlert(InfoAlert, "Encoding done!", NULL, NULL);
					goto Done;
				}
			}
			swapImageP->planeP[0] = (void*)Swap32(planarImage.planeP[0]);
			swapImageP->planeP[1] = (void*)Swap32(planarImage.planeP[1]);
			swapImageP->planeP[2] = (void*)Swap32(planarImage.planeP[2]);
		}
		
		inSize = sizeof(PalmImagePlanarType);
		outSize = planarImage.width * planarImage.height * 2;
		
		// Check the event queue
		EvtGetEvent(&event, 0);
		if(event.eType == penDownEvent && RctPtInRectangle(event.screenX, event.screenY, &goButtonBounds))
			goto Done;
	
		// Encode one frame
		err = CodecMgrEncodeDecode(gMPEG4Info.codecMgrLibRefNum, gMPEG4Info.session, swapImageP, &inSize, outputBufferP, &outSize);
		
		// Update the Frame counter
		if(outSize)
		{
			gFrameCount++;
			
			if(gMPEG4Info.outputToSD)
			{
				UInt32 written = 0;
				
				// Write the Buffer
				err = VFSFileWrite(gMPEG4Info.outputFileRef, outSize, outputBufferP, &written);
				if(err || written != outSize) {
					FrmCustomAlert(ErrorAlert, "Error during file write!", NULL, NULL);
					goto Done;
				}
			}
		}
		
		// Update the UI frame count
		PrvUpdateUI();
	}
			
Done:
	if(inputBufferP) {
		if(useFtr)	
			FtrPtrFree(appFileCreator, 0);
		else
			MemPtrFree(inputBufferP);
	}
	if(outputBufferP)
		MemPtrFree(outputBufferP);	
	if(savedPlaneP[0])
		MemPtrFree(savedPlaneP[0]);
	if(savedPlaneP[1])
		MemPtrFree(savedPlaneP[1]);
	if(savedPlaneP[2])
		MemPtrFree(savedPlaneP[2]);
	if(imageParamP)
		MemPtrFree(imageParamP);
	if(swapImageP)
		MemPtrFree(swapImageP);
		
	// Delete the session
	if(gMPEG4Info.session)
		CodecMgrDeleteSession(gMPEG4Info.codecMgrLibRefNum, &gMPEG4Info.session);
	
	// Close files
	if(gMPEG4Info.inputFileRef) {
		VFSFileClose(gMPEG4Info.inputFileRef);
		gMPEG4Info.inputFileRef = NULL;
	}
	
    if(gMPEG4Info.outputFileRef) {
    	VFSFileClose(gMPEG4Info.outputFileRef);
    	gMPEG4Info.outputFileRef = NULL;
    }
    		
	return err;
}

#if 0
#pragma mark -
#endif

/**
 * Initialize the form
 */
static void MainFormInit(FormType *frmP)
{
	Char text[32];
	FieldType *fldP = NULL;
	ControlType *ctlP = NULL;
	
	// Set the current mode
	if(gMPEG4Info.encoding)	{
		ctlP = FrmGetPtr(frmP, MainEncodePushButton);
		CtlSetValue(ctlP, true);
	} else {
		ctlP = FrmGetPtr(frmP, MainDecodePushButton);
		CtlSetValue(ctlP, true);
	}
	
	// Set encoder specfic params
	StrIToA(text, gMPEG4Info.searchRange);
	fldP = FrmGetPtr(frmP, MainSearchRangeField);
	SetFieldTextFromStr(fldP, text, false);
	StrIToA(text, gMPEG4Info.bitRate);
	fldP = FrmGetPtr(frmP, MainBitRateField);
	SetFieldTextFromStr(fldP, text, false);
	StrIToA(text, gMPEG4Info.keyFrame);
	fldP = FrmGetPtr(frmP, MainKeyFrameField);
	SetFieldTextFromStr(fldP, text, false);
	StrIToA(text, gMPEG4Info.IQuantization);
	fldP = FrmGetPtr(frmP, MainIQuantizationField);
	SetFieldTextFromStr(fldP, text, false);
	
	// Set Width and Height
	StrIToA(text, gMPEG4Info.width);
	fldP = FrmGetPtr(frmP, MainWidthField);
	SetFieldTextFromStr(fldP, text, false);
	StrIToA(text, gMPEG4Info.height);
	fldP = FrmGetPtr(frmP, MainHeightField);
	SetFieldTextFromStr(fldP, text, false);
	
	// Set files
	if(gMPEG4Info.inputFileName[0]!=NULL) {
		fldP = FrmGetPtr(frmP, MainInputField);
		SetFieldTextFromStr(fldP, gMPEG4Info.inputFileName, false);
	}
	
	if(gMPEG4Info.outputFileName[0]!=NULL) {
		fldP = FrmGetPtr(frmP, MainOutputField);
		SetFieldTextFromStr(fldP, gMPEG4Info.outputFileName, false);
	}
		
	// Set the checkbox
	ctlP = FrmGetPtr(frmP, MainLoadInMemCheckbox);
	CtlSetValue(ctlP, gMPEG4Info.loadFileInMemory);
	ctlP = FrmGetPtr(frmP, MainToSDCheckbox);
	CtlSetValue(ctlP, gMPEG4Info.outputToSD);
	ctlP = FrmGetPtr(frmP, MainLoopCheckbox);
	CtlSetValue(ctlP, gMPEG4Info.loop);
		
	
	// Overlay
	if(gLCDOverlayRefNum == sysInvalidRefNum)
		FrmHideObject(frmP, FrmGetObjectIndex(frmP, MainOverlayPushButton));
	else
	{
		ctlP = FrmGetPtr(frmP, MainOverlayPushButton);
		CtlSetValue(ctlP, gUseOverlay);
	}
}

/**
 * MainFormHandleEvent
 */
static Boolean MainFormHandleEvent(EventType * eventP)
{
	Boolean handled = false;
	FormType *frmP = FrmGetActiveForm();
	FieldType *fldP = NULL;


	switch(eventP->eType)
	{
		case frmOpenEvent:
			MainFormInit(frmP);
			FrmDrawForm(frmP);
			PrvDrawLoadingRect();
			FrmNavObjectTakeFocus(frmP, MainInputField);
			handled = true;
			break;
			
		case frmUpdateEvent:
			break;
			
		case popSelectEvent:
			switch(eventP->data.popSelect.controlID)
			{
				case MainFormatPopTrigger:
					switch(eventP->data.popSelect.selection) {
						case 0:
							gMPEG4Info.imageFormat = palmCodecImageYCbCr420Planar;
							break;
						case 1:
							gMPEG4Info.imageFormat = palmCodecImageYCbCr422Planar;
							break;
					}
					break;
				
				case MainQuickPickPopTrigger:
					switch(eventP->data.popSelect.selection) {
						case 0:
							gMPEG4Info.width = 320;
							gMPEG4Info.height = 240;
							break;
						case 1:
							gMPEG4Info.width = 176;
							gMPEG4Info.height = 144;
							break;
						case 2:
							gMPEG4Info.width = 352;
							gMPEG4Info.height = 288;
							break;
					}
					{
						Char text[32];
						// Set Width and Height
						StrIToA(text, gMPEG4Info.width);
						fldP = FrmGetPtr(frmP, MainWidthField);
						SetFieldTextFromStr(fldP, text, true);
						StrIToA(text, gMPEG4Info.height);
						fldP = FrmGetPtr(frmP, MainHeightField);
						SetFieldTextFromStr(fldP, text, true);
					}
					break;
			}
			break;
			
		case ctlSelectEvent:
			switch(eventP->data.ctlSelect.controlID)
			{
				case MainInputGraphicButton:
					// Sets the callback function and return form
					if(PrvReadParameters(gMPEG4Info.encoding)==errNone) { // Store before switching form
						FileBrowserSetCallback(&PrvGetInputFileInfoCallback, MainForm);
						FrmGotoForm(FileBrowserForm);
						handled = true;
					}
					break;
					
				case MainEncodePushButton:
					gMPEG4Info.encoding = true;
					break;
					
				case MainDecodePushButton:
					gMPEG4Info.encoding = false;
					break;
					
				case MainLoadInMemCheckbox:
					gMPEG4Info.loadFileInMemory = CtlGetValue(eventP->data.ctlSelect.pControl);
					break;
					
				case MainToSDCheckbox:
					gMPEG4Info.outputToSD = CtlGetValue(eventP->data.ctlSelect.pControl);
					break;
					
				case MainLoopCheckbox:
					gMPEG4Info.loop = CtlGetValue(eventP->data.ctlSelect.pControl);
					break;
					
				case MainGoButton:
					CtlSetLabel(FrmGetPtr(FrmGetActiveForm(), MainGoButton), gGOButtonLabel[1]);
					if(gMPEG4Info.encoding)
						PrvStartEncoder();
					else
						PrvStartDecoder();
					CtlSetLabel(FrmGetPtr(FrmGetActiveForm(), MainGoButton), gGOButtonLabel[0]);
					PrvDrawLoadingRect();
					handled = true;
					break;
					
				case MainStartColorGadget:
				{
					IndexedColorType colorIndex = WinRGBToIndex(&gStartColor);
					if( UIPickColor(&colorIndex, NULL, UIPickColorStartPalette, "End Color", NULL) )
						WinIndexToRGB(colorIndex, &gStartColor);
					FrmDrawForm(FrmGetActiveForm());
					PrvDrawLoadingRect();
					handled = true;
				}
					break;
					
				case MainEndColorGadget:
				{
					IndexedColorType colorIndex = WinRGBToIndex(&gEndColor);
					if( UIPickColor(&colorIndex, NULL, UIPickColorStartPalette, "End Color", NULL) )
						WinIndexToRGB(colorIndex, &gEndColor);
					FrmDrawForm(FrmGetActiveForm());
					PrvDrawLoadingRect();
					handled = true;
				}
					break;
								
					
				case MainOverlayPushButton:
					gUseOverlay = eventP->data.ctlSelect.on;
					FrmDrawForm(FrmGetActiveForm());
					PrvDrawLoadingRect();
					handled = true;
					break;
			}
			break;
			
		case menuEvent:
			HandleMenu(eventP->data.menu.itemID);
			FrmDrawForm(frmP);
			handled = true;
			break;


		default:
			break;
	}
	
	return handled;
}

/**
 * AppHandleEvent
 */
static Boolean AppHandleEvent(EventType * eventP)
{
    UInt16 formId;
    FormType * frmP;

    if (eventP->eType == frmLoadEvent)
    {
        formId = eventP->data.frmLoad.formID;
        frmP = FrmInitForm(formId);
        FrmSetActiveForm(frmP);

        switch (formId)
        {
        case MainForm:
            FrmSetEventHandler(frmP, MainFormHandleEvent);
            FrmSetGadgetHandler(frmP,  FrmGetObjectIndex(frmP, MainStartColorGadget), ColorButtonGadgetHandler);
			FrmSetGadgetHandler(frmP,  FrmGetObjectIndex(frmP, MainEndColorGadget), ColorButtonGadgetHandler);
            break;
            
        case FileBrowserForm:
            FrmSetEventHandler(frmP, FileBrowserFormHandleEvent);
            break;

        default:
            break;

        }
        return true;
    }

    return false;
}

/**
 * AppEventLoop
 */
static void AppEventLoop(void)
{
	UInt16 error = errNone;
	EventType event;

    do
    {
    	EvtGetEvent(&event, evtWaitForever);
    	
    	if (! SysHandleEvent(&event))
    		if (! MenuHandleEvent(0, &event, &error))
    			if (! AppHandleEvent(&event))
    				FrmDispatchEvent(&event);

    } while (event.eType != appStopEvent);
}

/**
 * AppStart
 * Called when the application starts.
 */
static Err AppStart(void)
{
	Err err = errNone;
	
	// Clear the global
	MemSet(&gMPEG4Info, sizeof(MPEG4Info), 0);

	// Try to find the hardware utils library
	err = SysLibFind(kCodecMgrLibName, &gMPEG4Info.codecMgrLibRefNum);	
	if (err != errNone)
	{
		err = SysLibLoad(kCodecMgrLibType, kCodecMgrLibCreator, &gMPEG4Info.codecMgrLibRefNum);
		if(err == errNone)
			err = CodecMgrOpen(gMPEG4Info.codecMgrLibRefNum);
	}
	
	if(err) {
		FrmAlert(NoCPMLibAlert);
		goto Done;
	}


	// Try to load LCD Overlay library
	err = SysLibFind(kLcdOverlayLibName, &gLCDOverlayRefNum);	
	if (err != errNone)
	{
		err = SysLibLoad(kLcdOverlayLibType, kLcdOverlayLibCreator, &gLCDOverlayRefNum);
		if(err == errNone)
			err = LcdOverlayLibOpen(gLCDOverlayRefNum);
	}
	// Don't generate an error for the Overlay library
	err = errNone;
	
	
	// Set default values
	gMPEG4Info.inputFileRef = NULL;
	gMPEG4Info.outputFileRef = NULL;
	gMPEG4Info.session = NULL;
	
	gMPEG4Info.width = 320;
	gMPEG4Info.height = 240;
	gMPEG4Info.frameRate = 15;
	gMPEG4Info.bitRate = 0;
	gMPEG4Info.keyFrame = 20;
	gMPEG4Info.IQuantization = 16;
	gMPEG4Info.imageFormat = palmCodecImageYCbCr420Planar;
	gMPEG4Info.searchRange = 10;
	
	gMPEG4Info.loadFileInMemory = true;
	gMPEG4Info.outputToSD = false;
	gMPEG4Info.encoding = true;
	gMPEG4Info.loop = false;
	
	StrCopy(gMPEG4Info.outputFileName, "/default.out");
	
	// Switch to 16 bit color
	WinScreenMode(winScreenModeGet, NULL, NULL, &gPreviousScreenDepth, NULL);
	WinScreenMode(winScreenModeSet, NULL, NULL, &gScreenDepth, NULL);
		
Done:			
	return err;
}

/**
 * AppStop
 * Called when the application stops.
 */
static void AppStop(void)
{
	Err err = errNone;
	
    FrmCloseAllForms();
    
    // Close files
	if(gMPEG4Info.inputFileRef)
		VFSFileClose(gMPEG4Info.inputFileRef);
	if(gMPEG4Info.outputFileRef)
		VFSFileClose(gMPEG4Info.outputFileRef);
	
	// Close the library
	if(gMPEG4Info.codecMgrLibRefNum != sysInvalidRefNum)
	{
		err = CodecMgrClose(gMPEG4Info.codecMgrLibRefNum);
		if (err == errNone)
			err = SysLibRemove(gMPEG4Info.codecMgrLibRefNum);
	}
	
	
	if(gLCDOverlayRefNum != sysInvalidRefNum)
	{
		err = LcdOverlayLibClose(gLCDOverlayRefNum);
		if (err == errNone)
			err = SysLibRemove(gLCDOverlayRefNum);
	}
	
	// Restore previous color mode
	WinScreenMode(winScreenModeSet, NULL, NULL, &gPreviousScreenDepth, NULL);
}

//
// RomVersionCompatible
//
static Err RomVersionCompatible(UInt32 requiredVersion, UInt16 launchFlags)
{
    UInt32 romVersion;

    FtrGet(sysFtrCreator, sysFtrNumROMVersion, &romVersion);
    if (romVersion < requiredVersion)
    {
        if ((launchFlags & 
            (sysAppLaunchFlagNewGlobals | sysAppLaunchFlagUIApp)) ==
            (sysAppLaunchFlagNewGlobals | sysAppLaunchFlagUIApp))
        {
            FrmAlert (RomIncompatibleAlert);

            if (romVersion < kPalmOS20Version)
            {
                AppLaunchWithCommand(
                    sysFileCDefaultApp, 
                    sysAppLaunchCmdNormalLaunch, NULL);
            }
        }

        return sysErrRomIncompatible;
    }

    return errNone;
}

//
// PilotMain
//
UInt32 PilotMain(UInt16 cmd, MemPtr cmdPBP, UInt16 launchFlags)
{
    Err error;
//    SysNotifyParamType *notifyParamP = NULL;

    error = RomVersionCompatible (ourMinVersion, launchFlags);
    if (error) return (error);

    switch (cmd)
    {
    case sysAppLaunchCmdNormalLaunch:
        error = AppStart();
        if (error) 
            return error;

        FrmGotoForm(MainForm);
        AppEventLoop();
        
        AppStop();
        break;
        
    default:
        break;
    }

//Done:
    return errNone;
}