interface.c

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

		KillTimer(p->Win.Wnd,TIMER_SLEEP);
#endif
}

static void UpdateTitleScroll(intface* p)
{
	if (p->Focus && p->TitleNameSize < p->TitleNameWidth)
	{
		if (p->TitleNameOffset >= p->TitleNameWidth - p->TitleNameSize)
			p->TitleNameOffset = p->TitleNameWidth - p->TitleNameSize;
		SetTimer(p->Win.Wnd,TIMER_TITLESCROLL,TITLESCROLL_CYCLE,NULL);
	}
	else
	{
		p->TitleNameOffset = 0;
		p->ScrollMode = 0;
		KillTimer(p->Win.Wnd,TIMER_TITLESCROLL);
	}
}

static void TitleScroll(intface* p)
{
	if (p->ScrollMode<TITLESCROLL_WAIT)
		++p->ScrollMode;
	else
	if (p->ScrollMode==TITLESCROLL_WAIT)
	{
		p->TitleNameOffset += 3;
		if (p->TitleNameOffset >= p->TitleNameWidth - p->TitleNameSize)
		{
			p->TitleNameOffset = p->TitleNameWidth - p->TitleNameSize;
			++p->ScrollMode;
		}
		InvalidateRect(p->WndTitle,NULL,1); 
	}
	else
	if (p->ScrollMode<TITLESCROLL_WAIT*2+1)
		++p->ScrollMode;
	else
	{
		p->TitleNameOffset -= 3;
		if (p->TitleNameOffset<=0)
		{
			p->TitleNameOffset=0;
			p->ScrollMode = 0;
		}
		InvalidateRect(p->WndTitle,NULL,1); 
	}

	UpdateTitleScroll(p);
}

static bool_t ShowVideo(intface* p)
{
	bool_t b = p->Focus;
	if (!b)
		p->Player->Get(p->Player,PLAYER_SHOWINBACKGROUND,&b,sizeof(b));
	return b;
}

static void UpdateClippingTimer(intface* p)
{
	if (p->Clipping && ShowVideo(p))
		SetTimer(p->Win.Wnd,TIMER_CLIPPING,CLIPPING_CYCLE,NULL);
	else
		KillTimer(p->Win.Wnd,TIMER_CLIPPING);
}

static bool_t IsOverlay(intface* p)
{
	bool_t b = 0;
	p->Player->Get(p->Player,PLAYER_VIDEO_OVERLAY,&b,sizeof(b));
	return b;
}

static bool_t IsOverlapped(intface* p)
{
	if (!p->Win.FullScreen || p->Wait)
	{
		// check for overlapping top-level windows
		p->Overlap = 0;
		EnumWindows(EnumCheck,(LPARAM)p);
		if (p->Overlap)
			return 1;
	}
	return 0;
}

static void UpdateClipping(intface* p,bool_t Suggest,bool_t HotKey)
{
	if (p->Clipping != Suggest)
	{
		KillTimer(p->Win.Wnd,TIMER_CLIPPING2);

		if (!Suggest && IsOverlapped(p))
			return; // overlapping window -> clipping still needed

		p->Clipping = Suggest;
		p->Player->Set(p->Player,PLAYER_CLIPPING,&p->Clipping,sizeof(bool_t));

		if (HotKey)
			UpdateHotKey(p,!p->Clipping,0);

		UpdateClippingTimer(p);
	}
}

static void RefreshButton(intface* p,int No,bool_t* State,int Id,int Off,int On)
{
	int i;
	bool_t b;

	if (p->Player->Get(p->Player,No,&b,sizeof(b)) != ERR_NONE)
		b = -1;

	switch (No)
	{
	case PLAYER_PLAY: i = SKIN_PLAY; break;
	case PLAYER_FFWD: i = SKIN_FFWD; break;
	case PLAYER_MUTE: i = SKIN_MUTE; break;
	case PLAYER_FULLSCREEN: i = SKIN_FULLSCREEN; break;
	case PLAYER_REPEAT: i = SKIN_REPEAT; break;
	default: i = -1; break;
	}

	if (i>=0 && p->Skin[p->SkinNo].Item[i].Pushed != b)
	{
		p->Skin[p->SkinNo].Item[i].Pushed = b;
		SkinDrawItem(p->Skin+p->SkinNo,p->Win.Wnd,i,&p->SkinArea);
	}

	if (State && b != *State)
	{
		if (b == -1 || *State == -1)
			SendMessage(p->Win.WndTB,TB_ENABLEBUTTON,Id,MAKELPARAM(b!=-1,0));

		*State = b;

		if (b != -1)
		{
			SendMessage(p->Win.WndTB,TB_CHECKBUTTON,Id,MAKELPARAM(b,0));

			if (On>=0)
				SendMessage(p->Win.WndTB,TB_CHANGEBITMAP,Id,MAKELPARAM(p->Win.BitmapNo+(b?On:Off),0));
		}
	}
}

static void SetTrackThumb(HWND Wnd, bool_t State)
{
	int Style = GetWindowLong(Wnd,GWL_STYLE);

	if ((Style & TBS_NOTHUMB) != (State?0:TBS_NOTHUMB))
	{
		Style ^= TBS_NOTHUMB;
		SetWindowLong(Wnd,GWL_STYLE,Style);
	}
}

static void UpdateTitleTime(intface* p)
{
	if (p->WndTitle)
	{
		tick_t Time;
		if (p->Player->Get(p->Player,PLAYER_POSITION,&Time,sizeof(tick_t)) == ERR_NONE)
		{
			Time = (Time / TICKSPERSEC) * TICKSPERSEC;
			if (Time<0)
				Time=0;
		}
		else
			Time = -1;
	
		if (Time != p->TitleTime)
		{
			RECT r;

			r.left = p->TitleWidth - p->TitleTimeWidth - p->TitleDurWidth - p->TitleBorder;
			r.right = r.left + p->TitleTimeWidth;
			r.top = 0;
			r.bottom = p->TitleHeight;

			p->TitleTime = Time;
			InvalidateRect(p->WndTitle,&r,0);
		}
	}
}

static void UpdateMenuBool(intface* p,int MenuId,int Param)
{
	bool_t b = 0;
	WinMenuEnable(&p->Win,1,MenuId,p->Player->Get(p->Player,Param,&b,sizeof(b)) != ERR_NOT_SUPPORTED);
	WinMenuCheck(&p->Win,1,MenuId,b);
}

static void UpdateMenuInt(intface* p,int MenuId,int Param,int Value)
{
	int v = 0;
	WinMenuEnable(&p->Win,1,MenuId,p->Player->Get(p->Player,Param,&v,sizeof(v)) != ERR_NOT_SUPPORTED);
	WinMenuCheck(&p->Win,1,MenuId,v==Value);
}

static void UpdateMenuFrac(intface* p,int MenuId,int Param,int Num,int Den)
{
	fraction f = {0,0};
	WinMenuEnable(&p->Win,1,MenuId,p->Player->Get(p->Player,Param,&f,sizeof(f)) != ERR_NOT_SUPPORTED);
	WinMenuCheck(&p->Win,1,MenuId,f.Num*Den==f.Den*Num);
}

static void UpdateMenu(intface* p)
{
	packetformat PacketFormat;
	node* AOutput;
	bool_t Stereo;
	bool_t b;
	int* i;
	int No,Id;
	int PreAmp;
	bool_t Accel;
	tchar_t Name[20+1];
	int ACurrent = -1;
	int VCurrent = -1;
	int SubCurrent = -1;

	// remove old chapters
	if (!WinMenuEnable(&p->Win,0,IF_FILE_CHAPTERS_NONE,0))
	{
		WinMenuInsert(&p->Win,0,IF_CHAPTER+1,IF_FILE_CHAPTERS_NONE,LangStr(INTERFACE_ID,IF_FILE_CHAPTERS_NONE));

		for (No=1;No<MAXCHAPTER;++No)
			if (!WinMenuDelete(&p->Win,0,IF_CHAPTER+No))
				break;
	}

	// add new chapters
	for (No=1;No<MAXCHAPTER && PlayerGetChapter(p->Player,No,Name,TSIZEOF(Name))>=0;++No)
		WinMenuInsert(&p->Win,0,IF_FILE_CHAPTERS_NONE,IF_CHAPTER+No,Name);

	if (No>1)
		WinMenuDelete(&p->Win,0,IF_FILE_CHAPTERS_NONE);
	else
		WinMenuEnable(&p->Win,0,IF_FILE_CHAPTERS_NONE,0);

	// remove old streams
	if (p->MenuVStream >= 0)
	{
		WinMenuInsert(&p->Win,1,p->MenuVStream,IF_OPTIONS_VIDEO_STREAM_NONE, LangStr(INTERFACE_ID,IF_OPTIONS_VIDEO_STREAM_NONE));

		for (No=0;No<p->MenuStreams;++No)
			WinMenuDelete(&p->Win,1,IF_STREAM_VIDEO+No);
	}
	if (p->MenuAStream >= 0)
	{
		WinMenuInsert(&p->Win,1,p->MenuAStream,IF_OPTIONS_AUDIO_STREAM_NONE, LangStr(INTERFACE_ID,IF_OPTIONS_AUDIO_STREAM_NONE));

		for (No=0;No<p->MenuStreams;++No)
			WinMenuDelete(&p->Win,1,IF_STREAM_AUDIO+No);
	}

	if (p->MenuSubStream >= 0)
		for (No=0;No<p->MenuStreams;++No)
			WinMenuDelete(&p->Win,1,IF_STREAM_SUBTITLE+No);

	// add new streams
	p->MenuStreams = 0;
	p->MenuAStream = -1;
	p->MenuVStream = -1;
	p->MenuSubStream = -1;

	for (No=0;PlayerGetStream(p->Player,No,&PacketFormat,Name,TSIZEOF(Name),NULL);++No)
		switch (PacketFormat.Type)
		{
		case PACKET_VIDEO:
			p->MenuVStream = IF_STREAM_VIDEO+No;
			WinMenuInsert(&p->Win,1,IF_OPTIONS_VIDEO_STREAM_NONE,IF_STREAM_VIDEO+No,Name);
			break;
		case PACKET_AUDIO:
			p->MenuAStream = IF_STREAM_AUDIO+No;
			WinMenuInsert(&p->Win,1,IF_OPTIONS_AUDIO_STREAM_NONE,IF_STREAM_AUDIO+No,Name);
			break;
		case PACKET_SUBTITLE:
			p->MenuSubStream = IF_STREAM_SUBTITLE+No;
			WinMenuInsert(&p->Win,1,IF_OPTIONS_SUBTITLE_STREAM_NONE,IF_STREAM_SUBTITLE+No,Name);
			break;
		}

	p->MenuStreams = No;

	p->Player->Get(p->Player,PLAYER_VSTREAM,&VCurrent,sizeof(int));
	p->Player->Get(p->Player,PLAYER_ASTREAM,&ACurrent,sizeof(int));
	p->Player->Get(p->Player,PLAYER_SUBSTREAM,&SubCurrent,sizeof(int));

	if (p->MenuVStream<0)
		WinMenuEnable(&p->Win,1,IF_OPTIONS_VIDEO_STREAM_NONE,0);
	else
	{
		WinMenuCheck(&p->Win,1,IF_STREAM_VIDEO+VCurrent,1);
		WinMenuDelete(&p->Win,1,IF_OPTIONS_VIDEO_STREAM_NONE);
	}

	if (p->MenuAStream<0)
		WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STREAM_NONE,0);
	else
	{
		WinMenuCheck(&p->Win,1,IF_STREAM_AUDIO+ACurrent,1);
		WinMenuDelete(&p->Win,1,IF_OPTIONS_AUDIO_STREAM_NONE);
	}

	if (SubCurrent >= MAXSTREAM) 
		SubCurrent = -1;

	WinMenuEnable(&p->Win,1,IF_OPTIONS_SUBTITLE_STREAM_NONE,p->MenuSubStream>=0);
	WinMenuCheck(&p->Win,1,IF_OPTIONS_SUBTITLE_STREAM_NONE,SubCurrent<0);
	if (SubCurrent>=0)
		WinMenuCheck(&p->Win,1,IF_STREAM_SUBTITLE+SubCurrent,1);

	UpdateMenuFrac(p,IF_OPTIONS_ASPECT_AUTO,PLAYER_ASPECT,0,1);
	UpdateMenuFrac(p,IF_OPTIONS_ASPECT_SQUARE,PLAYER_ASPECT,1,1);
	UpdateMenuFrac(p,IF_OPTIONS_ASPECT_4_3_SCREEN,PLAYER_ASPECT,-4,3);
	UpdateMenuFrac(p,IF_OPTIONS_ASPECT_4_3_NTSC,PLAYER_ASPECT,10,11);
	UpdateMenuFrac(p,IF_OPTIONS_ASPECT_4_3_PAL,PLAYER_ASPECT,12,11);
	UpdateMenuFrac(p,IF_OPTIONS_ASPECT_16_9_SCREEN,PLAYER_ASPECT,-16,9);
	UpdateMenuFrac(p,IF_OPTIONS_ASPECT_16_9_NTSC,PLAYER_ASPECT,40,33);
	UpdateMenuFrac(p,IF_OPTIONS_ASPECT_16_9_PAL,PLAYER_ASPECT,16,11);

	UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FIT_SCREEN,PLAYER_FULL_ZOOM,0,1);
	UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FIT_110,PLAYER_FULL_ZOOM,-11,10);
	UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FIT_120,PLAYER_FULL_ZOOM,-12,10);
	UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FIT_130,PLAYER_FULL_ZOOM,-13,10);
	UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FILL_SCREEN,PLAYER_FULL_ZOOM,-4,SCALE_ONE);
	UpdateMenuFrac(p,IF_OPTIONS_ZOOM_STRETCH_SCREEN,PLAYER_FULL_ZOOM,-3,SCALE_ONE);
	UpdateMenuFrac(p,IF_OPTIONS_ZOOM_50,PLAYER_FULL_ZOOM,1,2);
	UpdateMenuFrac(p,IF_OPTIONS_ZOOM_100,PLAYER_FULL_ZOOM,1,1);
	UpdateMenuFrac(p,IF_OPTIONS_ZOOM_150,PLAYER_FULL_ZOOM,3,2);
	UpdateMenuFrac(p,IF_OPTIONS_ZOOM_200,PLAYER_FULL_ZOOM,2,1);

	UpdateMenuBool(p,IF_OPTIONS_VIDEO_ZOOM_SMOOTH50,PLAYER_SMOOTH50);
	UpdateMenuBool(p,IF_OPTIONS_VIDEO_ZOOM_SMOOTHALWAYS,PLAYER_SMOOTHALWAYS);

	WinMenuCheck(&p->Win,1,IF_OPTIONS_VIEW_TITLEBAR,p->TitleBar);
	WinMenuCheck(&p->Win,1,IF_OPTIONS_VIEW_TRACKBAR,p->TrackBar);
	WinMenuCheck(&p->Win,1,IF_OPTIONS_VIEW_TASKBAR,p->TaskBar);

	//UpdateMenuInt(p,IF_OPTIONS_AUDIO_QUALITY_LOW,PLAYER_AUDIO_QUALITY,0);
	//UpdateMenuInt(p,IF_OPTIONS_AUDIO_QUALITY_MEDIUM,PLAYER_AUDIO_QUALITY,1);
	//UpdateMenuInt(p,IF_OPTIONS_AUDIO_QUALITY_HIGH,PLAYER_AUDIO_QUALITY,2);

	if (p->Player->Get(p->Player,PLAYER_PREAMP,&PreAmp,sizeof(PreAmp)) != ERR_NONE)
		PreAmp = 0;
	if (PreAmp != p->MenuPreAmp)
	{
		p->MenuPreAmp = PreAmp;
		stprintf_s(Name,TSIZEOF(Name),LangStr(INTERFACE_ID,IF_OPTIONS_AUDIO_PREAMP),PreAmp);
		WinMenuDelete(&p->Win,1,IF_OPTIONS_AUDIO_PREAMP);
		WinMenuInsert(&p->Win,1,IF_OPTIONS_AUDIO_PREAMP_INC,IF_OPTIONS_AUDIO_PREAMP,Name);
	}

	UpdateMenuInt(p,IF_OPTIONS_VIDEO_QUALITY_LOWEST,PLAYER_VIDEO_QUALITY,0);
	UpdateMenuInt(p,IF_OPTIONS_VIDEO_QUALITY_LOW,PLAYER_VIDEO_QUALITY,1);
	UpdateMenuInt(p,IF_OPTIONS_VIDEO_QUALITY_NORMAL,PLAYER_VIDEO_QUALITY,2);

	UpdateMenuInt(p,IF_OPTIONS_ROTATE_GUI,PLAYER_FULL_DIR,-1);
	UpdateMenuInt(p,IF_OPTIONS_ROTATE_0,PLAYER_FULL_DIR,0);
	UpdateMenuInt(p,IF_OPTIONS_ROTATE_90,PLAYER_FULL_DIR,DIR_SWAPXY | DIR_MIRRORLEFTRIGHT);
	UpdateMenuInt(p,IF_OPTIONS_ROTATE_270,PLAYER_FULL_DIR,DIR_SWAPXY | DIR_MIRRORUPDOWN);
	UpdateMenuInt(p,IF_OPTIONS_ROTATE_180,PLAYER_FULL_DIR,DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT);

	UpdateMenuFrac(p,IF_OPTIONS_SPEED_10,PLAYER_PLAY_SPEED,1,10);
	UpdateMenuFrac(p,IF_OPTIONS_SPEED_25,PLAYER_PLAY_SPEED,1,4);
	UpdateMenuFrac(p,IF_OPTIONS_SPEED_50,PLAYER_PLAY_SPEED,1,2);
	UpdateMenuFrac(p,IF_OPTIONS_SPEED_80,PLAYER_PLAY_SPEED,8,10);
	UpdateMenuFrac(p,IF_OPTIONS_SPEED_90,PLAYER_PLAY_SPEED,9,10);
	UpdateMenuFrac(p,IF_OPTIONS_SPEED_100,PLAYER_PLAY_SPEED,1,1);
	UpdateMenuFrac(p,IF_OPTIONS_SPEED_110,PLAYER_PLAY_SPEED,11,10);
	UpdateMenuFrac(p,IF_OPTIONS_SPEED_120,PLAYER_PLAY_SPEED,12,10);
	UpdateMenuFrac(p,IF_OPTIONS_SPEED_150,PLAYER_PLAY_SPEED,3,2);
	UpdateMenuFrac(p,IF_OPTIONS_SPEED_200,PLAYER_PLAY_SPEED,2,1);
	UpdateMenuFrac(p,IF_OPTIONS_SPEED_BENCHMARK,PLAYER_PLAY_SPEED,0,1);

	UpdateMenuBool(p,IF_PLAY,PLAYER_PLAY);

	WinMenuEnable(&p->Win,1,IF_OPTIONS_VIDEO_DITHER,p->Color->Get(p->Color,COLOR_DITHER,&b,sizeof(b)) != ERR_NOT_SUPPORTED);
	WinMenuCheck(&p->Win,1,IF_OPTIONS_VIDEO_DITHER,b);
	
	UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO,PLAYER_STEREO,STEREO_NORMAL);
	UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO_SWAPPED,PLAYER_STEREO,STEREO_SWAPPED);
	UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO_JOINED,PLAYER_STEREO,STEREO_JOINED);
	UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO_LEFT,PLAYER_STEREO,STEREO_LEFT);
	UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO_RIGHT,PLAYER_STEREO,STEREO_RIGHT);

	UpdateMenuBool(p,IF_OPTIONS_FULLSCREEN,PLAYER_FULLSCREEN);
	UpdateMenuBool(p,IF_OPTIONS_REPEAT,PLAYER_REPEAT);
	UpdateMenuBool(p,IF_OPTIONS_SHUFFLE,PLAYER_SHUFFLE);

	p->Equalizer->Get(p->Equalizer,EQUALIZER_ENABLED,&b,sizeof(b));
	WinMenuCheck(&p->Win,1,IF_OPTIONS_EQUALIZER,b);

	p->Player->Get(p->Player,PLAYER_VIDEO_ACCEL,&Accel,sizeof(Accel));
	p->Player->Get(p->Player,PLAYER_VOUTPUTID,&Id,sizeof(Id));

	WinMenuCheck(&p->Win,1,IF_OPTIONS_VIDEO_TURNOFF,!Id);

	for (No=0,i=ARRAYBEGIN(p->VOutput,int);i!=ARRAYEND(p->VOutput,int);++i,++No)
	{
		WinMenuCheck(&p->Win,1,IF_VIDEO+No,*i==Id && !Accel);
		WinMenuCheck(&p->Win,1,IF_VIDEOACCEL+No,*i==Id && Accel);
	}

	p->Player->Get(p->Player,PLAYER_AOUTPUTID,&Id,sizeof(Id));
	WinMenuCheck(&p->Win,1,IF_OPTIONS_AUDIO_TURNOFF,!Id);

	for (No=0,i=ARRAYBEGIN(p->AOutput,int);i!=ARRAYEND(p->AOutput,int);++i,++No)
		WinMenuCheck(&p->Win,1,IF_AUDIO+No,*i==Id);

	Stereo = 1;
	p->Player->Get(p->Player,PLAYER_AOUTPUT,&AOutput,sizeof(AOutput));
	if (AOutput && AOutput->Get(AOutput,OUT_INPUT|PIN_FORMAT,&PacketFormat,sizeof(PacketFormat))==ERR_NONE && 
		PacketFormat.Type == PACKET_AUDIO && PacketFormat.Format.Audio.Channels<2)
		Stereo = 0;

	WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO,Stereo);
	WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO_SWAPPED,Stereo);
	WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO_JOINED,Stereo);
	WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO_LEFT,Stereo);
	WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO_RIGHT,Stereo);
}

static void UpdatePosition(intface* p);

static int Delta(intface* p,node* Node,int Param,int d,int Min,int Max)
{
	int State;
	if (Node && Node->Get(Node,Param,&State,sizeof(State))==ERR_NONE)
	{
		State += d;
		if (State < Min)
			State = Min;
		if (State > Max)
			State = Max;

		Node->Set(Node,Param,&State,sizeof(State));

		if (Param == PLAYER_VOLUME)
		{
			if (State > Min) Toggle(p,PLAYER_MUTE,0);
			UpdateVolume(p);
		}
	}
	return State;
}

static bool_t IsCoverAtr(player *Player)
{
	node* Format;
	int CoverArt;
	int VStream;
	return Player->Get(Player,PLAYER_FORMAT,&Format,sizeof(Format))==ERR_NONE && Format &&
		Format->Get(Format,FORMAT_COVERART,&CoverArt,sizeof(CoverArt))==ERR_NONE &&
		Player->Get(Player,PLAYER_VSTREAM,&VStream,sizeof(VStream))==ERR_NONE && VStream==CoverArt;
}

static bool_t ToggleFullScreen(intface* p,int Force,int CoverArtFullScreen)
{
	bool_t State = 0;
	if (p->Player->Get(p->Player,PLAYER_FULLSCREEN,&State,sizeof(State))==ERR_NONE)
	{
		node* VOutput;
		bool_t Primary;
		packetformat Format;

		if (State==Force)
			return State;
		State = !State;

		if (p->Player->Get(p->Player,PLAYER_VOUTPUT,&VOutput,sizeof(VOutput))!=ERR_NONE ||
			!VOutput ||
			VOutput->Get(VOutput,VOUT_PRIMARY,&Primary,sizeof(Primary))!=ERR_NONE || !Primary ||
			(!CoverArtFullScreen && IsCoverAtr(p->Player)) ||
			(!p->ForceFullScreen && VOutput->Get(VOutput,OUT_INPUT|PIN_FORMAT,&Format,sizeof(Format))!=ERR_NONE) ||
			(!p->ForceFullScreen && !Format.Format.Video.Width))
			State = 0;

		UpdatePosition(p); // before returning from fullscreen

		if (!State)
		{
			p->Player->Set(p->Player,PLAYER_FULLSCREEN,&State,sizeof(State));
			p->Player->Set(p->Player,PLAYER_UPDATEVIDEO,NULL,0);