interface.cpp

tcpmp 中修改过的界面文件

			Time = -1;

		//更新当前位置
		if( Time==-1 || Time==0 ) {
			if( p->WndPlayList ) {
				int Current;
				p->Player->Get(p->Player,PLAYER_LIST_CURRENT,&Current,sizeof(int));
				if( Current>=0 ) {
					ListBox_SetCurSel( p->WndPlayList, Current );
				}
			}			
		}

		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;  //1为全屏 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( State ) {	//转全屏
			ShowSkinButtons( p, !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 (p->Skin[p->SkinNo].Valid) p->Skin[p->SkinNo].Hidden = State;
	
		WinSetFullScreen(&p->Win,State);
		if (p->Win.WndTB) UpdateWindow((HWND)p->Win.WndTB);

		p->Player->Set(p->Player,PLAYER_FULLSCREEN,&State,sizeof(State));
		if (!State)	{	//转非全屏
			ShowSkinButtons(p, !State);
		}
		p->Player->Set(p->Player,PLAYER_UPDATEVIDEO,NULL,0);
		RefreshButton(p,PLAYER_FULLSCREEN,&p->FullScreen,IF_OPTIONS_FULLSCREEN,-1,-1);
	}
	return State;
}

static bool_t Toggle(intface* p,int Param,int Force)
{	//ShowMessage(NULL, _T("Play"));
	bool_t State = 0;
	if (p->Player->Get(p->Player,Param,&State,sizeof(State))==ERR_NONE)
	{
		assert(Param != PLAYER_FULLSCREEN);
		if (State==Force)
			return State;
		State = !State;
		p->Player->Set(p->Player,Param,&State,sizeof(State));	//通过此处播放或停止
		if (Param == PLAYER_PLAY)
			RefreshButton(p,PLAYER_PLAY,&p->Play,IF_PLAY,0,1);
		else
		if (Param == PLAYER_FFWD)
			RefreshButton(p,PLAYER_FFWD,&p->FFwd,IF_FASTFORWARD,4,1);
		else
			RefreshButton(p,Param,NULL,0,0,0);
	}
	return State;
}

static bool_t IsAutoRun(intface* p, const tchar_t* CmdLine)
{
	while (IsSpace(*CmdLine))
		++CmdLine;

	return tcsnicmp(CmdLine,T("-autorun"),8)==0;
}

static void EnumDir(const tchar_t* Path,const tchar_t* Exts,player* Player)
{
	streamdir DirItem;
	stream* Stream = GetStream(Path,1);
	if (Stream)
	{
		int Result = Stream->EnumDir(Stream,Path,Exts,1,&DirItem);
		
		while (Result == ERR_NONE)
		{
			tchar_t FullPath[MAXPATH];
			AbsPath(FullPath,TSIZEOF(FullPath),DirItem.FileName,Path);

			if (DirItem.Size < 0)
				EnumDir(FullPath,Exts,Player);
			else
			if (DirItem.Type == FTYPE_AUDIO || DirItem.Type == FTYPE_VIDEO)
			{
				int n;
				Player->Get(Player,PLAYER_LIST_COUNT,&n,sizeof(n));
				Player->Set(Player,PLAYER_LIST_URL+n,FullPath,sizeof(FullPath));
			}

			Result = Stream->EnumDir(Stream,NULL,NULL,0,&DirItem);
		}

		NodeDelete((node*)Stream);
	}
}

void ProcessCmdLine( intface* p, const tchar_t* CmdLine)
{
	int n;
	tchar_t URL[MAXPATH];

	if (IsAutoRun(p,CmdLine))
	{
		// search for media files on SD card
		tchar_t Base[MAXPATH];
		int* i;
		array List;
		tchar_t* s;
		int ExtsLen = 1024;
		tchar_t* Exts = (tchar_t*)malloc(ExtsLen*sizeof(tchar_t));
		if (!Exts)
			return;

		Exts[0]=0;
		NodeEnumClass(&List,FORMAT_CLASS);
		for (i=ARRAYBEGIN(List,int);i!=ARRAYEND(List,int);++i)
		{
			const tchar_t* s = LangStr(*i,NODE_EXTS);
			if (s[0])
			{
				if (Exts[0]) tcscat_s(Exts,ExtsLen,T(";"));
				tcscat_s(Exts,ExtsLen,s);
			}
		}
		ArrayClear(&List);

		n = 0;
		p->Player->Set(p->Player,PLAYER_LIST_COUNT,&n,sizeof(n));

		GetModuleFileName(GetModuleHandle(NULL),Base,MAXPATH);
		s = tcsrchr(Base,'\\');
		if (s) *s=0;
		s = tcsrchr(Base,'\\');
		if (s) *s=0;

		EnumDir(Base,Exts,p->Player);
		free(Exts);
	}
	else
	{
		while (IsSpace(*CmdLine))
			++CmdLine;

		if (*CmdLine == '"')
		{
			tchar_t* ch = tcschr(++CmdLine,'"');
			if (ch) *ch=0;
		}