void CClientDlg::OnBtnPlay() 
{
	if(mControll.IsConnected())
	{
		if(mState=STOP)
		{
			int index = mProgramListCtrl.GetNextItem(-1, LVNI_SELECTED);
			if (index >= 0)
			{
				CString pid = mProgramListCtrl.GetItemText(index, 3);
				mPlayingPID = atol(pid);
				CMediaInfo     media;
				POSITION pos = mPrgrmList.GetHeadPosition();
				while (pos)
				{
					media  = mPrgrmList.GetNext(pos);
					if (media.mProgramId == mPlayingPID)
					{
						mMediaType=media.mFileType;
						break;
					}
				}
				Deactivate();
				if(ConnectVideoSocket()&&ConnectAudioSocket())
				{
					SendMediaControlCommand(Cmd_RequestPlay);
					Activate();
				}
				else
				{
					MessageBox("fail to connect!");
				}
			}
		}
		else if(mState=PAUSE)
		{
			mMediaControl->Run();
			mState=PLAY;
			SendSimpleCommand(Cmd_RequestResume);
		}
	}
}
BOOL CClientDlg::SendMediaControlCommand(long inCommand)
{
	if(mControll.IsConnected())
	{
		char  buf[MAX_COMMAND_SIZE];
		long  len  = sizeof(Net_Command) + sizeof(Media_Control);
		long * pCmd = (long *) buf;
		*pCmd = inCommand;
		*pCmd = htonl(*pCmd);
		pCmd++;
		Media_Control * pData = (Media_Control *) pCmd;
		pData->program_id = mPlayingPID;
		pData->my_hton();
		return mControll.Send(buf, len);
	}
	return FALSE;
}

BOOL CClientDlg::ConnectVideoSocket()
{

	if(	(!mVideo.ConnectTo(mServerIP,SERVER_VIDEO_PORT)))
	{
		MessageBox("Fail to connect to video socket");
		return FALSE;
	}
	return TRUE;

}

BOOL CClientDlg::ConnectAudioSocket()
{

	if(	(!mAudio.ConnectTo(mServerIP,SERVER_AUDIO_PORT)))
	{
		MessageBox("Fail to connect to audio socket");
		return FALSE;
	}
	return TRUE;

}

BOOL CClientDlg::Activate()
{
	BOOL pass=CreateGraph();
	if(pass)
	{		
		pass=CreateFilters();
	}
	if(pass)
	{
		pass=AfterBuildGraph();
	}
	return pass;
}

BOOL CClientDlg::CreateGraph()
{
	if (!mGraph)
	{
		if (SUCCEEDED(CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
			IID_IGraphBuilder, (void **)&mGraph)))
		{
			mGraph->QueryInterface(IID_IMediaControl, (void **)&mMediaControl);
			return TRUE;
		}
		mGraph = NULL;
	}
	return FALSE;

}

BOOL CClientDlg::CreateFilters()
{
	HRESULT hr = NOERROR;
	BOOL  pass = FALSE;
	IBaseFilter * pFilter = NULL;
	mVideoReceiver = new CFilterNetReceiver(NULL, &hr);
	mVideoReceiver->QueryInterface(IID_IBaseFilter, (void**)&pFilter);
	if (SUCCEEDED(mGraph->AddFilter(pFilter, L"Video Receiver")))
	{
		mVideoReceiver->AddMsgReceiver(this);
		pass=TRUE;
	}

	if(pass)
	{
		pass=FALSE;
		if (SUCCEEDED(CoCreateInstance(CLSID_VideoRenderer, NULL, CLSCTX_INPROC_SERVER,
				IID_IBaseFilter, (void **)&mVideoRenderer)))
		{
			if (SUCCEEDED(mGraph->AddFilter(mVideoRenderer,L"VideoRenderer")))
				pass=TRUE;
		}
	}

	if(pass)
	{
        pass=FALSE;
		mAudioReceiver = new CFilterNetReceiver(NULL, &hr);
		mAudioReceiver->QueryInterface(IID_IBaseFilter, (void**)&pFilter);
		if (SUCCEEDED(mGraph->AddFilter(pFilter, L"Audio Receiver")))
		{
			mAudioReceiver->AddMsgReceiver(this);
			pass=TRUE;
		}
	}
	if(mPlayingPID==FT_REAL)
	{
		if(pass)
		{
			pass=FALSE;
			if (SUCCEEDED(CoCreateInstance(CLSID_MYREALAUDIODECOM, NULL, CLSCTX_INPROC_SERVER,
					IID_IBaseFilter, (void **)&mAudioDecom)))
			{
				if (SUCCEEDED(mGraph->AddFilter(mAudioDecom,L"AudioDecom")))
					pass=TRUE;
			}
		}
	}
	if(pass)
	{
		pass=FALSE;
		if (SUCCEEDED(CoCreateInstance(CLSID_DSoundRender, NULL, CLSCTX_INPROC_SERVER,
				IID_IBaseFilter, (void **)&mAudioRenderer)))
		{
			if (SUCCEEDED(mGraph->AddFilter(mAudioRenderer,L"AudioRenderer")))
				pass=TRUE;
		}
	}
	return pass;

}

BOOL CClientDlg::AfterBuildGraph()
{
	IMediaFilter *pMediaFilter = 0;
	mGraph->QueryInterface(IID_IMediaFilter, (void**)&pMediaFilter);
    pMediaFilter->SetSyncSource(NULL);
	pMediaFilter->Release();

	SOCKET videosocket=mVideo.GetSocket();
	if(videosocket!=INVALID_SOCKET)
	{
		mVideoReceiver->SetStreamSocket(videosocket);
		mVideoReceiver->StartReceiving();
	}else
	{
		MessageBox("video socket fail");
	}	

	SOCKET audiosocket=mAudio.GetSocket();
	if(audiosocket!=INVALID_SOCKET)
	{
		mAudioReceiver->SetStreamSocket(audiosocket);
		mAudioReceiver->StartReceiving();
	}
	else
	{
		MessageBox("audio socket fail");
	}	
	return TRUE;

}

BOOL CClientDlg::CompleteVideoReceivingGraph()
{
	BOOL   pass = FALSE;
	IPin * pOut = NULL;
	IPin * pIn  = NULL;

	pOut = mVideoReceiver->GetPin(0);
    pIn=UFilterUtils::GetPin(mVideoRenderer,TRUE,"Input");
    if (SUCCEEDED(mGraph->Connect(pOut,pIn)))
	{
		pass=TRUE;
	}
	SetDisplayWindow(mVideoWnd.m_hWnd);

	mVideoIsOK=TRUE;
	if(mVideoIsOK&&mAudioIsOK)
	{
		mMediaControl->Run();
	    mState=PLAY;
	}
	return TRUE;
}

BOOL CClientDlg::CompleteAudioReceivingGraph()
{
	BOOL   pass = FALSE;
	IPin * pOut = NULL;
	IPin * pIn  = NULL;

	pOut = mAudioReceiver->GetPin(0);
	pIn=UFilterUtils::GetPin(mAudioRenderer,TRUE,"Audio");
	if (SUCCEEDED(mGraph->Connect(pOut,pIn)))
	{
		pass=TRUE;
	}

	mAudioIsOK=TRUE;
	if(mVideoIsOK&&mAudioIsOK)
	{
		mMediaControl->Run();
	    mState=PLAY;
	}
	return TRUE;
}

BOOL CClientDlg::SetDisplayWindow(HWND inWindow)
{

	HRESULT hr = NOERROR;
	IVideoWindow  *		mVideoWindow;
	hr = mGraph->QueryInterface(IID_IVideoWindow, (void **)&mVideoWindow);
	if (mVideoWindow)
	{
		mVideoWindow->put_Visible(OAFALSE);
		mVideoWindow->put_Owner((OAHWND)inWindow);

		RECT windowRect;
		::GetClientRect(inWindow, &windowRect);
		mVideoWindow->put_Left(0);
		mVideoWindow->put_Top(0);
		mVideoWindow->put_Width(windowRect.right - windowRect.left);
		mVideoWindow->put_Height(windowRect.bottom - windowRect.top);
		mVideoWindow->put_WindowStyle(WS_CHILD|WS_CLIPCHILDREN|WS_CLIPSIBLINGS);

		mVideoWindow->put_MessageDrain((OAHWND) inWindow);
		if (inWindow != NULL)
		{
			mVideoWindow->put_Visible(OATRUE);
		}
		else
		{
			mVideoWindow->put_Visible(OAFALSE);
		}
		mVideoWindow->Release();
		return TRUE;
	}
	mVideoWindow->Release();
	return FALSE;
}

void CClientDlg::Deactivate()
{

	if (mGraph && mMediaControl)
	{		
		mMediaControl->Stop();	
	}

	mSliderTimer.SetPos(0);
	SAFE_RELEASE(mVideoRenderer);
	SAFE_RELEASE(mAudioRenderer);
	SAFE_RELEASE(mVideoReceiver);
	SAFE_RELEASE(mAudioReceiver);
	SAFE_RELEASE(mVideoDecom);
	SAFE_RELEASE(mAudioDecom);

	SAFE_RELEASE(mGraph);
	SAFE_RELEASE(mMediaControl);
	mState=STOP;

}

void CClientDlg::OnDestroy() 
{
	SendSimpleCommand(Cmd_RequestTCPDisconnect);
	mControll.Detach();
	CDialog::OnDestroy();
	
	Deactivate();	
}

void CClientDlg::OnBtnStop() 
{
	Deactivate();
	SendSimpleCommand(Cmd_RequestStop);
}

void CClientDlg::OnBtndisconnect() 
{
	SendSimpleCommand(Cmd_RequestTCPDisconnect);
	mControll.Detach();
	mBtnDisconnect.EnableWindow(FALSE);
	mBtnConnect.EnableWindow(TRUE);
	
}

void CClientDlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{
	SendProgress(mSliderTimer.GetPos());	
	CDialog::OnHScroll(nSBCode, nPos, pScrollBar);
}

void CClientDlg::SendProgress(int pos)
{
	if(mControll.IsConnected())
	{
		char  buf[MAX_COMMAND_SIZE];
		long  len  = sizeof(Net_Command) + sizeof(Media_Progress);
		long * pCmd = (long *) buf;
		*pCmd = Cmd_SetProgress;
		*pCmd = htonl(*pCmd);
		pCmd++;
		Media_Progress * pData = (Media_Progress *) pCmd;
		pData->program_Progress = pos;
		pData->my_hton();
		mControll.Send(buf, len);
	}
}