pace.c

大名鼎鼎的CE下播放软件,TCPPMP的源代码!!!2410下可以流畅的解QVGA的H264,MPEG4等格式.

	pcecall Old = PceCall;
	PceCall.Func = call68KFuncP;
	PceCall.State = emulStateP;
	Event_M68K_To_ARM(EventM68K,&EventARM);
	Result = i->Handler(&EventARM);
	if (!Result && EventARM.eType == frmCloseEvent)
		i->Form = NULL;
	PceCall = Old;
	return Result;
}

DLLEXPORT Boolean WrapperGadgetHandler86(const void *emulStateP, gadgethandler* i, Call68KFuncType *call68KFuncP)
{
	EventType EventARM;
	Boolean Result;
	FormGadgetTypeInCallback GadgetARM;
	uint16_t* Gadget = (uint16_t*) SWAP32(i->Gadget);
	UInt16 Cmd = SWAP16(i->Cmd);
	uint16_t* EventM68K = (uint16_t*) SWAP32(i->Event);
	pcecall Old = PceCall;
	PceCall.Func = call68KFuncP;
	PceCall.State = emulStateP;
	GadgetTypeInCallback_M68K_To_ARM(Gadget,&GadgetARM);
	if (Cmd == formGadgetHandleEventCmd)
		Event_M68K_To_ARM(EventM68K,&EventARM);
	Result = i->Handler(&GadgetARM,Cmd,&EventARM);
	GadgetTypeInCallback_ARM_To_M68K(&GadgetARM,Gadget);
	if (Cmd == formGadgetDeleteCmd)
		i->Form = NULL;
	PceCall = Old;
	return Result;
}

#elif defined(ARM)

#define NONE

void SaveSysRegs(sysregs* p)
{
	p->SysReg = PceCall.SysReg;
	asm volatile(
		"mov %0, r10\n\t"
		: "=&r"(p->GOT) : : "cc");
}

void LoadSysRegs(sysregs* p)
{
	asm volatile(
		"mov r9,%0\n\t"
		"mov r10,%1\n\t"
		: : "r"(p->SysReg),"r"(p->GOT): "cc");
}

static NOINLINE unsigned long Call68K(unsigned long trapOrFunction,
									  const void *argsOnStackP, unsigned long argsSizeAndwantA0)
{
	pcecall* Call = &PceCall;
	unsigned long Result;
	register void *SysReg asm("r9") = Call->SysReg;
	Result = Call->Func(Call->State,trapOrFunction,argsOnStackP,argsSizeAndwantA0);
	Call->SysReg = SysReg;
	return Result;
}

static NOINLINE void SafeMemCpy(void* d,const void* s,int n)
{
	uint8_t* d8 = (uint8_t*)d;
	const uint8_t* s8= (const uint8_t*)s;
	for (;n>0;--n,++d8,++s8)
		*d8 = *s8;
}

#ifdef STACKCHECK
static void NOINLINE StackCheck(char* p)
{
	int i;
	for (i=0;i<STACKSIZE;++i)
		if (p[i] != 0x55)
			break;
	if (i < 4096)
	{
		char s[64];
		sprintf(s,"Possible stack overflow %d/%d. ",i,STACKSIZE);
		FrmCustomAlert(WarningOKAlert, s, "Please contact developer!", " ");
	}
}
#endif

uint32_t PaceMain(launch* Launch)
{
	MemPtr Parameters = (MemPtr)((SWAP16(Launch->launchParameters[0])<<16)|(SWAP16(Launch->launchParameters[1])));
	int Code = SWAP16(Launch->launchCode);
	void* Old = NULL;
	char* Stack = NULL;
	uint32_t Result; 

	if (CmdLaunch(Code))
	{
		SafeMemCpy(&Peal,Launch,sizeof(launch));
		Stack = MemGluePtrNew(STACKSIZE);
		if (!Stack)
			return errNone;
		memset(Stack,0x55,STACKSIZE);
		Old = SwapSP(Stack+STACKSIZE);
	}

	SwapLanchParameters(Code,Parameters,1);
	Result = PilotMain(Code,Parameters,SWAP16(Launch->launchFlags));
	SwapLanchParameters(Code,Parameters,0);

	if (Stack)
	{
		SwapSP(Old);
#ifdef STACKCHECK
		StackCheck(Stack);
#endif
		MemPtrFree(Stack);
		FreeHandlers();
	}

	return Result;
}

static Boolean WrapperEventHandler(eventhandler* i)
{
	Boolean Result;
	EventType EventARM;
	const uint16_t* EventM68K = (const uint16_t*) SWAP32(i->Event);
	Event_M68K_To_ARM(EventM68K,&EventARM);
	Result = i->Handler(&EventARM);
	if (!Result && EventARM.eType == frmCloseEvent)
		i->Form = NULL;
	return Result;
}

static Boolean WrapperGadgetHandler(gadgethandler* i)
{
	EventType EventARM;
	Boolean Result;
	FormGadgetTypeInCallback GadgetARM;
	uint16_t* Gadget = (uint16_t*) SWAP32(i->Gadget);
	UInt16 Cmd = SWAP16(i->Cmd);
	const uint16_t* EventM68K = (const uint16_t*) SWAP32(i->Event);
	GadgetTypeInCallback_M68K_To_ARM(Gadget,&GadgetARM);
	if (Cmd == formGadgetHandleEventCmd)
		Event_M68K_To_ARM(EventM68K,&EventARM);
	Result = i->Handler(&GadgetARM,Cmd,&EventARM);
	GadgetTypeInCallback_ARM_To_M68K(&GadgetARM,Gadget);
	if (Cmd == formGadgetDeleteCmd)
		i->Form = NULL;
	return Result;
}

#else
#error Not supported platform
#endif

typedef struct emustate
{
	uint32_t instr;
	uint32_t regD[8];
	uint32_t regA[8];
	uint32_t regPC;

} emustate;

#define PACE_PARAM			_v

#define PACE_BEGIN(declare)	NOINLINE declare { uint16_t PACE_PARAM[] = {
#define PACE_BEGINEVENT(declare) NOINLINE declare { uint16_t ev[12]; uint16_t PACE_PARAM[] = {
#define PACE_BEGINEX(declare,name)	NOINLINE declare { uint16_t name[] = {
#define PACE_VAR(name)		}; uint16_t name[] = {

#define PACE_ADD8(name) 	(uint8_t)name,
#define PACE_ADD16(name) 	SWAP16(name),
#define PACE_ADD32(name)	SWAP16(((uint32_t)(name))>>16),SWAP16(name),

#define PACE_DATA16(name)	*name = SWAP16(*name);
#define PACE_DATA32(name)	*name = SWAP32(*name);
#define PACE_CDATA16(name)	if (name) *name = SWAP16(*name);
#define PACE_CDATA32(name)	if (name) *name = SWAP32(*name);
#define PACE_SEL(sel)		((emustate*)PceCall.State)->regD[2] = sel;

#define PACE_END(Trap,PreProcess,PostProcess) }; PreProcess; \
    Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)); \
	PostProcess; }

#define PACE_ENDVOID(Trap,PreProcess,PostProcess) 0}; PreProcess; \
    Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0); \
	PostProcess; }

#define PACE_END8(Trap,PreProcess,PostProcess) }; uint32_t ret; PreProcess; \
	ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)); \
	PostProcess; return (uint8_t)ret; }

#define PACE_END8VOID(Trap,PreProcess,PostProcess) 0}; uint32_t ret; PreProcess; \
	ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0); \
	PostProcess; return (uint8_t)ret; }

#define PACE_END16(Trap,PreProcess,PostProcess) }; uint32_t ret; PreProcess; \
	ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)); \
	PostProcess; return (uint16_t)ret; }

#define PACE_END16VOID(Trap,PreProcess,PostProcess) 0}; uint32_t ret; PreProcess; \
	ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0); \
	PostProcess; return (uint16_t)ret; }

#define PACE_END32(Trap,PreProcess,PostProcess) }; uint32_t ret; PreProcess; \
	ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)); \
	PostProcess; return ret; }

#define PACE_END32VOID(Trap,PreProcess,PostProcess) 0}; uint32_t ret; PreProcess; \
	ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0); \
	PostProcess; return ret; }

#define PACE_ENDPTR(Trap,PreProcess,PostProcess) }; uint32_t ret; PreProcess; \
	ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)|kPceNativeWantA0); \
	PostProcess; return (void*)ret; }

#define PACE_ENDPTRVOID(Trap,PreProcess,PostProcess) 0}; uint32_t ret; PreProcess; \
	ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0|kPceNativeWantA0); \
	PostProcess; return (void*)ret; }

static NOINLINE void SwapBlock32(void* Ptr,int n)
{
	if (Ptr)
	{
		int i;
		char* p = (char*)Ptr;
		for (i=0;i<n;++i,p+=4)
			PACE_DATA32((uint32_t*)p);
	}
}

static NOINLINE void SwapStruct(void* Ptr,...)
{
	if (Ptr)
	{
		int Size;
		char* p = (char*)Ptr;
		va_list Args;
		va_start(Args,Ptr);
		while ((Size = va_arg(Args,int))!=0)
		{
			if (Size == 4)
				PACE_DATA32((uint32_t*)p)
			else
			if (Size == 2)
				PACE_DATA16((uint16_t*)p)
			p += Size;
		}
		va_end(Args);
	}
}

//---------------------------------------------------------------------

PACE_BEGIN(Int32 GetOEMSleepMode())
PACE_END32VOID(sysTrapOEMDispatch2,PACE_SEL(263),NONE)

PACE_BEGIN(Err SetOEMSleepMode(Int32 Mode))
PACE_ADD32(Mode)
PACE_END16(sysTrapOEMDispatch2,PACE_SEL(264),NONE)

PACE_BEGIN(UInt16 SysGetOrientation())
PACE_END16VOID(sysTrapPinsDispatch,PACE_SEL(pinSysGetOrientation),NONE)

PACE_BEGIN(Err WinGetPixelRGB(Coord x, Coord y, RGBColorType* rgbP))
PACE_ADD16(x)
PACE_ADD16(y)
PACE_ADD32(rgbP)
PACE_END16(sysTrapWinGetPixelRGB,NONE,NONE)

PACE_BEGIN(void	WinSetForeColorRGB(const RGBColorType* newRgbP, RGBColorType* prevRgbP))
PACE_ADD32(newRgbP)
PACE_ADD32(prevRgbP)
PACE_END(sysTrapWinSetForeColorRGB,NONE,NONE)

PACE_BEGIN(void WinPaintPixel(Coord x, Coord y))
PACE_ADD16(x)
PACE_ADD16(y)
PACE_END(sysTrapWinPaintPixel,NONE,NONE)

PACE_BEGIN(void WinDrawPixel(Coord x, Coord y))
PACE_ADD16(x)
PACE_ADD16(y)
PACE_END(sysTrapWinDrawPixel,NONE,NONE)

PACE_BEGIN(void FrmSetFocus(FormType *formP, UInt16 fieldIndex))
PACE_ADD32(formP)
PACE_ADD16(fieldIndex)
PACE_END(sysTrapFrmSetFocus,NONE,NONE)

PACE_BEGIN(void FrmSetTitle (FormType *formP, Char *newTitle))
PACE_ADD32(formP)
PACE_ADD32(newTitle)
PACE_END(sysTrapFrmSetTitle,NONE,NONE)

PACE_BEGIN(FormObjectKind FrmGetObjectType(const FormType *formP, UInt16 objIndex))
PACE_ADD32(formP)
PACE_ADD16(objIndex)
PACE_END8(sysTrapFrmGetObjectType,NONE,NONE)

PACE_BEGIN(FormLabelType *FrmNewLabel (FormType **formPP, UInt16 ID, const Char *textP,
	Coord x, Coord y, FontID font))
PACE_ADD32(formPP)
PACE_ADD16(ID)
PACE_ADD32(textP)
PACE_ADD16(x)
PACE_ADD16(y)
PACE_ADD8(font)
PACE_ENDPTR(sysTrapFrmNewLabel,PACE_CDATA32((UInt32*)formPP),PACE_CDATA32((UInt32*)formPP))

PACE_BEGIN(FormType *FrmNewForm(UInt16 formID, const Char *titleStrP,
	Coord x, Coord y, Coord width, Coord height, Boolean modal,
	UInt16 defaultButton, UInt16 helpRscID, UInt16 menuRscID))
PACE_ADD16(formID)
PACE_ADD32(titleStrP)
PACE_ADD16(x)
PACE_ADD16(y)
PACE_ADD16(width)
PACE_ADD16(height)
PACE_ADD8(modal)
PACE_ADD16(defaultButton)
PACE_ADD16(helpRscID)
PACE_ADD16(menuRscID)
PACE_ENDPTR(sysTrapFrmNewForm,NONE,NONE)

PACE_BEGIN(void FrmCloseAllForms())
PACE_ENDVOID(sysTrapFrmCloseAllForms,NONE,NONE)

PACE_BEGIN(UInt16 FrmGetObjectId (const FormType *formP, UInt16 objIndex))
PACE_ADD32(formP)
PACE_ADD16(objIndex)
PACE_END16(sysTrapFrmGetObjectId,NONE,NONE)

PACE_BEGIN(UInt16 FrmGetNumberOfObjects(const FormType *formP))
PACE_ADD32(formP)
PACE_END16(sysTrapFrmGetNumberOfObjects,NONE,NONE)

PACE_BEGIN(UInt16 FrmGetActiveFormID())
PACE_END16VOID(sysTrapFrmGetActiveFormID,NONE,NONE)

PACE_BEGIN(void FrmGotoForm (UInt16 formId))
PACE_ADD16(formId)
PACE_END(sysTrapFrmGotoForm,NONE,NONE)

PACE_BEGIN(void CtlSetUsable (ControlType *controlP, Boolean usable))
PACE_ADD32(controlP)
PACE_ADD8(usable)
PACE_END(sysTrapCtlSetUsable,NONE,NONE)

PACE_BEGIN(Int16 CtlGetValue (const ControlType *controlP))
PACE_ADD32(controlP)
PACE_END16(sysTrapCtlGetValue,NONE,NONE)

PACE_BEGIN(void CtlSetValue (ControlType *controlP, Int16 newValue))
PACE_ADD32(controlP)
PACE_ADD16(newValue)
PACE_END(sysTrapCtlSetValue,NONE,NONE)

PACE_BEGIN(void CtlSetLabel (ControlType *controlP, const Char *newLabel))
PACE_ADD32(controlP)
PACE_ADD32(newLabel)
PACE_END(sysTrapCtlSetLabel,NONE,NONE)

PACE_BEGIN(void	EvtEnableGraffiti(Boolean enable))
PACE_ADD8(enable)
PACE_END(sysTrapEvtEnableGraffiti,NONE,NONE);

PACE_BEGIN(Err EvtResetAutoOffTimer())
PACE_END16VOID(sysTrapEvtResetAutoOffTimer,NONE,NONE)

PACE_BEGIN(FormType *FrmGetFirstForm())
PACE_ENDPTRVOID(sysTrapFrmGetFirstForm,NONE,NONE)

PACE_BEGIN(void *FrmGetObjectPtr (const FormType *formP, UInt16 objIndex))
PACE_ADD32(formP)
PACE_ADD16(objIndex)
PACE_ENDPTR(sysTrapFrmGetObjectPtr,NONE,NONE)

#if defined(_M_IX86)
// simulator freezes many times. bypassing...
Boolean EvtEventAvail() { return 1; }
#else
PACE_BEGIN(Boolean EvtEventAvail())
PACE_END8VOID(sysTrapEvtEventAvail,NONE,NONE)
#endif

PACE_BEGIN(void EvtGetPen(Int16 *pScreenX, Int16 *pScreenY, Boolean *pPenDown))
PACE_ADD32(pScreenX)
PACE_ADD32(pScreenY)
PACE_ADD32(pPenDown)
PACE_END(sysTrapEvtGetPen,NONE,PACE_DATA16(pScreenX) PACE_DATA16(pScreenY))

PACE_BEGIN(Boolean EvtSysEventAvail(Boolean ignorePenUps))
PACE_ADD8(ignorePenUps)
PACE_END8(sysTrapEvtSysEventAvail,NONE,NONE)

PACE_BEGINEVENT(void EvtAddUniqueEventToQueue(const EventType *eventP, UInt32 id,Boolean inPlace))
PACE_ADD32(&ev)
PACE_ADD32(id)
PACE_ADD8(inPlace)
PACE_END(sysTrapEvtAddUniqueEventToQueue,Event_ARM_To_M68K(eventP,ev),NONE)

PACE_BEGINEVENT(void EvtGetEvent(EventType *event, Int32 timeout))
PACE_ADD32(&ev)
PACE_ADD32(timeout)
PACE_END(sysTrapEvtGetEvent,NONE,Event_M68K_To_ARM(ev,event))

PACE_BEGIN(UInt16 FrmGetObjectIndex (const FormType *formP, UInt16 objID))
PACE_ADD32(formP)
PACE_ADD16(objID)
PACE_END16(sysTrapFrmGetObjectIndex,NONE,NONE)

PACE_BEGIN(void CtlSetSliderValues(ControlType *ctlP, const UInt16 *minValueP, const UInt16 *maxValueP,
								   const UInt16 *pageSizeP, const UInt16 *valueP))
PACE_ADD32(ctlP)
PACE_ADD32(minValueP)
PACE_ADD32(maxValueP)
PACE_ADD32(pageSizeP)
PACE_ADD32(valueP)
PACE_END(sysTrapCtlSetSliderValues,PACE_CDATA16((UInt16*)minValueP) PACE_CDATA16((UInt16*)maxValueP) PACE_CDATA16((UInt16*)pageSizeP) PACE_CDATA16((UInt16*)valueP),
								   PACE_CDATA16((UInt16*)minValueP) PACE_CDATA16((UInt16*)maxValueP) PACE_CDATA16((UInt16*)pageSizeP) PACE_CDATA16((UInt16*)valueP))
								   // possible problem overriding const input

PACE_BEGIN(WinHandle WinSetDrawWindow(WinHandle winHandle))
PACE_ADD32(winHandle)
PACE_ENDPTR(sysTrapWinSetDrawWindow,NONE,NONE)