platform_win32.c

betaplayer的源码 tcpmp的老版本

			Size = sizeof(Value);
			if (RegQueryValueEx( Key, Name,NULL,NULL,(LPBYTE)&Value,&Size) == ERROR_SUCCESS)
				NodeSaveValue(BackupId,&Value,sizeof(Value),TYPE_INT);

			// set no screensaver
			Value = NewValue;
			Size = sizeof(Value);
			RegSetValueEx( Key, Name,0,REG_DWORD,(LPBYTE)&Value,Size);
		}
		else
		if (NodeLoadValue(BackupId,&Value,sizeof(Value),NULL))
		{
			// restore value (and delete old value)
			Size = sizeof(Value);
			RegSetValueEx( Key, Name,0,REG_DWORD,(LPBYTE)&Value,Size);

			NodeSaveValue(BackupId,NULL,0,TYPE_INT);
		}

		RegCloseKey( Key );
	}

	return Key != 0;
}

static bool_t BacklightTimeoutDisabled = -1;

void IdleTimerReset()
{
#if defined(_WIN32_WCE)
	SystemIdleTimerReset();
	if (FuncSHIdleTimerReset)
		if (BacklightTimeoutDisabled || !QueryAdvPlatform(ADVPLATFORM_HOMESCREEN))
			FuncSHIdleTimerReset();
	if (BacklightTimeoutDisabled)
		SetEvent(BacklightEvent);
#endif
}

void SleepTimeout(bool_t Disable)
{
}

void BacklightTimeout(bool_t Disable)
{
	if (Disable && QueryAdvPlatform(ADVPLATFORM_NOBACKLIGHT))
		Disable = 0;

	if (Disable != BacklightTimeoutDisabled)
	{
		HANDLE Handle;
		int Value;

		BacklightTimeoutDisabled = Disable;

#ifdef MIPS
		if (Platform.Model == MODEL_CASIO_E125 ||
			Platform.Model == MODEL_CASIO_EM500 ||
			Platform.Model == MODEL_CASIO_E115 ||
			Platform.Model == MODEL_CASIO_BE300 ||
			Platform.Model == MODEL_CASIO_E105)
		{
			Value = 0;
			ChangeRegEntry(0,RegCASIOBacklight,RegTimeoutBattery,Disable,Value,PLATFORM_BATTERYTIMEOUT);
			ChangeRegEntry(0,RegCASIOBacklight,RegTimeoutExPower,Disable,Value,PLATFORM_ACTIMEOUT);
		}
		else
#endif
		{
			Value = (Platform.Type == TYPE_SMARTPHONE) ? 7199999 /*10*3600*1000*/ : 0x7FFFFFFF;
			if (Platform.Model == MODEL_AXIM_X5) 
				Value = 0;
			ChangeRegEntry(1,RegScreenSaver,RegMode,Disable,1,PLATFORM_SCREENSAVER);
			ChangeRegEntry(1,RegBacklight,RegBatteryTimeout,Disable,Value,PLATFORM_BATTERYTIMEOUT);
			ChangeRegEntry(1,RegBacklight,RegACTimeout,Disable,Value,PLATFORM_ACTIMEOUT);
			ChangeRegEntry(1,RegPower,RegDisplay,Disable,-1,PLATFORM_DISPPOWER);

			// just in case try HKEY_LOCAL_MACHINE as well 
			ChangeRegEntry(0,RegBacklight,RegBatteryTimeout,Disable,Value,PLATFORM_BATTERYTIMEOUT2);
			ChangeRegEntry(0,RegBacklight,RegACTimeout,Disable,Value,PLATFORM_ACTIMEOUT2);
		}
	
		Handle = CreateEvent( NULL, FALSE, FALSE, T("BackLightChangeEvent") );
		if (Handle) 
		{
			SetEvent(Handle);
			CloseHandle(Handle);
		}

		// support for sample Power Manager implementation 
		// maybe if they use the sample code, there might be bugs with SystemIdleTimerReset()...

		if (ChangeRegEntry(0,RegPowerTimouts,RegACUserIdle,Disable,0,PLATFORM_ACUSERIDLE))
		{
			ChangeRegEntry(0,RegPowerTimouts,RegBattUserIdle,Disable,0,PLATFORM_BATTUSERIDLE);
			ChangeRegEntry(0,RegPowerTimouts,RegACSystemIdle,Disable,0,PLATFORM_ACSYSTEMIDLE);
			ChangeRegEntry(0,RegPowerTimouts,RegBattSystemIdle,Disable,0,PLATFORM_BATTSYSTEMIDLE);
			ChangeRegEntry(0,RegPowerTimouts,RegACSuspend,Disable,0,PLATFORM_ACSUSPEND);
			ChangeRegEntry(0,RegPowerTimouts,RegBattSuspend,Disable,0,PLATFORM_BATTSUSPEND);

			Handle = CreateEvent( NULL, FALSE, FALSE, T("PowerManager/ReloadActivityTimeouts") );
			if (Handle) 
			{
				SetEvent(Handle);
				CloseHandle(Handle);
			}
		}

#if defined(_WIN32_WCE)

		if (FuncSetPowerRequirement && FuncReleasePowerRequirement)
		{
			static HANDLE PowerHandle = NULL;
			if (Disable && !PowerHandle)
			{
				PowerHandle = FuncSetPowerRequirement(T("BKL1:"),0,1,NULL,0);
			}
			else if (!Disable && PowerHandle)
			{
				FuncReleasePowerRequirement(PowerHandle);
				PowerHandle = NULL;
			}
		}
#endif
	}
}

void* LockFrameBuffer( video* p )
{
	void* Ptr = NULL;

	memset(p,0,sizeof(video));

	//set default values (for most of the models)
	p->Width = 240;
	p->Height = 320;
	p->Pitch = 480;
	p->Aspect = ASPECT_ONE;
	p->Direction = 0;

	if (QueryPlatform(PLATFORM_CAPS) & CAPS_ONLY12BITRGB)
		DefaultRGB(&p->Pixel,16,4,4,4,1,2,1);
	else
		DefaultRGB(&p->Pixel,16,5,6,5,0,0,0);

	switch (QueryPlatform(PLATFORM_MODEL))
	{
	case MODEL_BSQUARE_ALCHEMY:
		Ptr = PhyFrameBuffer = PhyMemBegin(0x15000000,320*480,1);
		p->Width = 240;
		p->Height = 320;
		p->Pitch = 480;
		break;

	case MODEL_IPAQ_H3600:
	case MODEL_IPAQ_H3700:
		p->Direction = DIR_SWAPXY | DIR_MIRRORLEFTRIGHT;
		Ptr = (void*)0xAC050020;
		p->Width = 320;
		p->Height = 240;
		p->Pitch = 640;
		break;

	case MODEL_IPAQ_H3800:
		p->Direction = DIR_SWAPXY | DIR_MIRRORUPDOWN;
		Ptr = (void*)0xAC050020;
		p->Width = 320;
		p->Height = 240;
		p->Pitch = 640;
		break;

	case MODEL_CASIO_BE300:
	case MODEL_CASIO_E105:
	case MODEL_CASIO_E115:
		Ptr = (void*)0xAA200000;
		p->Pitch = 512;
		break;

	case MODEL_JORNADA_710:
	case MODEL_JORNADA_720:
		Ptr = PhyFrameBuffer = PhyMemBegin(0x48200000,240*1280,1);
		p->Width = 640;
		p->Height = 240;
		p->Pitch = 1280;
		break;

	case MODEL_JORNADA_680:
	case MODEL_JORNADA_690: 
		Ptr = (void*)0xB2000000; //only japan???
		p->Width = 640;
		p->Height = 240;
		p->Pitch = 1280;
		break;

	case MODEL_MOBILEGEAR2_550:
	case MODEL_MOBILEGEAR2_450:
	case MODEL_MOBILEGEAR2_530:
	case MODEL_MOBILEGEAR2_430:
	case MODEL_MOBILEPRO_780:
		Ptr = (void*)0xAA180100;
		p->Width = 640;
		p->Height = 240;
		p->Pitch = 1280;
		break;

	case MODEL_MOBILEPRO_770:
		Ptr = (void*)0xAA000000;
		p->Width = 640;
		p->Height = 240;
		p->Pitch = 1600;
		break;

	case MODEL_JVC_C33:
		Ptr = (void*)0x445C0000;
		p->Width = 1024;
		p->Height = 600;
		p->Pitch = 2048;
		break;

	case MODEL_SIGMARION:
		Ptr = (void*)0xAA000000;
		p->Width = 640;
		p->Height = 240;
		p->Pitch = 1280;
		break;

	case MODEL_SIGMARION2:
		Ptr = (void*)0xB0800000;
		p->Width = 640;
		p->Height = 240;
		p->Pitch = 1280;
		break;

	case MODEL_SIGMARION3:
		Ptr = PhyFrameBuffer = PhyMemBegin(0x14800000,480*1600,1);
		p->Width = 800;
		p->Height = 480;
		p->Pitch = 1600;
		break;

	case MODEL_INTERMEC_6651:
		Ptr = PhyFrameBuffer = PhyMemBegin(0x6C000000,480*1600,1);
		p->Width = 800;
		p->Height = 480;
		p->Pitch = 1600;
		break;
	}

	if (((int)Ptr & 15)==0 && (p->Pitch & 15)==0)
		p->Pixel.Flags |= PF_16ALIGNED;
	return Ptr;
}

void UnlockFrameBuffer()
{
	if (PhyFrameBuffer)
	{
		PhyMemEnd(PhyFrameBuffer);
		PhyFrameBuffer = NULL;
	}
}

void* CodeAlloc(int Size)
{
	void* p;
	int h = 1;
	do 
	{
		p = VirtualAlloc(NULL,Size,MEM_COMMIT,PAGE_EXECUTE_READ);
	}
	while (!p && Size && NodeHibernate(h--));
	return p;
}

void CodeFree(void* Code,int Size)
{
	VirtualFree(Code,Size,MEM_DECOMMIT);
	VirtualFree(Code,0,MEM_RELEASE);
}

void CodeLock(void* Code,int Size)
{
	DWORD Protect;
	VirtualProtect(Code,Size,PAGE_READWRITE|PAGE_NOCACHE,&Protect);
}

void CodeUnlock(void* Code,int Size)
{
	DWORD Protect;
	VirtualProtect(Code,Size,PAGE_EXECUTE_READ,&Protect);
#if defined(_WIN32_WCE)
	if (FuncCacheSync)
		FuncCacheSync(CACHE_SYNC_INSTRUCTIONS);
#endif
}

void CodeFindPages(void* Ptr,uint8_t** Min,uint8_t** Max,int* PageSize)
{
#if defined(MIPS)
	*PageSize = 1024;
#else
	*PageSize = 4096;
#endif

	*Min = *Max = (uint8_t*) ((int)Ptr & ~(*PageSize-1));
	while (!IsBadCodePtr((FARPROC)(*Min-*PageSize)))
		*Min -= *PageSize;
	while (!IsBadCodePtr((FARPROC)*Max))
		*Max += *PageSize;
}

void _Assert(const char* Exp,const char* File,int Line)
{
	TCHAR TExp[MAXPATH];
	TCHAR TFile[MAXPATH];
	StrToTcs(TExp,File,MAXPATH);
	stprintf(TFile,T("%d:%s"),Line,TExp);
	StrToTcs(TExp,Exp,MAXPATH);
#ifndef NDEBUG
	DebugBreak();
#endif
	MessageBox(NULL,TExp,TFile,MB_OK);
}

void* LockCreate()
{
	void* p = Alloc(sizeof(CRITICAL_SECTION));
	InitializeCriticalSection((LPCRITICAL_SECTION)p);
	return p;
}

void LockDelete(void* p)
{
	if (p)
	{
		DeleteCriticalSection((LPCRITICAL_SECTION)p);
		Free(p);
	}
}

void LockEnter(void* p)
{
	EnterCriticalSection((LPCRITICAL_SECTION)p);
}

void LockLeave(void* p)
{
	LeaveCriticalSection((LPCRITICAL_SECTION)p);
}

int ThreadPriority(void* Thread,int Priority)
{
	int Old;
	if (!Thread) Thread = GetCurrentThread();
	Old = GetThreadPriority(Thread);

#if defined(_WIN32_WCE)
	Priority = THREAD_PRIORITY_NORMAL + Priority;
	if (Priority > THREAD_PRIORITY_IDLE)
		Priority = THREAD_PRIORITY_IDLE;
	if (Priority < THREAD_PRIORITY_TIME_CRITICAL)
		Priority = THREAD_PRIORITY_TIME_CRITICAL;
	SetThreadPriority(Thread,Priority);
	if (FuncCeSetThreadQuantum)
	{
		if (Old == THREAD_PRIORITY_TIME_CRITICAL && Priority != THREAD_PRIORITY_TIME_CRITICAL)
			FuncCeSetThreadQuantum(Thread,25);
		if (Old != THREAD_PRIORITY_TIME_CRITICAL && Priority == THREAD_PRIORITY_TIME_CRITICAL)
			FuncCeSetThreadQuantum(Thread,250);
	}
	return Old - THREAD_PRIORITY_NORMAL;
#else
	Priority = THREAD_PRIORITY_NORMAL - Priority;
	if (Priority < THREAD_PRIORITY_IDLE)
		Priority = THREAD_PRIORITY_IDLE;
	if (Priority > THREAD_PRIORITY_TIME_CRITICAL)
		Priority = THREAD_PRIORITY_TIME_CRITICAL;
	SetThreadPriority(Thread,Priority);
	return -(Old - THREAD_PRIORITY_NORMAL);
#endif
}

void* BrushCreate(uint32_t Color) { return CreateSolidBrush(Color); }
void BrushDelete(void* Handle) { if (Handle) DeleteObject((HGDIOBJ)Handle); }
void WinFill(void* DC,rect* Rect,rect* Exclude,void* Brush)
{
	RECT r;
	if (Exclude)
		ExcludeClipRect(DC,Exclude->x,Exclude->y,Exclude->x + Exclude->Width,Exclude->y + Exclude->Height);

	r.left = Rect->x;
	r.top = Rect->y;
	r.right = Rect->x + Rect->Width;
	r.bottom = Rect->y + Rect->Height;

	FillRect(DC,&r,(HBRUSH)Brush);
}

void EventWait(void* Handle,int Time) { WaitForSingleObject(Handle,Time); } // -1 = INFINITE
void* EventCreate(bool_t ManualReset,bool_t InitState) { return CreateEvent(NULL,ManualReset,InitState,NULL); }
void EventSet(void* Handle) { SetEvent(Handle); }
void EventReset(void* Handle) { ResetEvent(Handle); }
void EventClose(void* Handle) { CloseHandle(Handle); }

void ThreadSleep(int Time) { Sleep(Time); }
void ThreadTerminate(void* Handle)
{
	if (Handle && WaitForSingleObject(Handle,5000) == WAIT_TIMEOUT)
		TerminateThread(Handle,0);
}

void* ThreadCreate(int(*Start)(void*),void* Parameter,int Quantum)
{
	DWORD Id;
	HANDLE Handle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)Start,Parameter,0,&Id);

#if defined(_WIN32_WCE)
	if (FuncCeSetThreadQuantum)
		FuncCeSetThreadQuantum(Handle,Quantum);
#endif
	return Handle;
}

void CheckHeap()
{
#if defined(_DEBUG) && defined(_MSC_VER)
	assert(_CrtCheckMemory());
#endif
}

//#define FIND 0xAD1A30

int AvailMemory()
{
	MEMORYSTATUS Status;
	Status.dwLength = sizeof(Status);

	GlobalMemoryStatus(&Status); 

	return Status.dwAvailPhys;
}

void FreeBlock(void* p)
{
	if (p)
	{
#ifndef NDEBUG
		if (VirtualFree(p,0,MEM_RELEASE))
			--BlockCount;
#else
		VirtualFree(p,0,MEM_RELEASE);
#endif
	}
}

void* AllocBlock(int n,bool_t Optional)
{
	void* p;
	int h = 1;

	if (Optional && AvailMemory() < 256*1024+n) // we want to avoid OS low memory warning
		return NULL;

	do
	{
		p = VirtualAlloc(NULL,n,MEM_COMMIT,PAGE_READWRITE);
	}
	while (!p && !Optional && n && NodeHibernate(h--));

#ifndef NDEBUG
	if (p) ++BlockCount;
#endif

	return p;
}

void* Alloc(int n)
{
	void* p;
	int h = 1;
	do
	{
		p = malloc(n);
	}
	while (!p && n && NodeHibernate(h--));

	//DEBUG_MSG1(-1,T("Alloc %d"),n);

#ifdef FIND
	if ((int)p == FIND) DebugBreak();
#endif

	return p;
}

void* CAlloc(int n,int m)
{
	void* p;
	int h = 1;
	n *= m;

	do
	{
		p = malloc(n);
	}
	while (!p && n && NodeHibernate(h--));
	
	if (p)
		memset(p,0,n);

#ifdef FIND
	if ((int)p == FIND) DebugBreak();
#endif

	return p;
}

void* ReAlloc(void* p,int n)
{
	int h = 1;
	do
	{
		p = realloc(p,n);
	}
	while (!p && n && NodeHibernate(h--));

#ifdef FIND
	if ((int)p == FIND) DebugBreak();
#endif

	return p;
}

void Free(void* p)
{
	free(p);
}

void ShowMessage(const tchar_t* Title,const tchar_t* Msg,...)
{
	bool_t Wait = WaitCursor;