interface.c

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

	{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_90 },
	{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_100 },
	{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_110 },
	{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_120 },
	{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_150 },
	{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_200 },
	{ 1,INTERFACE_ID, IF_OPTIONS_VIEW, MENU_SMALL },	
	{ 2,INTERFACE_ID, IF_OPTIONS_ZOOM },
#if !defined(SH3)
	{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FIT_SCREEN },
	{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FILL_SCREEN },
	{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_STRETCH_SCREEN },
	{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FIT_110 },
	{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FIT_120 },
	{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FIT_130 },
	{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_50 }, 
#endif
	{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_100 },
#if !defined(SH3)
	{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_150 },
#endif
	{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_200 },
#if !defined(SH3)
	{ 2,INTERFACE_ID, IF_OPTIONS_ASPECT },
	{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_AUTO },
	{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_SQUARE },
	{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_4_3_SCREEN },
	{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_4_3_NTSC },
	{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_4_3_PAL },
	{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_16_9_SCREEN },
	{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_16_9_NTSC },
	{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_16_9_PAL },
#endif
	{ 2,INTERFACE_ID, IF_OPTIONS_ORIENTATION },
	{ 3,INTERFACE_ID, IF_OPTIONS_ORIENTATION_FULLSCREEN },
	{ 3,INTERFACE_ID, IF_OPTIONS_ROTATE_GUI },
	{ 3,INTERFACE_ID, IF_OPTIONS_ROTATE_0 },
	{ 3,INTERFACE_ID, IF_OPTIONS_ROTATE_90 },
	{ 3,INTERFACE_ID, IF_OPTIONS_ROTATE_270 },
	{ 3,INTERFACE_ID, IF_OPTIONS_ROTATE_180 },
	{ 2,INTERFACE_ID, IF_OPTIONS_VIEW, MENU_NOTSMALL },	
	{ 3,INTERFACE_ID, IF_OPTIONS_VIEW_TITLEBAR },
	{ 3,INTERFACE_ID, IF_OPTIONS_VIEW_TRACKBAR }, 
	{ 3,INTERFACE_ID, IF_OPTIONS_VIEW_TASKBAR }, 
	{ 1,INTERFACE_ID, IF_OPTIONS_VIDEO },
#if !defined(SH3) && !defined(MIPS)
	{ 2,INTERFACE_ID, IF_OPTIONS_VIDEO_ZOOM_SMOOTH50 },
	{ 2,INTERFACE_ID, IF_OPTIONS_VIDEO_ZOOM_SMOOTHALWAYS },
	{ 2,INTERFACE_ID, IF_OPTIONS_VIDEO_DITHER },
#endif
	{ 2,INTERFACE_ID, IF_OPTIONS_VIDEO_QUALITY },
	{ 3,INTERFACE_ID, IF_OPTIONS_VIDEO_QUALITY_LOWEST },
	{ 3,INTERFACE_ID, IF_OPTIONS_VIDEO_QUALITY_LOW },
	{ 3,INTERFACE_ID, IF_OPTIONS_VIDEO_QUALITY_NORMAL }, 
	{ 2,-1,-1 },
	{ 2,INTERFACE_ID, IF_OPTIONS_VIDEO_DEVICE, MENU_SMALL|MENU_GRAYED },
	{ 3,INTERFACE_ID, IF_OPTIONS_VIDEO_TURNOFF },
	{ 2,-1,-1 },
	{ 2,INTERFACE_ID, IF_OPTIONS_VIDEO_STREAM, MENU_SMALL|MENU_GRAYED },
	{ 3,INTERFACE_ID, IF_OPTIONS_VIDEO_STREAM_NONE },

	{ 1,INTERFACE_ID, IF_OPTIONS_AUDIO },
	{ 2,INTERFACE_ID, IF_OPTIONS_AUDIO_CHANNELS, MENU_SMALL },
	{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO },
	{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO_SWAPPED },
	{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO_JOINED },
	{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO_LEFT },
	{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO_RIGHT },
//	{ 2,-1,-1 },
//	{ 2,INTERFACE_ID, IF_OPTIONS_AUDIO_QUALITY },
//	{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_QUALITY_LOW },
//	{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_QUALITY_MEDIUM },
//	{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_QUALITY_HIGH }, 
	{ 2,-1,-1 },
	{ 2,INTERFACE_ID, IF_OPTIONS_AUDIO_PREAMP_DEC },
	{ 2,INTERFACE_ID, IF_OPTIONS_AUDIO_PREAMP },
	{ 2,INTERFACE_ID, IF_OPTIONS_AUDIO_PREAMP_INC }, 
	{ 2,-1,-1 },
	{ 2,INTERFACE_ID, IF_OPTIONS_AUDIO_DEVICE, MENU_SMALL|MENU_GRAYED },
	{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_TURNOFF },
	{ 2,-1,-1 },
	{ 2,INTERFACE_ID, IF_OPTIONS_AUDIO_STREAM, MENU_SMALL|MENU_GRAYED },
	{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STREAM_NONE },

//!SUBTITLE	{ 1,INTERFACE_ID, IF_OPTIONS_SUBTITLE_STREAM, MENU_GRAYED },
//!SUBTITLE	{ 2,INTERFACE_ID, IF_OPTIONS_SUBTITLE_STREAM_NONE },

	{ 1,-1,-1 },
	{ 1,INTERFACE_ID, IF_OPTIONS_REPEAT },
	{ 1,INTERFACE_ID, IF_OPTIONS_SHUFFLE },
	{ 1,INTERFACE_ID, IF_OPTIONS_EQUALIZER },
	{ 1,INTERFACE_ID, IF_OPTIONS_FULLSCREEN },
#if defined(CONFIG_SKIN)
	{ 1,INTERFACE_ID, IF_OPTIONS_SKIN },
#endif
	{ 1,-1,-1 },
	{ 1,INTERFACE_ID, IF_OPTIONS_SETTINGS },

	MENUDEF_END
};

void CreateButtons(intface* p)
{
	if (QueryPlatform(PLATFORM_TYPENO) != TYPE_SMARTPHONE)
	{
		bool_t FullScreenButton = 1;
		RECT r,rv;

		WinBitmap(&p->Win,IDB_TOOLBAR16,IDB_TOOLBAR32,10);
		WinAddButton(&p->Win,-1,-1,NULL,0);
		WinAddButton(&p->Win,IF_PLAY,0,NULL,1);
		WinAddButton(&p->Win,IF_FASTFORWARD,4,NULL,1);
		WinAddButton(&p->Win,IF_STOP,5,NULL,0);
		WinAddButton(&p->Win,-1,-1,NULL,0);
		WinAddButton(&p->Win,IF_OPTIONS_FULLSCREEN,6,NULL,1);
		WinAddButton(&p->Win,IF_OPTIONS_MUTE,7,NULL,1);

		GetClientRect(p->Win.WndTB,&r);
		SendMessage(p->Win.WndTB,TB_GETRECT,IF_OPTIONS_MUTE,(LPARAM)&rv);
		if (r.right-rv.right < VOLMINWIDTH)
		{
			WinDeleteButton(&p->Win,IF_FASTFORWARD);
			SendMessage(p->Win.WndTB,TB_GETRECT,IF_OPTIONS_MUTE,(LPARAM)&rv);
			if (r.right-rv.right < VOLMINWIDTH)
			{
				WinDeleteButton(&p->Win,IF_OPTIONS_FULLSCREEN);
				FullScreenButton = 0;
			}
		}

		WinMenuDelete(&p->Win,0,IF_PLAY);
		if (FullScreenButton)
			WinMenuDelete(&p->Win,1,IF_OPTIONS_FULLSCREEN);
		WinMenuDelete(&p->Win,1,IF_OPTIONS_MUTE);
	}
}

static void UpdateVolume(intface* p)
{
	int x;

	if (p->Skin[p->SkinNo].Valid)
		SkinUpdate(&p->Skin[p->SkinNo],p->Player,p->Win.Wnd,&p->SkinArea);

	if (p->WndVol)
	{
		bool_t Enable = p->Player->Get(p->Player,PLAYER_VOLUME,&x,sizeof(x))==ERR_NONE;
		EnableWindow(p->WndVol,Enable);
		SetTrackThumb(p->WndVol,Enable);
		if (Enable)
			SendMessage(p->WndVol,TBM_SETPOS,1,x);
	}
	RefreshButton(p,PLAYER_MUTE,&p->Mute,IF_OPTIONS_MUTE,7,8);
}

static void CreateVolumeTrack(intface* p)
{
	if (QueryPlatform(PLATFORM_TYPENO) != TYPE_SMARTPHONE)
	{
		WNDCLASS WinClass;

		memset(&WinClass,0,sizeof(WinClass));
		WinClass.style			= CS_HREDRAW | CS_VREDRAW;
		WinClass.lpfnWndProc	= (WNDPROC) VolBackProc;
		WinClass.cbClsExtra		= 0;
		WinClass.cbWndExtra		= 0;
		WinClass.hInstance		= p->Win.Module;
		WinClass.hCursor		= WinCursorArrow();
		WinClass.hbrBackground	= GetSysColorBrush(COLOR_BTNFACE);
		WinClass.lpszMenuName	= 0;
		WinClass.lpszClassName	= T("VolumeBack");
		RegisterClass(&WinClass);

		p->WndVolBack = CreateWindowEx( 
			WS_EX_TOPMOST,                    
			WinClass.lpszClassName,       
			Context()->ProgramName,   
			(p->Win.ToolBarHeight ? WS_CHILD:WS_POPUP) | WS_VISIBLE | 
			TBS_HORZ|TBS_BOTH|TBS_NOTICKS|TBS_FIXEDLENGTH, 
			200, 0,    
			40, 20,   
			(p->Win.ToolBarHeight ? p->Win.WndTB:p->Win.Wnd),	
			NULL,						
			p->Win.Module,                     
			NULL                      
			); 

		p->WndVol = CreateWindowEx( 
			0,                    
			TRACKBAR_CLASS,       
			NULL,   
			WS_CHILD | WS_VISIBLE | 
			TBS_HORZ|TBS_BOTH|TBS_NOTICKS|TBS_FIXEDLENGTH, 
			0, 0,    
			40, 20,   
			p->WndVolBack,
			NULL,						
			p->Win.Module,                     
			NULL                      
			); 

		p->DefVolProc = (WNDPROC)GetWindowLong(p->WndVol,GWL_WNDPROC);
		SetWindowLong(p->WndVol,GWL_WNDPROC,(LONG)VolProc);
		WinSetObject(p->WndVol,&p->Win);

		SendMessage(p->WndVol, TBM_SETRANGE, FALSE,MAKELONG(0,100));
		SendMessage(p->WndVol, TBM_SETPAGESIZE,0,10);
		SendMessage(p->WndVol, TBM_SETLINESIZE,0,10);

		ResizeVolume(p);
		UpdateVolume(p);
	}
}

static int UpdateTitleBar(intface* p,bool_t DoResize)
{
	if (p->TitleBar && !p->WndTitle && p->Win.Wnd)
	{
		WNDCLASS WinClass;

		memset(&WinClass,0,sizeof(WinClass));
		WinClass.style			= CS_HREDRAW | CS_VREDRAW;
		WinClass.lpfnWndProc	= (WNDPROC) TitleProc;
		WinClass.cbClsExtra		= 0;
		WinClass.cbWndExtra		= 0;
		WinClass.hInstance		= p->Win.Module;
		WinClass.hCursor		= WinCursorArrow();
		WinClass.hbrBackground	= NULL;
		WinClass.lpszMenuName	= 0;
		WinClass.lpszClassName	= T("TitleBar");
		RegisterClass(&WinClass);

		p->WndTitle = CreateWindowEx( 
			0,                    
			WinClass.lpszClassName,       
			T("Time"),   
			WS_CHILD | WS_VISIBLE, 
			0, 0,    
			200, 20,   
			p->Win.Wnd,	
			NULL,						
			p->Win.Module,                     
			NULL                      
			); 

		WinSetObject(p->WndTitle,&p->Win);
		p->ClientRect.right = -1;
		if (DoResize) Resize(p);
	}
	if (!p->TitleBar && p->WndTitle)
	{
		DestroyWindow(p->WndTitle);
		p->WndTitle = NULL;
		p->ClientRect.right = -1;
		if (DoResize) Resize(p);
	}
	return ERR_NONE;
}

static NOINLINE void UpdateTrackPos(intface* p)
{
	if (p->Skin[p->SkinNo].Valid)
		SkinUpdate(p->Skin+p->SkinNo,p->Player,p->Win.Wnd,&p->SkinArea);

	if (p->WndTrack)
	{
		fraction f;
		int TrackPos;
		if (p->Player->Get(p->Player,PLAYER_PERCENT,&f,sizeof(fraction)) == ERR_NONE)
			TrackPos = Scale(TRACKMAX,f.Num,f.Den);
		else
			TrackPos = -1;

		if (TrackPos != p->TrackPos)
		{
			if (TrackPos == -1)
			{
				SetTrackThumb(p->WndTrack,0);
				EnableWindow(p->WndTrack,0);
			}
			if (p->TrackPos == -1)
			{
				SetTrackThumb(p->WndTrack,1);
				EnableWindow(p->WndTrack,1);
			}
			p->TrackPos = TrackPos;
			SendMessage(p->WndTrack,TBM_SETPOS,1,TrackPos);
		}
	}
}

static int UpdateTrackBar(intface* p,bool_t DoResize)
{
	bool_t TrackBar = p->TrackBar && !p->Skin[p->SkinNo].Valid;
	if (TrackBar && !p->WndTrack && p->Win.Wnd)
	{
		p->WndTrack = CreateWindowEx( 
			0,                    
			TRACKBAR_CLASS,       
			T("Time"),   
			WS_CHILD | WS_VISIBLE | 
			TBS_HORZ|TBS_BOTH|TBS_NOTICKS|TBS_FIXEDLENGTH, 
			0, 0,    
			200, 20,   
			p->Win.Wnd,	
			NULL,						
			p->Win.Module,                     
			NULL                      
			); 

		p->DefTrackProc = (WNDPROC)GetWindowLong(p->WndTrack,GWL_WNDPROC);
		SetWindowLong(p->WndTrack,GWL_WNDPROC,(LONG)TrackProc);
		WinSetObject(p->WndTrack,&p->Win);

		SendMessage(p->WndTrack, TBM_SETRANGE, FALSE,MAKELONG(0,TRACKMAX));
		SendMessage(p->WndTrack, TBM_SETPAGESIZE,0,TRACKMAX/20);
		SendMessage(p->WndTrack, TBM_SETLINESIZE,0,TRACKMAX/100);

		p->TrackPos = 0;
		UpdateTrackPos(p);
		p->ClientRect.right = -1;
		if (DoResize) Resize(p);
	}
	if (!TrackBar && p->WndTrack)
	{
		DestroyWindow(p->WndTrack);
		p->WndTrack = NULL;
		p->ClientRect.right = -1;
		if (DoResize) Resize(p);
	}
	p->TrackThumb = -1;
	return ERR_NONE;
}

static void BeforeExit(intface* p)
{
	if (Context()->Wnd)
	{
		NodeRegSaveValue(0,REG_INITING,NULL,0,TYPE_INT);
		NodeRegSave((node*)p);
		UpdateHotKey(p,0,1);
		if (p->WndVolBack)
		{
			DestroyWindow(p->WndVolBack);
			p->WndVolBack = NULL;
		}
		Context_Wnd(NULL);
	}
}

static void ShowError2(intface* p, const tchar_t* s)
{
	win* Win;

	if (p->Player)
	{
		p->Player->Set(p->Player,PLAYER_STOP,NULL,1); // full stop (no filling buffers)
		ToggleFullScreen(p,0,0); //ATI tweaks would have problem
	}
	UpdateClipping(p,1,1); // force clipping mode
	
	// find application foreground window
	Win = &p->Win;
	while (Win->Child) Win = Win->Child;

	MessageBox(Win->Wnd,s,LangStr(PLATFORM_ID,PLATFORM_ERROR),MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
}

static void ToggleStream(intface* p,int Id,int Type,bool_t UseNone)
{
	packetformat Format;
	int No,Current,First=-1;

	p->Player->Get(p->Player,Id,&Current,sizeof(int));

	if (Current == MAXSTREAM)
		Current = -1;

	for (No=0;PlayerGetStream(p->Player,No,&Format,NULL,0,NULL);++No)
		if (Format.Type == Type)
		{
			if (First < 0)
				First = No;
			if (Current == No)
				Current = -1;
			else
			if (Current == -1)
				Current = No;
		}

	if (Current == -1)
		Current = UseNone ? MAXSTREAM:First;

	if (Current >= 0)
	{
		p->Player->Set(p->Player,Id,&Current,sizeof(int));
		p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
	}
}

static int UpdateTaskBar(intface* p)
{
	if (!p->Win.FullScreen)
		DIASet(p->TaskBar?DIA_TASKBAR:0,DIA_TASKBAR);
	return ERR_NONE;
}

static int UpdateSkin(intface* p,bool_t Others);
static int UpdateSkinFile(intface* p)
{
	if (p->Player)
	{
		SkinFree(p->Skin,NULL);
		SkinLoad(p->Skin,p->Win.Wnd,p->SkinPath);
		UpdateSkin(p,1);
	}
	return ERR_NONE;
}

static int Command(intface* p,int Cmd)
{
	node* Node;
	bool_t b;
	int i;
	fraction f;
	tick_t t;
	int Zero = 0;

	switch (Cmd)
	{
	case IF_SKIN0:
		p->SkinNo = 0;
		UpdateSkin(p,1);
		break;
	case IF_SKIN1:
		p->SkinNo = 1;
		UpdateSkin(p,1);
		break;
	case IF_OPTIONS_VOLUME_UP:
		Delta(p,(node*)p->Player,PLAYER_VOLUME,10,0,100);
		break;
	case IF_OPTIONS_VOLUME_DOWN:
		Delta(p,(node*)p->Player,PLAYER_VOLUME,-10,0,100);
		break;
	case IF_OPTIONS_VOLUME_UP_FINE:
		Delta(p,(node*)p->Player,PLAYER_VOLUME,3,0,100);
		break;
	case IF_OPTIONS_VOLUME_DOWN_FINE:
		Delta(p,(node*)p->Player,PLAYER_VOLUME,-3,0,100);
		break;
	case IF_OPTIONS_BRIGHTNESS_UP:
		Delta(p,p->Color,COLOR_BRIGHTNESS,6,-128,127);
		break;
	case IF_OPTIONS_BRIGHTNESS_DOWN:
		Delta(p,p->Color,COLOR_BRIGHTNESS,-6,-128,127);
		break;
	case IF_OPTIONS_CONTRAST_UP:
		Delta(p,p->Color,COLOR_CONTRAST,6,-128,127);
		break;
	case IF_OPTIONS_CONTRAST_DOWN:
		Delta(p,p->Color,COLOR_CONTRAST,-6,-128,127);
		break;
	case IF_OPTIONS_SATURATION_UP:
		Delta(p,p->Color,COLOR_SATURATION,6,-128,127);
		break;
	case IF_OPTIONS_SATURATION_DOWN:
		Delta(p,p->Color,COLOR_SATURATION,-6,-128,127);
		break;

	case IF_OPTIONS_SCREEN:
		SetDisplayPower(!GetDisplayPower(),1);
		break;

	case IF_OPTIONS_AUDIO_STEREO_TOGGLE:
		p->Player->Get(p->Player,PLAYER_STEREO,&i,sizeof(i));
		i = i==STEREO_LEFT?STEREO_RIGHT:STEREO_LEFT;
		p->Player->Set(p->Player,PLAYER_STEREO,&i,sizeof(i));
		break;

	case IF_OPTIONS_TOGGLE_VIDEO:
		ToggleStream(p,PLAYER_VSTREAM,PACKET_VIDEO,0);
		break;

	case IF_OPTIONS_TOGGLE_SUBTITLE:
		ToggleStream(p,PLAYER_SUBSTREAM,PACKET_SUBTITLE,1);
		break;

	case IF_OPTIONS_TOGGLE_AUDIO: