main.c

palm编程

			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(gFrameCount);
	}
			
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) {
		fldP = FrmGetPtr(frmP, MainInputField);
		SetFieldTextFromStr(fldP, gMPEG4Info.inputFileName, false);
	}
	
	if(gMPEG4Info.outputFileName) {
		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();
			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
					PrvReadParameters(gMPEG4Info.encoding); // 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;
					handled = true;
					break;
			}
			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;
}