多媒体编程

开发平台：

Visual C++

MainFrm.cpp：源码内容

/*
* http://www.gabest.org
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
// MainFrm.cpp : implementation of the CMainFrame class
//
#include "stdafx.h"
#include "mplayerc.h"
#include "MainFrm.h"
#include <math.h>
#include <afxpriv.h>
#include <atlconv.h>
#include <atlrx.h>
#include <atlsync.h>
#include "OpenDlg.h"
#include "SaveDlg.h"
#include "GoToDlg.h"
#include "PnSPresetsDlg.h"
#include "MediaTypesDlg.h"
#include "SaveTextFileDialog.h"
#include "FavoriteAddDlg.h"
#include "FavoriteOrganizeDlg.h"
#include "ShaderEditorDlg.h"
#include "ConvertDlg.h"
#include <mtype.h>
#include <Mpconfig.h>
#include <ks.h>
#include <ksmedia.h>
#include <dvdevcod.h>
#include <dsound.h>
#include <initguid.h>
#include <uuids.h>
#include "......includemoreuuids.h"
#include "......includeOggOggDS.h"
#include <Qnetwork.h>
#include <qedit.h>
#include "....DSUtilDSUtil.h"
#include "GraphBuilder.h"
#include "textpassthrufilter.h"
#include "....filtersfilters.h"
#include "DX7AllocatorPresenter.h"
#include "DX9AllocatorPresenter.h"
#include "......includematroskamatroska.h"
#define DEFCLIENTW 292
#define DEFCLIENTH 200
static UINT s_uTaskbarRestart = RegisterWindowMessage(TEXT("TaskbarCreated"));
static UINT WM_NOTIFYICON = RegisterWindowMessage(TEXT("MYWM_NOTIFYICON"));
#include "....filterstransformvsfilterIDirectVobSub.h"
class CSubClock : public CUnknown, public ISubClock
{
STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv)
{
return
QI(ISubClock)
CUnknown::NonDelegatingQueryInterface(riid, ppv);
}
REFERENCE_TIME m_rt;
public:
CSubClock() : CUnknown(NAME("CSubClock"), NULL) {m_rt = 0;}
DECLARE_IUNKNOWN;
// ISubClock
STDMETHODIMP SetTime(REFERENCE_TIME rt) {m_rt = rt; return S_OK;}
STDMETHODIMP_(REFERENCE_TIME) GetTime() {return(m_rt);}
};
//
#define SaveMediaState
OAFilterState __fs = GetMediaState();
REFERENCE_TIME __rt = 0;
if(m_iMediaLoadState == MLS_LOADED) __rt = GetPos();
if(__fs != State_Stopped)
SendMessage(WM_COMMAND, ID_PLAY_STOP);
#define RestoreMediaState
if(m_iMediaLoadState == MLS_LOADED)
{
SeekTo(__rt);
if(__fs == State_Stopped)
SendMessage(WM_COMMAND, ID_PLAY_STOP);
else if(__fs == State_Paused)
SendMessage(WM_COMMAND, ID_PLAY_PAUSE);
else if(__fs == State_Running)
SendMessage(WM_COMMAND, ID_PLAY_PLAY);
}
/*
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
*/
/////////////////////////////////////////////////////////////////////////////
// CMainFrame
IMPLEMENT_DYNAMIC(CMainFrame, CFrameWnd)
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
ON_WM_CREATE()
ON_WM_DESTROY()
ON_WM_CLOSE()
ON_REGISTERED_MESSAGE(s_uTaskbarRestart, OnTaskBarRestart)
ON_REGISTERED_MESSAGE(WM_NOTIFYICON, OnNotifyIcon)
ON_WM_SETFOCUS()
ON_WM_GETMINMAXINFO()
ON_WM_MOVE()
ON_WM_SIZE()
ON_MESSAGE_VOID(WM_DISPLAYCHANGE, OnDisplayChange)
ON_WM_SYSCOMMAND()
ON_WM_ACTIVATEAPP()
ON_MESSAGE(WM_APPCOMMAND, OnAppCommand)
ON_WM_TIMER()
ON_MESSAGE(WM_GRAPHNOTIFY, OnGraphNotify)
ON_MESSAGE(WM_REARRANGERENDERLESS, OnRepaintRenderLess)
ON_MESSAGE(WM_RESUMEFROMSTATE, OnResumeFromState)
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONUP()
ON_WM_LBUTTONDBLCLK()
ON_WM_MBUTTONDOWN()
ON_WM_MBUTTONUP()
ON_WM_MBUTTONDBLCLK()
ON_WM_RBUTTONDOWN()
ON_WM_RBUTTONUP()
ON_WM_RBUTTONDBLCLK()
ON_MESSAGE(WM_XBUTTONDOWN, OnXButtonDown)
ON_MESSAGE(WM_XBUTTONUP, OnXButtonUp)
ON_MESSAGE(WM_XBUTTONDBLCLK, OnXButtonDblClk)
ON_WM_MOUSEWHEEL()
ON_WM_MOUSEMOVE()
// ON_WM_NCHITTEST()
ON_WM_HSCROLL()
ON_WM_INITMENU()
ON_WM_INITMENUPOPUP()
ON_COMMAND(ID_MENU_PLAYER_SHORT, OnMenuPlayerShort)
ON_COMMAND(ID_MENU_PLAYER_LONG, OnMenuPlayerLong)
ON_COMMAND(ID_MENU_FILTERS, OnMenuFilters)
ON_UPDATE_COMMAND_UI(ID_PLAYERSTATUS, OnUpdatePlayerStatus)
ON_COMMAND(ID_FILE_POST_OPENMEDIA, OnFilePostOpenmedia)
ON_UPDATE_COMMAND_UI(ID_FILE_POST_OPENMEDIA, OnUpdateFilePostOpenmedia)
ON_COMMAND(ID_FILE_POST_CLOSEMEDIA, OnFilePostClosemedia)
ON_UPDATE_COMMAND_UI(ID_FILE_POST_CLOSEMEDIA, OnUpdateFilePostClosemedia)
ON_COMMAND(ID_BOSS, OnBossKey)
ON_COMMAND_RANGE(ID_STREAM_AUDIO_NEXT, ID_STREAM_AUDIO_PREV, OnStreamAudio)
ON_COMMAND_RANGE(ID_STREAM_SUB_NEXT, ID_STREAM_SUB_PREV, OnStreamSub)
ON_COMMAND(ID_STREAM_SUB_ONOFF, OnStreamSubOnOff)
ON_COMMAND_RANGE(ID_OGM_AUDIO_NEXT, ID_OGM_AUDIO_PREV, OnOgmAudio)
ON_COMMAND_RANGE(ID_OGM_SUB_NEXT, ID_OGM_SUB_PREV, OnOgmSub)
ON_COMMAND_RANGE(ID_DVD_ANGLE_NEXT, ID_DVD_ANGLE_PREV, OnDvdAngle)
ON_COMMAND_RANGE(ID_DVD_AUDIO_NEXT, ID_DVD_AUDIO_PREV, OnDvdAudio)
ON_COMMAND_RANGE(ID_DVD_SUB_NEXT, ID_DVD_SUB_PREV, OnDvdSub)
ON_COMMAND(ID_DVD_SUB_ONOFF, OnDvdSubOnOff)
ON_COMMAND(ID_FILE_OPENMEDIA, OnFileOpenmedia)
ON_UPDATE_COMMAND_UI(ID_FILE_OPENMEDIA, OnUpdateFileOpen)
ON_WM_COPYDATA()
ON_COMMAND(ID_FILE_OPENDVD, OnFileOpendvd)
ON_UPDATE_COMMAND_UI(ID_FILE_OPENDVD, OnUpdateFileOpen)
ON_COMMAND(ID_FILE_OPENDEVICE, OnFileOpendevice)
ON_UPDATE_COMMAND_UI(ID_FILE_OPENDEVICE, OnUpdateFileOpen)
ON_COMMAND_RANGE(ID_FILE_OPEN_CD_START, ID_FILE_OPEN_CD_END, OnFileOpenCD)
ON_UPDATE_COMMAND_UI_RANGE(ID_FILE_OPEN_CD_START, ID_FILE_OPEN_CD_END, OnUpdateFileOpen)
ON_WM_DROPFILES()
ON_COMMAND(ID_FILE_SAVEAS, OnFileSaveas)
ON_UPDATE_COMMAND_UI(ID_FILE_SAVEAS, OnUpdateFileSaveas)
ON_COMMAND(ID_FILE_SAVE_IMAGE, OnFileSaveImage)
ON_COMMAND(ID_FILE_SAVE_IMAGE_AUTO, OnFileSaveImageAuto)
ON_UPDATE_COMMAND_UI(ID_FILE_SAVE_IMAGE, OnUpdateFileSaveImage)
ON_UPDATE_COMMAND_UI(ID_FILE_SAVE_IMAGE_AUTO, OnUpdateFileSaveImage)
ON_COMMAND(ID_FILE_CONVERT, OnFileConvert)
ON_UPDATE_COMMAND_UI(ID_FILE_CONVERT, OnUpdateFileConvert)
ON_COMMAND(ID_FILE_LOADSUBTITLE, OnFileLoadsubtitles)
ON_UPDATE_COMMAND_UI(ID_FILE_LOADSUBTITLE, OnUpdateFileLoadsubtitles)
ON_COMMAND(ID_FILE_SAVESUBTITLES, OnFileSavesubtitles)
ON_UPDATE_COMMAND_UI(ID_FILE_SAVESUBTITLES, OnUpdateFileSavesubtitles)
ON_COMMAND(ID_SUBTITLEDATABASE_SEARCH, OnSubtitledatabaseSearch)
ON_UPDATE_COMMAND_UI(ID_SUBTITLEDATABASE_SEARCH, OnUpdateSubtitledatabaseSearch)
ON_COMMAND(ID_SUBTITLEDATABASE_UPLOAD, OnSubtitledatabaseUpload)
ON_UPDATE_COMMAND_UI(ID_SUBTITLEDATABASE_UPLOAD, OnUpdateSubtitledatabaseUpload)
ON_COMMAND(ID_SUBTITLEDATABASE_DOWNLOAD, OnSubtitledatabaseDownload)
ON_UPDATE_COMMAND_UI(ID_SUBTITLEDATABASE_DOWNLOAD, OnUpdateSubtitledatabaseDownload)
ON_COMMAND(ID_FILE_PROPERTIES, OnFileProperties)
ON_UPDATE_COMMAND_UI(ID_FILE_PROPERTIES, OnUpdateFileProperties)
ON_COMMAND(ID_FILE_CLOSEPLAYLIST, OnFileClosePlaylist)
ON_COMMAND(ID_FILE_CLOSEMEDIA, OnFileCloseMedia)
ON_UPDATE_COMMAND_UI(ID_FILE_CLOSEMEDIA, OnUpdateFileClose)
ON_COMMAND(ID_VIEW_CAPTIONMENU, OnViewCaptionmenu)
ON_UPDATE_COMMAND_UI(ID_VIEW_CAPTIONMENU, OnUpdateViewCaptionmenu)
ON_COMMAND_RANGE(ID_VIEW_SEEKER, ID_VIEW_STATUS, OnViewControlBar)
ON_UPDATE_COMMAND_UI_RANGE(ID_VIEW_SEEKER, ID_VIEW_STATUS, OnUpdateViewControlBar)
ON_COMMAND(ID_VIEW_SUBRESYNC, OnViewSubresync)
ON_UPDATE_COMMAND_UI(ID_VIEW_SUBRESYNC, OnUpdateViewSubresync)
ON_COMMAND(ID_VIEW_PLAYLIST, OnViewPlaylist)
ON_UPDATE_COMMAND_UI(ID_VIEW_PLAYLIST, OnUpdateViewPlaylist)
ON_COMMAND(ID_VIEW_CAPTURE, OnViewCapture)
ON_UPDATE_COMMAND_UI(ID_VIEW_CAPTURE, OnUpdateViewCapture)
ON_COMMAND(ID_VIEW_PRESETS_MINIMAL, OnViewMinimal)
ON_UPDATE_COMMAND_UI(ID_VIEW_PRESETS_MINIMAL, OnUpdateViewMinimal)
ON_COMMAND(ID_VIEW_PRESETS_COMPACT, OnViewCompact)
ON_UPDATE_COMMAND_UI(ID_VIEW_PRESETS_COMPACT, OnUpdateViewCompact)
ON_COMMAND(ID_VIEW_PRESETS_NORMAL, OnViewNormal)
ON_UPDATE_COMMAND_UI(ID_VIEW_PRESETS_NORMAL, OnUpdateViewNormal)
ON_COMMAND(ID_VIEW_FULLSCREEN, OnViewFullscreen)
ON_COMMAND(ID_VIEW_FULLSCREEN_SECONDARY, OnViewFullscreenSecondary)
ON_UPDATE_COMMAND_UI(ID_VIEW_FULLSCREEN, OnUpdateViewFullscreen)
ON_COMMAND_RANGE(ID_VIEW_ZOOM_50, ID_VIEW_ZOOM_200, OnViewZoom)
ON_UPDATE_COMMAND_UI_RANGE(ID_VIEW_ZOOM_50, ID_VIEW_ZOOM_200, OnUpdateViewZoom)
ON_COMMAND_RANGE(ID_VIEW_VF_HALF, ID_VIEW_VF_FROMOUTSIDE, OnViewDefaultVideoFrame)
ON_UPDATE_COMMAND_UI_RANGE(ID_VIEW_VF_HALF, ID_VIEW_VF_FROMOUTSIDE, OnUpdateViewDefaultVideoFrame)
ON_COMMAND(ID_VIEW_VF_KEEPASPECTRATIO, OnViewKeepaspectratio)
ON_UPDATE_COMMAND_UI(ID_VIEW_VF_KEEPASPECTRATIO, OnUpdateViewKeepaspectratio)
ON_COMMAND(ID_VIEW_VF_COMPMONDESKARDIFF, OnViewCompMonDeskARDiff)
ON_UPDATE_COMMAND_UI(ID_VIEW_VF_COMPMONDESKARDIFF, OnUpdateViewCompMonDeskARDiff)
ON_COMMAND_RANGE(ID_VIEW_INCSIZE, ID_VIEW_RESET, OnViewPanNScan)
ON_UPDATE_COMMAND_UI_RANGE(ID_VIEW_INCSIZE, ID_VIEW_RESET, OnUpdateViewPanNScan)
ON_COMMAND_RANGE(ID_PANSCAN_MOVELEFT, ID_PANSCAN_CENTER, OnViewPanNScan)
ON_UPDATE_COMMAND_UI_RANGE(ID_PANSCAN_MOVELEFT, ID_PANSCAN_CENTER, OnUpdateViewPanNScan)
ON_COMMAND_RANGE(ID_PANNSCAN_PRESETS_START, ID_PANNSCAN_PRESETS_END, OnViewPanNScanPresets)
ON_UPDATE_COMMAND_UI_RANGE(ID_PANNSCAN_PRESETS_START, ID_PANNSCAN_PRESETS_END, OnUpdateViewPanNScanPresets)
ON_COMMAND_RANGE(ID_PANSCAN_ROTATEXP, ID_PANSCAN_ROTATEZM, OnViewRotate)
ON_UPDATE_COMMAND_UI_RANGE(ID_PANSCAN_ROTATEXP, ID_PANSCAN_ROTATEZM, OnUpdateViewRotate)
ON_COMMAND_RANGE(ID_ASPECTRATIO_START, ID_ASPECTRATIO_END, OnViewAspectRatio)
ON_UPDATE_COMMAND_UI_RANGE(ID_ASPECTRATIO_START, ID_ASPECTRATIO_END, OnUpdateViewAspectRatio)
ON_COMMAND_RANGE(ID_ONTOP_NEVER, ID_ONTOP_WHILEPLAYING, OnViewOntop)
ON_UPDATE_COMMAND_UI_RANGE(ID_ONTOP_NEVER, ID_ONTOP_WHILEPLAYING, OnUpdateViewOntop)
ON_COMMAND(ID_VIEW_OPTIONS, OnViewOptions)
ON_COMMAND(ID_PLAY_PLAY, OnPlayPlay)
ON_COMMAND(ID_PLAY_PAUSE, OnPlayPause)
ON_COMMAND(ID_PLAY_PLAYPAUSE, OnPlayPlaypause)
ON_COMMAND(ID_PLAY_STOP, OnPlayStop)
ON_UPDATE_COMMAND_UI(ID_PLAY_PLAY, OnUpdatePlayPauseStop)
ON_UPDATE_COMMAND_UI(ID_PLAY_PAUSE, OnUpdatePlayPauseStop)
ON_UPDATE_COMMAND_UI(ID_PLAY_PLAYPAUSE, OnUpdatePlayPauseStop)
ON_UPDATE_COMMAND_UI(ID_PLAY_STOP, OnUpdatePlayPauseStop)
ON_COMMAND_RANGE(ID_PLAY_FRAMESTEP, ID_PLAY_FRAMESTEPCANCEL, OnPlayFramestep)
ON_UPDATE_COMMAND_UI_RANGE(ID_PLAY_FRAMESTEP, ID_PLAY_FRAMESTEPCANCEL, OnUpdatePlayFramestep)
ON_COMMAND_RANGE(ID_PLAY_SEEKBACKWARDSMALL, ID_PLAY_SEEKFORWARDLARGE, OnPlaySeek)
ON_COMMAND_RANGE(ID_PLAY_SEEKKEYBACKWARD, ID_PLAY_SEEKKEYFORWARD, OnPlaySeekKey)
ON_UPDATE_COMMAND_UI_RANGE(ID_PLAY_SEEKBACKWARDSMALL, ID_PLAY_SEEKFORWARDLARGE, OnUpdatePlaySeek)
ON_UPDATE_COMMAND_UI_RANGE(ID_PLAY_SEEKKEYBACKWARD, ID_PLAY_SEEKKEYFORWARD, OnUpdatePlaySeek)
ON_COMMAND(ID_PLAY_GOTO, OnPlayGoto)
ON_UPDATE_COMMAND_UI(ID_PLAY_GOTO, OnUpdateGoto)
ON_COMMAND_RANGE(ID_PLAY_DECRATE, ID_PLAY_INCRATE, OnPlayChangeRate)
ON_UPDATE_COMMAND_UI_RANGE(ID_PLAY_DECRATE, ID_PLAY_INCRATE, OnUpdatePlayChangeRate)
ON_COMMAND(ID_PLAY_RESETRATE, OnPlayResetRate)
ON_UPDATE_COMMAND_UI(ID_PLAY_RESETRATE, OnUpdatePlayResetRate)
ON_COMMAND_RANGE(ID_PLAY_INCAUDDELAY, ID_PLAY_DECAUDDELAY, OnPlayChangeAudDelay)
ON_UPDATE_COMMAND_UI_RANGE(ID_PLAY_INCAUDDELAY, ID_PLAY_DECAUDDELAY, OnUpdatePlayChangeAudDelay)
ON_COMMAND_RANGE(ID_FILTERS_SUBITEM_START, ID_FILTERS_SUBITEM_END, OnPlayFilters)
ON_UPDATE_COMMAND_UI_RANGE(ID_FILTERS_SUBITEM_START, ID_FILTERS_SUBITEM_END, OnUpdatePlayFilters)
ON_COMMAND_RANGE(ID_SHADERS_START, ID_SHADERS_END, OnPlayShaders)
ON_UPDATE_COMMAND_UI_RANGE(ID_SHADERS_START, ID_SHADERS_END, OnUpdatePlayShaders)
ON_COMMAND_RANGE(ID_AUDIO_SUBITEM_START, ID_AUDIO_SUBITEM_END, OnPlayAudio)
ON_UPDATE_COMMAND_UI_RANGE(ID_AUDIO_SUBITEM_START, ID_AUDIO_SUBITEM_END, OnUpdatePlayAudio)
ON_COMMAND_RANGE(ID_SUBTITLES_SUBITEM_START, ID_SUBTITLES_SUBITEM_END, OnPlaySubtitles)
ON_UPDATE_COMMAND_UI_RANGE(ID_SUBTITLES_SUBITEM_START, ID_SUBTITLES_SUBITEM_END, OnUpdatePlaySubtitles)
ON_COMMAND_RANGE(ID_FILTERSTREAMS_SUBITEM_START, ID_FILTERSTREAMS_SUBITEM_END, OnPlayLanguage)
ON_UPDATE_COMMAND_UI_RANGE(ID_FILTERSTREAMS_SUBITEM_START, ID_FILTERSTREAMS_SUBITEM_END, OnUpdatePlayLanguage)
ON_COMMAND_RANGE(ID_VOLUME_UP, ID_VOLUME_MUTE, OnPlayVolume)
ON_COMMAND_RANGE(ID_AFTERPLAYBACK_CLOSE, ID_AFTERPLAYBACK_DONOTHING, OnAfterplayback)
ON_UPDATE_COMMAND_UI_RANGE(ID_AFTERPLAYBACK_CLOSE, ID_AFTERPLAYBACK_DONOTHING, OnUpdateAfterplayback)
ON_COMMAND_RANGE(ID_NAVIGATE_SKIPBACK, ID_NAVIGATE_SKIPFORWARD, OnNavigateSkip)
ON_UPDATE_COMMAND_UI_RANGE(ID_NAVIGATE_SKIPBACK, ID_NAVIGATE_SKIPFORWARD, OnUpdateNavigateSkip)
ON_COMMAND_RANGE(ID_NAVIGATE_SKIPBACKPLITEM, ID_NAVIGATE_SKIPFORWARDPLITEM, OnNavigateSkipPlaylistItem)
ON_UPDATE_COMMAND_UI_RANGE(ID_NAVIGATE_SKIPBACKPLITEM, ID_NAVIGATE_SKIPFORWARDPLITEM, OnUpdateNavigateSkipPlaylistItem)
ON_COMMAND_RANGE(ID_NAVIGATE_TITLEMENU, ID_NAVIGATE_CHAPTERMENU, OnNavigateMenu)
ON_UPDATE_COMMAND_UI_RANGE(ID_NAVIGATE_TITLEMENU, ID_NAVIGATE_CHAPTERMENU, OnUpdateNavigateMenu)
ON_COMMAND_RANGE(ID_NAVIGATE_AUDIO_SUBITEM_START, ID_NAVIGATE_AUDIO_SUBITEM_END, OnNavigateAudio)
ON_COMMAND_RANGE(ID_NAVIGATE_SUBP_SUBITEM_START, ID_NAVIGATE_SUBP_SUBITEM_END, OnNavigateSubpic)
ON_COMMAND_RANGE(ID_NAVIGATE_ANGLE_SUBITEM_START, ID_NAVIGATE_ANGLE_SUBITEM_END, OnNavigateAngle)
ON_COMMAND_RANGE(ID_NAVIGATE_CHAP_SUBITEM_START, ID_NAVIGATE_CHAP_SUBITEM_END, OnNavigateChapters)
ON_COMMAND_RANGE(ID_NAVIGATE_MENU_LEFT, ID_NAVIGATE_MENU_LEAVE, OnNavigateMenuItem)
ON_UPDATE_COMMAND_UI_RANGE(ID_NAVIGATE_MENU_LEFT, ID_NAVIGATE_MENU_LEAVE, OnUpdateNavigateMenuItem)
ON_COMMAND(ID_FAVORITES_ADD, OnFavoritesAdd)
ON_UPDATE_COMMAND_UI(ID_FAVORITES_ADD, OnUpdateFavoritesAdd)
ON_COMMAND(ID_FAVORITES_ORGANIZE, OnFavoritesOrganize)
ON_UPDATE_COMMAND_UI(ID_FAVORITES_ORGANIZE, OnUpdateFavoritesOrganize)
ON_COMMAND_RANGE(ID_FAVORITES_FILE_START, ID_FAVORITES_FILE_END, OnFavoritesFile)
ON_UPDATE_COMMAND_UI_RANGE(ID_FAVORITES_FILE_START, ID_FAVORITES_FILE_END, OnUpdateFavoritesFile)
ON_COMMAND_RANGE(ID_FAVORITES_DVD_START, ID_FAVORITES_DVD_END, OnFavoritesDVD)
ON_UPDATE_COMMAND_UI_RANGE(ID_FAVORITES_DVD_START, ID_FAVORITES_DVD_END, OnUpdateFavoritesDVD)
ON_COMMAND_RANGE(ID_FAVORITES_DEVICE_START, ID_FAVORITES_DEVICE_END, OnFavoritesDevice)
ON_UPDATE_COMMAND_UI_RANGE(ID_FAVORITES_DEVICE_START, ID_FAVORITES_DEVICE_END, OnUpdateFavoritesDevice)
ON_COMMAND(ID_HELP_HOMEPAGE, OnHelpHomepage)
ON_COMMAND(ID_HELP_DOCUMENTATION, OnHelpDocumentation)
ON_COMMAND(ID_HELP_DONATE, OnHelpDonate)
ON_WM_SIZING()
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CMainFrame construction/destruction
#pragma warning(disable : 4355)
CMainFrame::CMainFrame() :
m_dwRegister(0),
m_iMediaLoadState(MLS_CLOSED),
m_iPlaybackMode(PM_NONE),
m_iSpeedLevel(0),
m_rtDurationOverride(-1),
m_fFullScreen(false),
m_fHideCursor(false),
m_lastMouseMove(-1, -1),
m_pLastBar(NULL),
m_nLoops(0),
m_iSubtitleSel(-1),
m_ZoomX(1), m_ZoomY(1), m_PosX(0.5), m_PosY(0.5),
m_AngleX(0), m_AngleY(0), m_AngleZ(0),
m_fCustomGraph(false),
m_fRealMediaGraph(false), m_fShockwaveGraph(false), m_fQuicktimeGraph(false),
m_fFrameSteppingActive(false),
m_fEndOfStream(false),
m_fCapturing(false),
m_fLiveWM(false),
m_fOpeningAborted(false),
m_fBuffering(false),
m_fileDropTarget(this),
m_fTrayIcon(false)
{
}
CMainFrame::~CMainFrame()
{
// m_owner.DestroyWindow();
}
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if(__super::OnCreate(lpCreateStruct) == -1)
return -1;
m_popup.LoadMenu(IDR_POPUP);
m_popupmain.LoadMenu(IDR_POPUPMAIN);
GetMenu()->ModifyMenu(ID_FAVORITES, MF_BYCOMMAND|MF_STRING, IDR_MAINFRAME, ResStr(IDS_FAVORITES_POPUP));
// create a view to occupy the client area of the frame
if(!m_wndView.Create(NULL, NULL, AFX_WS_DEFAULT_VIEW,
CRect(0, 0, 0, 0), this, AFX_IDW_PANE_FIRST, NULL))
{
TRACE0("Failed to create view windown");
return -1;
}
// static bars
if(!m_wndStatusBar.Create(this)
|| !m_wndStatsBar.Create(this)
|| !m_wndInfoBar.Create(this)
|| !m_wndToolBar.Create(this)
|| !m_wndSeekBar.Create(this))
{
TRACE0("Failed to create all control barsn");
return -1; // fail to create
}
m_bars.AddTail(&m_wndSeekBar);
m_bars.AddTail(&m_wndToolBar);
m_bars.AddTail(&m_wndInfoBar);
m_bars.AddTail(&m_wndStatsBar);
m_bars.AddTail(&m_wndStatusBar);
m_wndSeekBar.Enable(false);
// dockable bars
EnableDocking(CBRS_ALIGN_ANY);
m_wndSubresyncBar.Create(this, &m_csSubLock);
m_wndSubresyncBar.SetBarStyle(m_wndSubresyncBar.GetBarStyle() | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_wndSubresyncBar.EnableDocking(CBRS_ALIGN_ANY);
m_wndSubresyncBar.SetHeight(200);
LoadControlBar(&m_wndSubresyncBar, _T("ToolBars\Subresync"), AFX_IDW_DOCKBAR_TOP);
m_wndPlaylistBar.Create(this);
m_wndPlaylistBar.SetBarStyle(m_wndPlaylistBar.GetBarStyle() | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_wndPlaylistBar.EnableDocking(CBRS_ALIGN_ANY);
m_wndPlaylistBar.SetHeight(100);
LoadControlBar(&m_wndPlaylistBar, _T("ToolBars\Playlist"), AFX_IDW_DOCKBAR_BOTTOM);
m_wndPlaylistBar.LoadPlaylist();
m_wndCaptureBar.Create(this);
m_wndCaptureBar.SetBarStyle(m_wndCaptureBar.GetBarStyle() | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_wndCaptureBar.EnableDocking(CBRS_ALIGN_LEFT|CBRS_ALIGN_RIGHT);
LoadControlBar(&m_wndCaptureBar, _T("ToolBars\Capture"), AFX_IDW_DOCKBAR_LEFT);
m_dockingbars.AddTail(&m_wndSubresyncBar);
m_dockingbars.AddTail(&m_wndPlaylistBar);
m_dockingbars.AddTail(&m_wndCaptureBar);
m_fileDropTarget.Register(this);
AppSettings& s = AfxGetAppSettings();
ShowControls(s.nCS);
SetAlwaysOnTop(s.iOnTop);
ShowTrayIcon(s.fTrayIcon);
SetFocus();
m_pGraphThread = (CGraphThread*)AfxBeginThread(RUNTIME_CLASS(CGraphThread));
if(m_pGraphThread)
m_pGraphThread->SetMainFrame(this);
if(s.fEnableWebServer)
StartWebServer(s.nWebServerPort);
return 0;
}
void CMainFrame::OnDestroy()
{
ShowTrayIcon(false);
m_fileDropTarget.Revoke();
if(m_pGraphThread)
{
CAMEvent e;
m_pGraphThread->PostThreadMessage(CGraphThread::TM_EXIT, 0, (LPARAM)&e);
if(!e.Wait(5000))
{
TRACE(_T("ERROR: Must call TerminateThread() on CMainFrame::m_pGraphThread->m_hThreadn"));
TerminateThread(m_pGraphThread->m_hThread, -1);
}
}
__super::OnDestroy();
}
void CMainFrame::OnClose()
{
m_wndPlaylistBar.SavePlaylist();
SaveControlBar(&m_wndSubresyncBar, _T("ToolBars\Subresync"));
SaveControlBar(&m_wndPlaylistBar, _T("ToolBars\Playlist"));
SaveControlBar(&m_wndCaptureBar, _T("ToolBars\Capture"));
ShowWindow(SW_HIDE);
CloseMedia();
__super::OnClose();
}
DROPEFFECT CMainFrame::OnDragEnter(COleDataObject* pDataObject, DWORD dwKeyState, CPoint point)
{
return DROPEFFECT_NONE;
}
DROPEFFECT CMainFrame::OnDragOver(COleDataObject* pDataObject, DWORD dwKeyState, CPoint point)
{
UINT CF_URL = RegisterClipboardFormat(_T("UniformResourceLocator"));
return pDataObject->IsDataAvailable(CF_URL) ? DROPEFFECT_COPY : DROPEFFECT_NONE;
}
BOOL CMainFrame::OnDrop(COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point)
{
UINT CF_URL = RegisterClipboardFormat(_T("UniformResourceLocator"));
BOOL bResult = FALSE;
if(pDataObject->IsDataAvailable(CF_URL))
{
FORMATETC fmt = {CF_URL, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
if(HGLOBAL hGlobal = pDataObject->GetGlobalData(CF_URL, &fmt))
{
LPCSTR pText = (LPCSTR)GlobalLock(hGlobal);
if(AfxIsValidString(pText))
{
CStringA url(pText);
SetForegroundWindow();
CList<CString> sl;
sl.AddTail(CString(url));
if(m_wndPlaylistBar.IsWindowVisible())
{
m_wndPlaylistBar.Append(sl, true);
}
else
{
m_wndPlaylistBar.Open(sl, true);
OpenCurPlaylistItem();
}
GlobalUnlock(hGlobal);
bResult = TRUE;
}
}
}
return bResult;
}
DROPEFFECT CMainFrame::OnDropEx(COleDataObject* pDataObject, DROPEFFECT dropDefault, DROPEFFECT dropList, CPoint point)
{
return (DROPEFFECT)-1;
}
void CMainFrame::OnDragLeave()
{
}
DROPEFFECT CMainFrame::OnDragScroll(DWORD dwKeyState, CPoint point)
{
return DROPEFFECT_NONE;
}
void CMainFrame::LoadControlBar(CControlBar* pBar, CString section, UINT defDockBarID)
{
if(!pBar || section.IsEmpty()) return;
CWinApp* pApp = AfxGetApp();
UINT nID = pApp->GetProfileInt(section, _T("DockState"), defDockBarID);
if(nID != AFX_IDW_DOCKBAR_FLOAT)
{
DockControlBar(pBar, nID);
}
else
{
// FIXME
CRect r;
GetWindowRect(r);
CPoint p;
p.x = r.left + pApp->GetProfileInt(section, _T("DockPosX"), r.Width());
p.y = r.top + pApp->GetProfileInt(section, _T("DockPosY"), 0);
FloatControlBar(pBar, p);
}
pBar->ShowWindow(
pApp->GetProfileInt(section, _T("Visible"), FALSE) && pBar != &m_wndSubresyncBar && pBar != &m_wndCaptureBar
? SW_SHOW
: SW_HIDE);
if(pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
{
((CSizingControlBar*)(pBar))->LoadState(section + _T("\State"));
}
}
void CMainFrame::SaveControlBar(CControlBar* pBar, CString section)
{
if(!pBar || section.IsEmpty()) return;
CWinApp* pApp = AfxGetApp();
pApp->WriteProfileInt(section, _T("Visible"), pBar->IsWindowVisible());
if(pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
((CSizingControlBar*)(pBar))->SaveState(section + _T("\State"));
UINT nID = pBar->GetParent()->GetDlgCtrlID();
if(nID == AFX_IDW_DOCKBAR_FLOAT)
{
return;//
// FIXME
CRect r1, r2;
GetWindowRect(r1);
pBar->GetWindowRect(r2);
pApp->WriteProfileInt(section, _T("DockPosX"), r2.left - r1.left);
pApp->WriteProfileInt(section, _T("DockPosY"), r2.top - r1.top);
}
pApp->WriteProfileInt(section, _T("DockState"), nID);
}
LRESULT CMainFrame::OnTaskBarRestart(WPARAM, LPARAM)
{
m_fTrayIcon = false;
ShowTrayIcon(AfxGetAppSettings().fTrayIcon);
return 0;
}
LRESULT CMainFrame::OnNotifyIcon(WPARAM wParam, LPARAM lParam)
{
if((UINT)wParam != IDR_MAINFRAME)
return -1;
switch((UINT)lParam)
{
case WM_LBUTTONDOWN:
ShowWindow(SW_SHOW);
MoveVideoWindow();
SetForegroundWindow();
break;
case WM_LBUTTONDBLCLK:
PostMessage(WM_COMMAND, ID_FILE_OPENMEDIA);
break;
case WM_RBUTTONDOWN:
{
POINT p;
GetCursorPos(&p);
SetForegroundWindow();
m_popupmain.GetSubMenu(0)->TrackPopupMenu(TPM_RIGHTBUTTON|TPM_NOANIMATION, p.x, p.y, this);
PostMessage(WM_NULL);
break;
}
case WM_MOUSEMOVE:
{
CString str;
GetWindowText(str);
SetTrayTip(str);
break;
}
default:
break;
}
return 0;
}
void CMainFrame::ShowTrayIcon(bool fShow)
{
BOOL bWasVisible = ShowWindow(SW_HIDE);
if(fShow)
{
if(!m_fTrayIcon)
{
NOTIFYICONDATA tnid;
tnid.cbSize = sizeof(NOTIFYICONDATA);
tnid.hWnd = m_hWnd;
tnid.uID = IDR_MAINFRAME;
// tnid.hIcon = (HICON)LoadIcon(AfxGetResourceHandle(), MAKEINTRESOURCE(IDR_MAINFRAME));
tnid.hIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDR_MAINFRAME), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
tnid.uFlags = NIF_MESSAGE|NIF_ICON|NIF_TIP;
tnid.uCallbackMessage = WM_NOTIFYICON;
lstrcpyn(tnid.szTip, TEXT("Media Player Classic"), sizeof(tnid.szTip));
Shell_NotifyIcon(NIM_ADD, &tnid);
m_fTrayIcon = true;
}
}
else
{
if(m_fTrayIcon)
{
NOTIFYICONDATA tnid;
tnid.cbSize = sizeof(NOTIFYICONDATA);
tnid.hWnd = m_hWnd;
tnid.uID = IDR_MAINFRAME;
Shell_NotifyIcon(NIM_DELETE, &tnid);
m_fTrayIcon = false;
}
}
if(bWasVisible)
ShowWindow(SW_SHOW);
}
void CMainFrame::SetTrayTip(CString str)
{
NOTIFYICONDATA tnid;
tnid.cbSize = sizeof(NOTIFYICONDATA);
tnid.hWnd = m_hWnd;
tnid.uID = IDR_MAINFRAME;
tnid.uFlags = NIF_TIP;
lstrcpyn(tnid.szTip, str, sizeof(tnid.szTip));
Shell_NotifyIcon(NIM_MODIFY, &tnid);
}
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
if(!__super::PreCreateWindow(cs))
return FALSE;
cs.dwExStyle &= ~WS_EX_CLIENTEDGE;
cs.lpszClass = MPC_WND_CLASS_NAME; //AfxRegisterWndClass(0);
return TRUE;
}
BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
{
if(pMsg->message == WM_KEYDOWN)
{
/* if(m_fShockwaveGraph
&& (pMsg->wParam == VK_LEFT || pMsg->wParam == VK_RIGHT
|| pMsg->wParam == VK_UP || pMsg->wParam == VK_DOWN))
return FALSE;
*/
if(pMsg->wParam == VK_ESCAPE && m_iMediaLoadState == MLS_LOADED && m_fFullScreen)
{
OnViewFullscreen();
PostMessage(WM_COMMAND, ID_PLAY_PAUSE);
return TRUE;
}
else if(pMsg->wParam == VK_ESCAPE && (IsCaptionMenuHidden()))
{
PostMessage(WM_COMMAND, ID_VIEW_CAPTIONMENU);
return TRUE;
}
else if(pMsg->wParam == VK_LEFT && pAMTuner)
{
PostMessage(WM_COMMAND, ID_NAVIGATE_SKIPBACK);
return TRUE;
}
else if(pMsg->wParam == VK_RIGHT && pAMTuner)
{
PostMessage(WM_COMMAND, ID_NAVIGATE_SKIPFORWARD);
return TRUE;
}
}
return __super::PreTranslateMessage(pMsg);
}
void CMainFrame::RecalcLayout(BOOL bNotify)
{
__super::RecalcLayout(bNotify);
CRect r;
GetWindowRect(&r);
MINMAXINFO mmi;
memset(&mmi, 0, sizeof(mmi));
SendMessage(WM_GETMINMAXINFO, 0, (LPARAM)&mmi);
r |= CRect(r.TopLeft(), CSize(r.Width(), mmi.ptMinTrackSize.y));
MoveWindow(&r);
}
/////////////////////////////////////////////////////////////////////////////
// CMainFrame diagnostics
#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
__super::AssertValid();
}
void CMainFrame::Dump(CDumpContext& dc) const
{
__super::Dump(dc);
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CMainFrame message handlers
void CMainFrame::OnSetFocus(CWnd* pOldWnd)
{
SetAlwaysOnTop(AfxGetAppSettings().iOnTop);
// forward focus to the view window
if(IsWindow(m_wndView.m_hWnd))
m_wndView.SetFocus();
}
BOOL CMainFrame::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
{
// let the view have first crack at the command
if(m_wndView.OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
return TRUE;
POSITION pos = m_bars.GetHeadPosition();
while(pos)
{
if(m_bars.GetNext(pos)->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
return TRUE;
}
pos = m_dockingbars.GetHeadPosition();
while(pos)
{
if(m_dockingbars.GetNext(pos)->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
return TRUE;
}
// otherwise, do default handling
return __super::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
}
void CMainFrame::OnGetMinMaxInfo(MINMAXINFO* lpMMI)
{
DWORD style = GetStyle();
MENUBARINFO mbi;
memset(&mbi, 0, sizeof(mbi));
mbi.cbSize = sizeof(mbi);
::GetMenuBarInfo(m_hWnd, OBJID_MENU, 0, &mbi);
lpMMI->ptMinTrackSize.x = 0;
if(!IsCaptionMenuHidden())
{
lpMMI->ptMinTrackSize.x = 10;
CRect r;
for(int i = 0; ::GetMenuItemRect(m_hWnd, mbi.hMenu, i, &r); i++)
lpMMI->ptMinTrackSize.x += r.Width();
lpMMI->ptMinTrackSize.x = max(DEFCLIENTW, lpMMI->ptMinTrackSize.x);
}
if(style&WS_THICKFRAME) lpMMI->ptMinTrackSize.x += GetSystemMetrics((style&WS_CAPTION)?SM_CXSIZEFRAME:SM_CXFIXEDFRAME)*2;
memset(&mbi, 0, sizeof(mbi));
mbi.cbSize = sizeof(mbi);
::GetMenuBarInfo(m_hWnd, OBJID_MENU, 0, &mbi);
lpMMI->ptMinTrackSize.y = 0;
if(style&WS_CAPTION) lpMMI->ptMinTrackSize.y += GetSystemMetrics(SM_CYCAPTION);
if(style&WS_THICKFRAME) lpMMI->ptMinTrackSize.y += GetSystemMetrics((style&WS_CAPTION)?SM_CYSIZEFRAME:SM_CYFIXEDFRAME)*2;
lpMMI->ptMinTrackSize.y += (mbi.rcBar.bottom - mbi.rcBar.top);
if(!AfxGetAppSettings().fHideCaptionMenu) lpMMI->ptMinTrackSize.y += 3;
POSITION pos = m_bars.GetHeadPosition();
while(pos)
{
CControlBar* pCB = m_bars.GetNext(pos);
if(!IsWindow(pCB->m_hWnd) || !pCB->IsVisible()) continue;
lpMMI->ptMinTrackSize.y += pCB->CalcFixedLayout(TRUE, TRUE).cy;
}
if(IsWindow(m_wndSubresyncBar.m_hWnd) && m_wndSubresyncBar.IsWindowVisible() && !m_wndSubresyncBar.IsFloating())
lpMMI->ptMinTrackSize.y += m_wndSubresyncBar.CalcFixedLayout(TRUE, TRUE).cy-2;
if(IsWindow(m_wndPlaylistBar.m_hWnd) && m_wndPlaylistBar.IsWindowVisible() && !m_wndPlaylistBar.IsFloating())
lpMMI->ptMinTrackSize.y += m_wndPlaylistBar.CalcFixedLayout(TRUE, TRUE).cy-2;
if(IsWindow(m_wndCaptureBar.m_hWnd) && m_wndCaptureBar.IsWindowVisible() && !m_wndCaptureBar.IsFloating())
lpMMI->ptMinTrackSize.y += m_wndCaptureBar.CalcFixedLayout(TRUE, TRUE).cy-2;
__super::OnGetMinMaxInfo(lpMMI);
}
void CMainFrame::OnMove(int x, int y)
{
__super::OnMove(x, y);
MoveVideoWindow();
WINDOWPLACEMENT wp;
GetWindowPlacement(&wp);
if(!m_fFullScreen && wp.flags != WPF_RESTORETOMAXIMIZED && wp.showCmd != SW_SHOWMINIMIZED)
GetWindowRect(AfxGetAppSettings().rcLastWindowPos);
}
void CMainFrame::OnSize(UINT nType, int cx, int cy)
{
__super::OnSize(nType, cx, cy);
if(nType == SIZE_RESTORED && m_fTrayIcon)
{
ShowWindow(SW_SHOW);
}
if(!m_fFullScreen)
{
AppSettings& s = AfxGetAppSettings();
if(nType != SIZE_MAXIMIZED && nType != SIZE_MINIMIZED)
GetWindowRect(s.rcLastWindowPos);
s.lastWindowType = nType;
}
}
void CMainFrame::OnSizing(UINT fwSide, LPRECT pRect)
{
__super::OnSizing(fwSide, pRect);
AppSettings& s = AfxGetAppSettings();
bool fCtrl = !!(GetAsyncKeyState(VK_CONTROL)&0x80000000);
if(m_iMediaLoadState != MLS_LOADED || m_fFullScreen
|| s.iDefaultVideoSize == DVS_STRETCH
|| (fCtrl ^ s.fFreeWindowResizing))
return;
CSize wsize(pRect->right - pRect->left, pRect->bottom - pRect->top);
CSize vsize = GetVideoSize();
CSize fsize(0, 0);
if(!vsize.cx || !vsize.cy)
return;
// TODO
{
DWORD style = GetStyle();
MENUBARINFO mbi;
memset(&mbi, 0, sizeof(mbi));
mbi.cbSize = sizeof(mbi);
::GetMenuBarInfo(m_hWnd, OBJID_MENU, 0, &mbi);
fsize.cx += GetSystemMetrics((style&WS_CAPTION)?SM_CXSIZEFRAME:SM_CXFIXEDFRAME)*2;
if(style&WS_CAPTION) fsize.cy += GetSystemMetrics(SM_CYCAPTION);
if(style&WS_THICKFRAME) fsize.cy += GetSystemMetrics((style&WS_CAPTION)?SM_CYSIZEFRAME:SM_CYFIXEDFRAME)*2;
fsize.cy += mbi.rcBar.bottom - mbi.rcBar.top;
if(!AfxGetAppSettings().fHideCaptionMenu) fsize.cy += 3;
POSITION pos = m_bars.GetHeadPosition();
while(pos)
{
CControlBar* pCB = m_bars.GetNext(pos);
if(IsWindow(pCB->m_hWnd) && pCB->IsVisible())
fsize.cy += pCB->CalcFixedLayout(TRUE, TRUE).cy;
}
if(IsWindow(m_wndSubresyncBar.m_hWnd) && m_wndSubresyncBar.IsWindowVisible())
{
if(m_wndSubresyncBar.IsHorzDocked())
fsize.cy += m_wndSubresyncBar.CalcFixedLayout(TRUE, TRUE).cy-2;
else if(m_wndSubresyncBar.IsVertDocked())
fsize.cx += m_wndSubresyncBar.CalcFixedLayout(TRUE, FALSE).cx;
}
if(IsWindow(m_wndPlaylistBar.m_hWnd) && m_wndPlaylistBar.IsWindowVisible())
{
if(m_wndPlaylistBar.IsHorzDocked())
fsize.cy += m_wndPlaylistBar.CalcFixedLayout(TRUE, TRUE).cy-2;
else if(m_wndPlaylistBar.IsVertDocked())
fsize.cx += m_wndPlaylistBar.CalcFixedLayout(TRUE, FALSE).cx;
}
if(IsWindow(m_wndCaptureBar.m_hWnd) && m_wndCaptureBar.IsWindowVisible())
{
if(m_wndCaptureBar.IsHorzDocked())
fsize.cy += m_wndCaptureBar.CalcFixedLayout(TRUE, TRUE).cy-2;
else if(m_wndCaptureBar.IsVertDocked())
fsize.cx += m_wndCaptureBar.CalcFixedLayout(TRUE, FALSE).cx;
}
}
wsize -= fsize;
bool fWider = wsize.cy < wsize.cx;
wsize.SetSize(
wsize.cy * vsize.cx / vsize.cy,
wsize.cx * vsize.cy / vsize.cx);
wsize += fsize;
if(fwSide == WMSZ_TOP || fwSide == WMSZ_BOTTOM || !fWider && (fwSide == WMSZ_TOPRIGHT || fwSide == WMSZ_BOTTOMRIGHT))
{
pRect->right = pRect->left + wsize.cx;
}
else if(fwSide == WMSZ_LEFT || fwSide == WMSZ_RIGHT || fWider && (fwSide == WMSZ_BOTTOMLEFT || fwSide == WMSZ_BOTTOMRIGHT))
{
pRect->bottom = pRect->top + wsize.cy;
}
else if(!fWider && (fwSide == WMSZ_TOPLEFT || fwSide == WMSZ_BOTTOMLEFT))
{
pRect->left = pRect->right - wsize.cx;
}
else if(fWider && (fwSide == WMSZ_TOPLEFT || fwSide == WMSZ_TOPRIGHT))
{
pRect->top = pRect->bottom - wsize.cy;
}
}
void CMainFrame::OnDisplayChange() // untested, not sure if it's working...
{
TRACE(_T("*** CMainFrame::OnDisplayChange()n"));
/*
if(m_iMediaLoadState == MLS_LOADED && m_pCAP)
m_pCAP->OnDisplayChange();
*/
}
void CMainFrame::OnSysCommand(UINT nID, LPARAM lParam)
{
if((nID & 0xFFF0) == SC_SCREENSAVE)
{
TRACE(_T("SC_SCREENSAVE, nID = %d, lParam = %dn"), nID, lParam);
}
else if((nID & 0xFFF0) == SC_MINIMIZE && m_fTrayIcon)
{
ShowWindow(SW_HIDE);
return;
}
__super::OnSysCommand(nID, lParam);
}
void CMainFrame::OnActivateApp(BOOL bActive, DWORD dwThreadID)
{
__super::OnActivateApp(bActive, dwThreadID);
MONITORINFO mi;
mi.cbSize = sizeof(MONITORINFO);
GetMonitorInfo(MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST), &mi);
if(m_iMediaLoadState == MLS_LOADED && m_fFullScreen && !bActive && (mi.dwFlags&MONITORINFOF_PRIMARY))
{
OnViewFullscreen();
}
}
LRESULT CMainFrame::OnAppCommand(WPARAM wParam, LPARAM lParam)
{
UINT cmd = GET_APPCOMMAND_LPARAM(lParam);
UINT uDevice = GET_DEVICE_LPARAM(lParam);
UINT dwKeys = GET_KEYSTATE_LPARAM(lParam);
if(uDevice != FAPPCOMMAND_OEM)
{
AppSettings& s = AfxGetAppSettings();
BOOL fRet = FALSE;
POSITION pos = s.wmcmds.GetHeadPosition();
while(pos)
{
wmcmd& wc = s.wmcmds.GetNext(pos);
if(wc.appcmd == cmd && TRUE == SendMessage(WM_COMMAND, wc.cmd))
fRet = TRUE;
}
if(fRet) return TRUE;
}
return Default();
}
void CMainFrame::OnTimer(UINT nIDEvent)
{
if(nIDEvent == TIMER_STREAMPOSPOLLER && m_iMediaLoadState == MLS_LOADED)
{
REFERENCE_TIME rtNow = 0, rtDur = 0;
if(m_iPlaybackMode == PM_FILE)
{
pMS->GetCurrentPosition(&rtNow);
pMS->GetDuration(&rtDur);
if(m_rtDurationOverride >= 0) rtDur = m_rtDurationOverride;
m_wndSeekBar.Enable(rtDur > 0);
m_wndSeekBar.SetRange(0, rtDur);
m_wndSeekBar.SetPos(rtNow);
}
else if(m_iPlaybackMode == PM_CAPTURE)
{
if(m_fCapturing && m_wndCaptureBar.m_capdlg.m_pMux)
{
CComQIPtr<IMediaSeeking> pMuxMS = m_wndCaptureBar.m_capdlg.m_pMux;
if(!pMuxMS || FAILED(pMuxMS->GetCurrentPosition(&rtNow))) rtNow = 0;
}
if(m_rtDurationOverride >= 0) rtDur = m_rtDurationOverride;
m_wndSeekBar.Enable(false);
m_wndSeekBar.SetRange(0, rtDur);
m_wndSeekBar.SetPos(rtNow);
/*
if(m_fCapturing)
{
if(rtNow > 10000i64*1000*60*60*3)
{
m_wndCaptureBar.m_capdlg.OnRecord();
}
}
*/
}
if(m_pCAP && m_iPlaybackMode != PM_FILE) m_pCAP->SetTime(/*rtNow*/m_wndSeekBar.GetPos());
}
else if(nIDEvent == TIMER_STREAMPOSPOLLER2 && m_iMediaLoadState == MLS_LOADED)
{
__int64 start, stop, pos;
m_wndSeekBar.GetRange(start, stop);
pos = m_wndSeekBar.GetPosReal();
GUID tf;
pMS->GetTimeFormat(&tf);
if(m_iPlaybackMode == PM_CAPTURE && !m_fCapturing)
{
CString str = _T("Live");
long lChannel = 0, lVivSub = 0, lAudSub = 0;
if(pAMTuner
&& m_wndCaptureBar.m_capdlg.IsTunerActive()
&& SUCCEEDED(pAMTuner->get_Channel(&lChannel, &lVivSub, &lAudSub)))
{
CString ch;
ch.Format(_T(" (ch%d)"), lChannel);
str += ch;
}
m_wndStatusBar.SetStatusTimer(str);
}
else
{
m_wndStatusBar.SetStatusTimer(pos, stop, !!m_wndSubresyncBar.IsWindowVisible(), &tf);
}
m_wndSubresyncBar.SetTime(pos);
if(m_pCAP && GetMediaState() == State_Paused) m_pCAP->Paint(true);
}
else if(nIDEvent == TIMER_FULLSCREENCONTROLBARHIDER)
{
CPoint p;
GetCursorPos(&p);
CRect r;
GetWindowRect(r);
bool fCursorOutside = !r.PtInRect(p);
CWnd* pWnd = WindowFromPoint(p);
if(pWnd && (m_wndView == *pWnd || m_wndView.IsChild(pWnd) || fCursorOutside))
{
if(AfxGetAppSettings().nShowBarsWhenFullScreenTimeOut >= 0)
ShowControls(CS_NONE, false);
}
}
else if(nIDEvent == TIMER_FULLSCREENMOUSEHIDER)
{
CPoint p;
GetCursorPos(&p);
CRect r;
GetWindowRect(r);
bool fCursorOutside = !r.PtInRect(p);
CWnd* pWnd = WindowFromPoint(p);
if(pWnd && (m_wndView == *pWnd || m_wndView.IsChild(pWnd) || fCursorOutside))
{
m_fHideCursor = true;
SetCursor(NULL);
}
}
else if(nIDEvent == TIMER_STATS)
{
if(pQP)
{
CString rate;
if(m_iSpeedLevel >= -11 && m_iSpeedLevel <= 3 && m_iSpeedLevel != -4)
{
CString speeds[] = {_T("1/8"),_T("1/4"),_T("1/2"),_T("1"),_T("2"),_T("4"),_T("8")};
rate = speeds[(m_iSpeedLevel >= -3 ? m_iSpeedLevel : (-m_iSpeedLevel - 8)) + 3];
if(m_iSpeedLevel < -4) rate = _T("-") + rate;
if(!rate.IsEmpty()) rate = _T("(") + rate + _T("X)");
}
CString info;
int val;
pQP->get_AvgFrameRate(&val);
info.Format(_T("%d.%02d %s"), val/100, val%100, rate);
m_wndStatsBar.SetLine(_T("Frame-rate"), info);
int avg, dev;
pQP->get_AvgSyncOffset(&avg);
pQP->get_DevSyncOffset(&dev);
info.Format(_T("avg: %d ms, dev: %d ms"), avg, dev);
m_wndStatsBar.SetLine(_T("Sync Offset"), info);
int drawn, dropped;
pQP->get_FramesDrawn(&drawn);
pQP->get_FramesDroppedInRenderer(&dropped);
info.Format(_T("drawn: %d, dropped: %d"), drawn, dropped);
m_wndStatsBar.SetLine(_T("Frames"), info);
pQP->get_Jitter(&val);
info.Format(_T("%d ms"), val);
m_wndStatsBar.SetLine(_T("Jitter"), info);
}
if(pBI)
{
CList<CString> sl;
for(int i = 0, j = pBI->GetCount(); i < j; i++)
{
int samples, size;
if(S_OK == pBI->GetStatus(i, samples, size))
{
CString str;
str.Format(_T("[%d]: %03d/%d KB"), i, samples, size / 1024);
sl.AddTail(str);
}
}
if(!sl.IsEmpty())
{
CString str;
str.Format(_T("%s (p%d)"), Implode(sl, ' '), pBI->GetPriority());
m_wndStatsBar.SetLine(_T("Buffers"), str);
}
}
CInterfaceList<IBitRateInfo> pBRIs;
BeginEnumFilters(pGB, pEF, pBF)
{
BeginEnumPins(pBF, pEP, pPin)
{
if(CComQIPtr<IBitRateInfo> pBRI = pPin)
{
pBRIs.AddTail(pBRI);
}
}
EndEnumPins
if(!pBRIs.IsEmpty())
{
CList<CString> sl;
POSITION pos = pBRIs.GetHeadPosition();
for(int i = 0; pos; i++)
{
IBitRateInfo* pBRI = pBRIs.GetNext(pos);
DWORD cur = pBRI->GetCurrentBitRate() / 1000;
DWORD avg = pBRI->GetAverageBitRate() / 1000;
if(avg == 0) continue;
CString str;
if(cur != avg) str.Format(_T("[%d]: %d/%d Kb/s"), i, avg, cur);
else str.Format(_T("[%d]: %d Kb/s"), i, avg);
sl.AddTail(str);
}
if(!sl.IsEmpty())
{
m_wndStatsBar.SetLine(_T("Bitrate"), Implode(sl, ' ') + _T(" (avg/cur)"));
}
break;
}
}
EndEnumFilters
if(m_iPlaybackMode == PM_FILE)
{
SetupChapters();
}
if(m_iPlaybackMode == PM_DVD) // we also use this timer to update the info panel for dvd playback
{
ULONG ulAvailable, ulCurrent;
// Domain
CString Domain('-');
DVD_DOMAIN dom;
if(SUCCEEDED(pDVDI->GetCurrentDomain(&dom)))
{
switch(dom)
{
case DVD_DOMAIN_FirstPlay: Domain = _T("First Play"); break;
case DVD_DOMAIN_VideoManagerMenu: Domain = _T("Video Manager Menu"); break;
case DVD_DOMAIN_VideoTitleSetMenu: Domain = _T("Video Title Set Menu"); break;
case DVD_DOMAIN_Title: Domain = _T("Title"); break;
case DVD_DOMAIN_Stop: Domain = _T("Stop"); break;
default: Domain = _T("-"); break;
}
}
m_wndInfoBar.SetLine(_T("Domain"), Domain);
// Location
CString Location('-');
DVD_PLAYBACK_LOCATION2 loc;
ULONG ulNumOfVolumes, ulVolume;
DVD_DISC_SIDE Side;
ULONG ulNumOfTitles;
ULONG ulNumOfChapters;
if(SUCCEEDED(pDVDI->GetCurrentLocation(&loc))
&& SUCCEEDED(pDVDI->GetNumberOfChapters(loc.TitleNum, &ulNumOfChapters))
&& SUCCEEDED(pDVDI->GetDVDVolumeInfo(&ulNumOfVolumes, &ulVolume, &Side, &ulNumOfTitles)))
{
Location.Format(_T("Volume: %02d/%02d, Title: %02d/%02d, Chapter: %02d/%02d"),
ulVolume, ulNumOfVolumes,
loc.TitleNum, ulNumOfTitles,
loc.ChapterNum, ulNumOfChapters);
}
m_wndInfoBar.SetLine(_T("Location"), Location);
// Video
CString Video('-');
DVD_VideoAttributes VATR;
if(SUCCEEDED(pDVDI->GetCurrentAngle(&ulAvailable, &ulCurrent))
&& SUCCEEDED(pDVDI->GetCurrentVideoAttributes(&VATR)))
{
Video.Format(_T("Angle: %02d/%02d, %dx%d %dHz %d:%d"),
ulAvailable, ulCurrent,
VATR.ulSourceResolutionX, VATR.ulSourceResolutionY, VATR.ulFrameRate,
VATR.ulAspectX, VATR.ulAspectY);
}
m_wndInfoBar.SetLine(_T("Video"), Video);
// Audio
CString Audio('-');
DVD_AudioAttributes AATR;
if(SUCCEEDED(pDVDI->GetCurrentAudio(&ulAvailable, &ulCurrent))
&& SUCCEEDED(pDVDI->GetAudioAttributes(ulCurrent, &AATR)))
{
CString lang;
int len = GetLocaleInfo(AATR.Language, LOCALE_SENGLANGUAGE, lang.GetBuffer(64), 64);
lang.ReleaseBufferSetLength(max(len-1, 0));
switch(AATR.LanguageExtension)
{
case DVD_AUD_EXT_NotSpecified:
default: break;
case DVD_AUD_EXT_Captions: lang += _T(" (Captions)"); break;
case DVD_AUD_EXT_VisuallyImpaired: lang += _T(" (Visually Impaired)"); break;
case DVD_AUD_EXT_DirectorComments1: lang += _T(" (Director Comments 1)"); break;
case DVD_AUD_EXT_DirectorComments2: lang += _T(" (Director Comments 2)"); break;
}
CString format;
switch(AATR.AudioFormat)
{
case DVD_AudioFormat_AC3: format = _T("AC3"); break;
case DVD_AudioFormat_MPEG1:
case DVD_AudioFormat_MPEG1_DRC: format = _T("MPEG1"); break;
case DVD_AudioFormat_MPEG2:
case DVD_AudioFormat_MPEG2_DRC: format = _T("MPEG2"); break;
case DVD_AudioFormat_LPCM: format = _T("LPCM"); break;
case DVD_AudioFormat_DTS: format = _T("DTS"); break;
case DVD_AudioFormat_SDDS: format = _T("SDDS"); break;
case DVD_AudioFormat_Other:
default: format = _T("Unknown format"); break;
}
Audio.Format(_T("%s, %s %dHz %dbits %d channel(s)"),
lang,
format,
AATR.dwFrequency,
AATR.bQuantization,
AATR.bNumberOfChannels);
m_wndStatusBar.SetStatusBitmap(
AATR.bNumberOfChannels == 1 ? IDB_MONO
: AATR.bNumberOfChannels >= 2 ? IDB_STEREO
: IDB_NOAUDIO);
}
m_wndInfoBar.SetLine(_T("Audio"), Audio);
// Subtitles
CString Subtitles('-');
BOOL bIsDisabled;
DVD_SubpictureAttributes SATR;
if(SUCCEEDED(pDVDI->GetCurrentSubpicture(&ulAvailable, &ulCurrent, &bIsDisabled))
&& SUCCEEDED(pDVDI->GetSubpictureAttributes(ulCurrent, &SATR)))
{
CString lang;
int len = GetLocaleInfo(SATR.Language, LOCALE_SENGLANGUAGE, lang.GetBuffer(64), 64);
lang.ReleaseBufferSetLength(max(len-1, 0));
switch(SATR.LanguageExtension)
{
case DVD_SP_EXT_NotSpecified:
default: break;
case DVD_SP_EXT_Caption_Normal: lang += _T(""); break;
case DVD_SP_EXT_Caption_Big: lang += _T(" (Big)"); break;
case DVD_SP_EXT_Caption_Children: lang += _T(" (Children)"); break;
case DVD_SP_EXT_CC_Normal: lang += _T(" (CC)"); break;
case DVD_SP_EXT_CC_Big: lang += _T(" (CC Big)"); break;
case DVD_SP_EXT_CC_Children: lang += _T(" (CC Children)"); break;
case DVD_SP_EXT_Forced: lang += _T(" (Forced)"); break;
case DVD_SP_EXT_DirectorComments_Normal: lang += _T(" (Director Comments)"); break;
case DVD_SP_EXT_DirectorComments_Big: lang += _T(" (Director Comments, Big)"); break;
case DVD_SP_EXT_DirectorComments_Children: lang += _T(" (Director Comments, Children)"); break;
}
if(bIsDisabled) lang = _T("-");
Subtitles.Format(_T("%s"),
lang);
}
m_wndInfoBar.SetLine(_T("Subtitles"), Subtitles);
}
if(GetMediaState() == State_Running)
{
UINT fSaverActive = 0;
if(SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, (PVOID)&fSaverActive, 0))
{
SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, 0, 0, SPIF_SENDWININICHANGE); // this might not be needed at all...
SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, fSaverActive, 0, SPIF_SENDWININICHANGE);
}
fSaverActive = 0;
if(SystemParametersInfo(SPI_GETPOWEROFFACTIVE, 0, (PVOID)&fSaverActive, 0))
{
SystemParametersInfo(SPI_SETPOWEROFFACTIVE, 0, 0, SPIF_SENDWININICHANGE); // this might not be needed at all...
SystemParametersInfo(SPI_SETPOWEROFFACTIVE, fSaverActive, 0, SPIF_SENDWININICHANGE);
}
}
}
else if(nIDEvent == TIMER_STATUSERASER)
{
KillTimer(TIMER_STATUSERASER);
m_playingmsg.Empty();
}
__super::OnTimer(nIDEvent);
}
static bool SetShutdownPrivilege()
{
HANDLE hToken;
TOKEN_PRIVILEGES tkp;
// Get a token for this process.
if(!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
return(false);
// Get the LUID for the shutdown privilege.
LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid);
tkp.PrivilegeCount = 1; // one privilege to set
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
// Get the shutdown privilege for this process.
AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);
if(GetLastError() != ERROR_SUCCESS)
return false;
return true;
}
bool CMainFrame::DoAfterPlaybackEvent()
{
AppSettings& s = AfxGetAppSettings();
bool fExit = false;
if(s.nCLSwitches&CLSW_CLOSE)
{
fExit = true;
}
if(s.nCLSwitches&CLSW_STANDBY)
{
SetShutdownPrivilege();
SetSystemPowerState(TRUE, TRUE);
fExit = true; // TODO: unless the app closes, it will call standby or hibernate once again forever, how to avoid that?
}
else if(s.nCLSwitches&CLSW_HIBERNATE)
{
SetShutdownPrivilege();
SetSystemPowerState(FALSE, TRUE);
fExit = true; // TODO: unless the app closes, it will call standby or hibernate once again forever, how to avoid that?
}
else if(s.nCLSwitches&CLSW_SHUTDOWN)
{
SetShutdownPrivilege();
ExitWindowsEx(EWX_SHUTDOWN|EWX_POWEROFF|EWX_FORCEIFHUNG, 0);
fExit = true;
}
else if(s.nCLSwitches&CLSW_LOGOFF)
{
SetShutdownPrivilege();
ExitWindowsEx(EWX_LOGOFF|EWX_FORCEIFHUNG, 0);
fExit = true;
}
if(!fExit) return false;
SendMessage(WM_COMMAND, ID_FILE_EXIT);
return true;
}
//
// our WM_GRAPHNOTIFY handler
//
#include <comdef.h>
LRESULT CMainFrame::OnGraphNotify(WPARAM wParam, LPARAM lParam)
{
HRESULT hr = S_OK;
LONG evCode, evParam1, evParam2;
while(pME && SUCCEEDED(pME->GetEvent(&evCode, (LONG_PTR*)&evParam1, (LONG_PTR*)&evParam2, 0)))
{
CString str;
if(m_fCustomGraph)
{
if(EC_BG_ERROR == evCode)
{
str = CString((char*)evParam1);
}
}
hr = pME->FreeEventParams(evCode, evParam1, evParam2);
if(EC_COMPLETE == evCode)
{
AppSettings& s = AfxGetAppSettings();
if(m_wndPlaylistBar.GetCount() <= 1)
{
m_nLoops++;
if(DoAfterPlaybackEvent()) return hr;
if(s.fLoopForever || m_nLoops < s.nLoops)
{
if(GetMediaState() == State_Stopped)
{
SendMessage(WM_COMMAND, ID_PLAY_PLAY);
}
else
{
LONGLONG pos = 0;
pMS->SetPositions(&pos, AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);
if(GetMediaState() == State_Paused)
{
SendMessage(WM_COMMAND, ID_PLAY_PLAY);
}
}
}
else
{
if(s.fRewind) SendMessage(WM_COMMAND, ID_PLAY_STOP);
else m_fEndOfStream = true;
SendMessage(WM_COMMAND, ID_PLAY_PAUSE);
if(m_fFullScreen && s.fExitFullScreenAtTheEnd)
OnViewFullscreen();
}
}
else if(m_wndPlaylistBar.GetCount() > 1)
{
if(m_wndPlaylistBar.IsAtEnd())
{
if(DoAfterPlaybackEvent()) return hr;
m_nLoops++;
}
if(s.fLoopForever || m_nLoops < s.nLoops)
{
int nLoops = m_nLoops;
PostMessage(WM_COMMAND, ID_NAVIGATE_SKIPFORWARD);
m_nLoops = nLoops;
}
else
{
if(m_fFullScreen && s.fExitFullScreenAtTheEnd)
OnViewFullscreen();
if(s.fRewind)
{
AfxGetAppSettings().nCLSwitches |= CLSW_OPEN; // HACK
PostMessage(WM_COMMAND, ID_NAVIGATE_SKIPFORWARD);
}
else
{
m_fEndOfStream = true;
PostMessage(WM_COMMAND, ID_PLAY_PAUSE);
}
}
}
}
else if(EC_ERRORABORT == evCode)
{
TRACE(_T("EC_ERRORABORT, hr = %08xn"), (HRESULT)evParam1);
// SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);
// m_closingmsg = _com_error((HRESULT)evParam1).ErrorMessage();
}
else if(EC_REPAINT == evCode)
{
TRACE(_T("EC_REPAINTn"));
}
else if(EC_BUFFERING_DATA == evCode)
{
TRACE(_T("EC_BUFFERING_DATA, %d, %dn"), (HRESULT)evParam1, evParam2);
m_fBuffering = ((HRESULT)evParam1 != S_OK);
}
else if(EC_STEP_COMPLETE == evCode)
{
if(m_fFrameSteppingActive)
{
m_fFrameSteppingActive = false;
pBA->put_Volume(m_VolumeBeforeFrameStepping);
}
}
else if(EC_DEVICE_LOST == evCode)
{
CComQIPtr<IBaseFilter> pBF;
if(m_iPlaybackMode == PM_CAPTURE
&& (!pVidCap && pVidCap == (pBF = (IUnknown*)evParam1)
|| !pAudCap && pAudCap == (pBF = (IUnknown*)evParam1))
&& evParam2 == 0)
{
SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);
}
}
else if(EC_DVD_TITLE_CHANGE == evCode)
{
if(m_iPlaybackMode == PM_FILE)
SetupChapters();
}
else if(EC_DVD_DOMAIN_CHANGE == evCode)
{
m_iDVDDomain = (DVD_DOMAIN)evParam1;
TRACE(_T("EC_DVD_DOMAIN_CHANGE %dn"), m_iDVDDomain);
MoveVideoWindow(); // AR might have changed
}
else if(EC_DVD_CURRENT_HMSF_TIME == evCode)
{
REFERENCE_TIME rtNow = 0, rtDur = 0;
double fps = evParam2 == DVD_TC_FLAG_25fps ? 25.0
: evParam2 == DVD_TC_FLAG_30fps ? 30.0
: evParam2 == DVD_TC_FLAG_DropFrame ? 29.97
: 25.0;
rtNow = HMSF2RT(*((DVD_HMSF_TIMECODE*)&evParam1), fps);
DVD_HMSF_TIMECODE tcDur;
ULONG ulFlags;
if(SUCCEEDED(pDVDI->GetTotalTitleTime(&tcDur, &ulFlags)))
{
rtDur = HMSF2RT(tcDur, fps);
}
m_wndSeekBar.Enable(rtDur > 0);
m_wndSeekBar.SetRange(0, rtDur);
m_wndSeekBar.SetPos(rtNow);
if(m_pSubClock) m_pSubClock->SetTime(rtNow);
}
else if(EC_DVD_ERROR == evCode)
{
TRACE(_T("EC_DVD_ERROR %d %dn"), evParam1, evParam2);
CString err;
switch(evParam1)
{
case DVD_ERROR_Unexpected: default: err = _T("DVD: Unexpected error"); break;
case DVD_ERROR_CopyProtectFail: err = _T("DVD: Copy-Protect Fail"); break;
case DVD_ERROR_InvalidDVD1_0Disc: err = _T("DVD: Invalid DVD 1.x Disc"); break;
case DVD_ERROR_InvalidDiscRegion: err = _T("DVD: Invalid Disc Region"); break;
case DVD_ERROR_LowParentalLevel: err = _T("DVD: Low Parental Level"); break;
case DVD_ERROR_MacrovisionFail: err = _T("DVD: Macrovision Fail"); break;
case DVD_ERROR_IncompatibleSystemAndDecoderRegions: err = _T("DVD: Incompatible System And Decoder Regions"); break;
case DVD_ERROR_IncompatibleDiscAndDecoderRegions: err = _T("DVD: Incompatible Disc And Decoder Regions"); break;
}
SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);
m_closingmsg = err;
}
else if(EC_DVD_WARNING == evCode)
{
TRACE(_T("EC_DVD_WARNING %d %dn"), evParam1, evParam2);
}
else if(EC_VIDEO_SIZE_CHANGED == evCode)
{
TRACE(_T("EC_VIDEO_SIZE_CHANGED %dx%dn"), CSize(evParam1));
WINDOWPLACEMENT wp;
wp.length = sizeof(wp);
GetWindowPlacement(&wp);
CSize size(evParam1);
m_fAudioOnly = (size.cx <= 0 || size.cy <= 0);
if(AfxGetAppSettings().fRememberZoomLevel
&& !(m_fFullScreen || wp.showCmd == SW_SHOWMAXIMIZED || wp.showCmd == SW_SHOWMINIMIZED))
{
ZoomVideoWindow();
}
else
{
MoveVideoWindow();
}
if(m_iMediaLoadState == MLS_LOADED
&& !m_fAudioOnly && (AfxGetAppSettings().nCLSwitches&CLSW_FULLSCREEN))
{
PostMessage(WM_COMMAND, ID_VIEW_FULLSCREEN);
AfxGetAppSettings().nCLSwitches &= ~CLSW_FULLSCREEN;
}
}
else if(EC_LENGTH_CHANGED == evCode)
{
__int64 rtDur = 0;
pMS->GetDuration(&rtDur);
m_wndPlaylistBar.SetCurTime(rtDur);
}
else if(!m_fCustomGraph)
{
TRACE(_T("%dn"), evCode);
}
else if(EC_BG_AUDIO_CHANGED == evCode)
{
int nAudioChannels = evParam1;
m_wndStatusBar.SetStatusBitmap(nAudioChannels == 1 ? IDB_MONO
: nAudioChannels >= 2 ? IDB_STEREO
: IDB_NOAUDIO);
}
else if(EC_BG_ERROR == evCode)
{
SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);
m_closingmsg = !str.IsEmpty() ? str : _T("Unspecified graph error");
m_wndPlaylistBar.SetCurValid(false);
break;
}
}
return hr;
}
LRESULT CMainFrame::OnRepaintRenderLess(WPARAM wParam, LPARAM lParam)
{
MoveVideoWindow();
return TRUE;
}
LRESULT CMainFrame::OnResumeFromState(WPARAM wParam, LPARAM lParam)
{
int iPlaybackMode = (int)wParam;
if(iPlaybackMode == PM_FILE)
{
SeekTo(10000i64*int(lParam));
}
else if(iPlaybackMode == PM_DVD)
{
CComPtr<IDvdState> pDvdState;
pDvdState.Attach((IDvdState*)lParam);
if(pDVDC) pDVDC->SetState(pDvdState, DVD_CMD_FLAG_Block, NULL);
}
else if(iPlaybackMode == PM_CAPTURE)
{
// not implemented
}
else
{
ASSERT(0);
return FALSE;
}
return TRUE;
}
BOOL CMainFrame::OnButton(UINT id, UINT nFlags, CPoint point)
{
SetFocus();
CRect r;
m_wndView.GetClientRect(r);
m_wndView.MapWindowPoints(this, &r);
if(id != wmcmd::WDOWN && id != wmcmd::WUP && !r.PtInRect(point)) return FALSE;
BOOL ret = FALSE;
AppSettings& s = AfxGetAppSettings();
POSITION pos = s.wmcmds.GetHeadPosition();
while(pos)
{
wmcmd& wc = s.wmcmds.GetNext(pos);
if(wc.mouse == id)
{
SendMessage(WM_COMMAND, wc.cmd);
ret = true;
}
}
return ret;
}
static bool s_fLDown = false;
void CMainFrame::OnLButtonDown(UINT nFlags, CPoint point)
{
SetFocus();
bool fClicked = false;
if(m_iPlaybackMode == PM_DVD)
{
CPoint p = point - m_wndView.GetVideoRect().TopLeft();
if(SUCCEEDED(pDVDC->ActivateAtPosition(p))
|| m_iDVDDomain == DVD_DOMAIN_VideoManagerMenu
|| m_iDVDDomain == DVD_DOMAIN_VideoTitleSetMenu)
fClicked = true;
}
if(!fClicked)
{
bool fLeftMouseBtnUnassigned = true;
AppSettings& s = AfxGetAppSettings();
POSITION pos = s.wmcmds.GetHeadPosition();
while(pos && fLeftMouseBtnUnassigned)
if(s.wmcmds.GetNext(pos).mouse == wmcmd::LDOWN)
fLeftMouseBtnUnassigned = false;
if(!m_fFullScreen && (IsCaptionMenuHidden() || fLeftMouseBtnUnassigned))
{
PostMessage(WM_NCLBUTTONDOWN, HTCAPTION, MAKELPARAM(point.x, point.y));
}
else
{
s_fLDown = true;
if(OnButton(wmcmd::LDOWN, nFlags, point))
return;
}
}
__super::OnLButtonDown(nFlags, point);
}
void CMainFrame::OnLButtonUp(UINT nFlags, CPoint point)
{
if(!OnButton(wmcmd::LUP, nFlags, point))
__super::OnLButtonUp(nFlags, point);
}
void CMainFrame::OnLButtonDblClk(UINT nFlags, CPoint point)
{
if(s_fLDown)
{
SendMessage(WM_LBUTTONDOWN, nFlags, MAKELPARAM(point.x, point.y));
s_fLDown = false;
}
if(!OnButton(wmcmd::LDBLCLK, nFlags, point))
__super::OnLButtonDblClk(nFlags, point);
}
void CMainFrame::OnMButtonDown(UINT nFlags, CPoint point)
{
SendMessage(WM_CANCELMODE);
if(!OnButton(wmcmd::MDOWN, nFlags, point))
__super::OnMButtonDown(nFlags, point);
}
void CMainFrame::OnMButtonUp(UINT nFlags, CPoint point)
{
if(!OnButton(wmcmd::MUP, nFlags, point))
__super::OnMButtonUp(nFlags, point);
}
void CMainFrame::OnMButtonDblClk(UINT nFlags, CPoint point)
{
SendMessage(WM_MBUTTONDOWN, nFlags, MAKELPARAM(point.x, point.y));
if(!OnButton(wmcmd::MDBLCLK, nFlags, point))
__super::OnMButtonDblClk(nFlags, point);
}
void CMainFrame::OnRButtonDown(UINT nFlags, CPoint point)
{
if(!OnButton(wmcmd::RDOWN, nFlags, point))
__super::OnRButtonDown(nFlags, point);
}
void CMainFrame::OnRButtonUp(UINT nFlags, CPoint point)
{
if(!OnButton(wmcmd::RUP, nFlags, point))
__super::OnRButtonUp(nFlags, point);
}
void CMainFrame::OnRButtonDblClk(UINT nFlags, CPoint point)
{
SendMessage(WM_RBUTTONDOWN, nFlags, MAKELPARAM(point.x, point.y));
if(!OnButton(wmcmd::RDBLCLK, nFlags, point))
__super::OnRButtonDblClk(nFlags, point);
}
LRESULT CMainFrame::OnXButtonDown(WPARAM wParam, LPARAM lParam)
{
SendMessage(WM_CANCELMODE);
UINT fwButton = GET_XBUTTON_WPARAM(wParam);
return OnButton(fwButton == XBUTTON1 ? wmcmd::X1DOWN : fwButton == XBUTTON2 ? wmcmd::X2DOWN : wmcmd::NONE,
GET_KEYSTATE_WPARAM(wParam), CPoint(lParam));
}
LRESULT CMainFrame::OnXButtonUp(WPARAM wParam, LPARAM lParam)
{
UINT fwButton = GET_XBUTTON_WPARAM(wParam);
return OnButton(fwButton == XBUTTON1 ? wmcmd::X1UP : fwButton == XBUTTON2 ? wmcmd::X2UP : wmcmd::NONE,
GET_KEYSTATE_WPARAM(wParam), CPoint(lParam));
}
LRESULT CMainFrame::OnXButtonDblClk(WPARAM wParam, LPARAM lParam)
{
SendMessage(WM_XBUTTONDOWN, wParam, lParam);
UINT fwButton = GET_XBUTTON_WPARAM(wParam);
return OnButton(fwButton == XBUTTON1 ? wmcmd::X1DBLCLK : fwButton == XBUTTON2 ? wmcmd::X2DBLCLK : wmcmd::NONE,
GET_KEYSTATE_WPARAM(wParam), CPoint(lParam));
}
BOOL CMainFrame::OnMouseWheel(UINT nFlags, short zDelta, CPoint point)
{
ScreenToClient(&point);
BOOL fRet =
zDelta > 0 ? OnButton(wmcmd::WUP, nFlags, point) :
zDelta < 0 ? OnButton(wmcmd::WDOWN, nFlags, point) :
FALSE;
return fRet;
}
void CMainFrame::OnMouseMove(UINT nFlags, CPoint point)
{
if(m_iPlaybackMode == PM_DVD)
{
CPoint vp = point - m_wndView.GetVideoRect().TopLeft();
pDVDC->SelectAtPosition(vp);
}
CSize diff = m_lastMouseMove - point;
if(m_fFullScreen && (abs(diff.cx)+abs(diff.cy)) >= 1)
{
int nTimeOut = AfxGetAppSettings().nShowBarsWhenFullScreenTimeOut;
if(nTimeOut < 0)
{
m_fHideCursor = false;
if(AfxGetAppSettings().fShowBarsWhenFullScreen)
ShowControls(AfxGetAppSettings().nCS);
KillTimer(TIMER_FULLSCREENCONTROLBARHIDER);
SetTimer(TIMER_FULLSCREENMOUSEHIDER, 2000, NULL);
}
else if(nTimeOut == 0)
{
CRect r;
GetClientRect(r);
r.top = r.bottom;
POSITION pos = m_bars.GetHeadPosition();
for(int i = 1; pos; i <<= 1)
{
CControlBar* pNext = m_bars.GetNext(pos);
CSize s = pNext->CalcFixedLayout(FALSE, TRUE);
if(AfxGetAppSettings().nCS&i) r.top -= s.cy;
}
// HACK: the controls would cover the menu too early hiding some buttons
if(m_iPlaybackMode == PM_DVD
&& (m_iDVDDomain == DVD_DOMAIN_VideoManagerMenu
|| m_iDVDDomain == DVD_DOMAIN_VideoTitleSetMenu))
r.top = r.bottom - 10;
m_fHideCursor = false;
if(r.PtInRect(point))
{
if(AfxGetAppSettings().fShowBarsWhenFullScreen)
ShowControls(AfxGetAppSettings().nCS);
}
else
{
if(AfxGetAppSettings().fShowBarsWhenFullScreen)
ShowControls(CS_NONE, false);
}
SetTimer(TIMER_FULLSCREENMOUSEHIDER, 2000, NULL);
}
else
{
m_fHideCursor = false;
if(AfxGetAppSettings().fShowBarsWhenFullScreen)
ShowControls(AfxGetAppSettings().nCS);
SetTimer(TIMER_FULLSCREENCONTROLBARHIDER, nTimeOut*1000, NULL);
SetTimer(TIMER_FULLSCREENMOUSEHIDER, max(nTimeOut*1000, 2000), NULL);
}
}
m_lastMouseMove = point;
__super::OnMouseMove(nFlags, point);
}
LRESULT CMainFrame::OnNcHitTest(CPoint point)
{
LRESULT nHitTest = __super::OnNcHitTest(point);
return ((IsCaptionMenuHidden()) && nHitTest == HTCLIENT) ? HTCAPTION : nHitTest;
}
void CMainFrame::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
if(pScrollBar->IsKindOf(RUNTIME_CLASS(CVolumeCtrl)))
{
OnPlayVolume(0);
}
else if(pScrollBar->IsKindOf(RUNTIME_CLASS(CPlayerSeekBar)) && m_iMediaLoadState == MLS_LOADED)
{
SeekTo(m_wndSeekBar.GetPos(), !!(::GetKeyState(VK_SHIFT)&0x8000));
}
__super::OnHScroll(nSBCode, nPos, pScrollBar);
}
void CMainFrame::OnInitMenu(CMenu* pMenu)
{
__super::OnInitMenu(pMenu);
MENUITEMINFO mii;
mii.cbSize = sizeof(mii);
for(UINT i = 0, j = pMenu->GetMenuItemCount(); i < j; i++)
{
CString str;
pMenu->GetMenuString(i, str, MF_BYPOSITION);
CMenu* pSubMenu = NULL;
if(str == ResStr(IDS_FAVORITES_POPUP))
{
SetupFavoritesSubMenu();
pSubMenu = &m_favorites;
}
if(pSubMenu)
{
mii.fMask = MIIM_STATE|MIIM_SUBMENU;
mii.fType = MF_POPUP;
mii.hSubMenu = pSubMenu->m_hMenu;
mii.fState = (pSubMenu->GetMenuItemCount() > 0 ? MF_ENABLED : (MF_DISABLED|MF_GRAYED));
pMenu->SetMenuItemInfo(i, &mii, TRUE);
}
}
}
void CMainFrame::OnInitMenuPopup(CMenu* pPopupMenu, UINT nIndex, BOOL bSysMenu)
{
__super::OnInitMenuPopup(pPopupMenu, nIndex, bSysMenu);
static CAtlMap<CString, UINT, CStringElementTraits<CString> > transl;
if(transl.IsEmpty())
{
transl[_T("Navigate")] = IDS_NAVIGATE_POPUP;
transl[_T("Open CD-ROM")] = IDS_OPENCDROM_POPUP;
transl[_T("Filters")] = IDS_FILTERS_POPUP;
transl[_T("Audio")] = IDS_AUDIO_POPUP;
transl[_T("Subtitles")] = IDS_SUBTITLES_POPUP;
transl[_T("Audio Language")] = IDS_AUDIOLANGUAGE_POPUP;
transl[_T("Subtitle Language")] = IDS_SUBTITLELANGUAGE_POPUP;
transl[_T("Video Angle")] = IDS_VIDEOANGLE_POPUP;
transl[_T("Jump To...")] = IDS_JUMPTO_POPUP;
transl[_T("Favorites")] = IDS_FAVORITES_POPUP;
transl[_T("Shaders")] = IDS_SHADER_POPUP;
transl[_T("Video Frame")] = IDS_VIDEOFRAME_POPUP;
transl[_T("PanScan")] = IDS_PANSCAN_POPUP;
transl[_T("Aspect Ratio")] = IDS_ASPECTRATIO_POPUP;
transl[_T("Zoom")] = IDS_ZOOM_POPUP;
}
MENUITEMINFO mii;
mii.cbSize = sizeof(mii);
for(UINT i = 0, j = pPopupMenu->GetMenuItemCount(); i < j; i++)
{
CString str;
pPopupMenu->GetMenuString(i, str, MF_BYPOSITION);
CString lookupstr = str;
lookupstr.Remove('&');
CMenu* pSubMenu = NULL;
UINT id;
if(transl.Lookup(lookupstr, id))
{
str = ResStr(id);
// pPopupMenu->ModifyMenu(i, MF_BYPOSITION|MF_STRING, 0, str);
MENUITEMINFO mii;
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STRING;
mii.dwTypeData = (LPTSTR)(LPCTSTR)str;
pPopupMenu->SetMenuItemInfo(i, &mii, TRUE);
}
if(str == ResStr(IDS_NAVIGATE_POPUP))
{
UINT fState = (m_iMediaLoadState == MLS_LOADED
&& (1/*m_iPlaybackMode == PM_DVD *//*|| (m_iPlaybackMode == PM_FILE && m_PlayList.GetCount() > 0)*/))
? MF_ENABLED
: (MF_DISABLED|MF_GRAYED);
pPopupMenu->EnableMenuItem(i, MF_BYPOSITION|fState);
}
else if(str == ResStr(IDS_VIDEOFRAME_POPUP)
|| str == ResStr(IDS_PANSCAN_POPUP)
|| str == ResStr(IDS_ASPECTRATIO_POPUP)
|| str == ResStr(IDS_ZOOM_POPUP))
{
UINT fState = (m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly)
? MF_ENABLED
: (MF_DISABLED|MF_GRAYED);
pPopupMenu->EnableMenuItem(i, MF_BYPOSITION|fState);
}
else if(str == ResStr(IDS_OPENCDROM_POPUP))
{
SetupOpenCDSubMenu();
pSubMenu = &m_opencds;
}
else if(str == ResStr(IDS_FILTERS_POPUP))
{
SetupFiltersSubMenu();
pSubMenu = &m_filters;
}
else if(str == ResStr(IDS_AUDIO_POPUP))
{
SetupAudioSwitcherSubMenu();
pSubMenu = &m_audios;
}
else if(str == ResStr(IDS_SUBTITLES_POPUP))
{
SetupSubtitlesSubMenu();
pSubMenu = &m_subtitles;
}
else if(str == ResStr(IDS_AUDIOLANGUAGE_POPUP))
{
SetupNavAudioSubMenu();
pSubMenu = &m_navaudio;
}
else if(str == ResStr(IDS_SUBTITLELANGUAGE_POPUP))
{
SetupNavSubtitleSubMenu();
pSubMenu = &m_navsubtitle;
}
else if(str == ResStr(IDS_VIDEOANGLE_POPUP))
{
SetupNavAngleSubMenu();
pSubMenu = &m_navangle;
}
else if(str == ResStr(IDS_JUMPTO_POPUP))
{
SetupNavChaptersSubMenu();
pSubMenu = &m_navchapters;
}
else if(str == ResStr(IDS_FAVORITES_POPUP))
{
SetupFavoritesSubMenu();
pSubMenu = &m_favorites;
}
else if(str == ResStr(IDS_SHADER_POPUP))
{
SetupShadersSubMenu();
pSubMenu = &m_shaders;
}
if(pSubMenu)
{
mii.fMask = MIIM_STATE|MIIM_SUBMENU;
mii.fType = MF_POPUP;
mii.hSubMenu = pSubMenu->m_hMenu;
mii.fState = (pSubMenu->GetMenuItemCount() > 0 ? MF_ENABLED : (MF_DISABLED|MF_GRAYED));
pPopupMenu->SetMenuItemInfo(i, &mii, TRUE);
}
}
//
for(UINT i = 0, j = pPopupMenu->GetMenuItemCount(); i < j; i++)
{
UINT nID = pPopupMenu->GetMenuItemID(i);
if(nID == ID_SEPARATOR || nID == -1
|| nID >= ID_FAVORITES_FILE_START && nID <= ID_FAVORITES_FILE_END
|| nID >= ID_NAVIGATE_CHAP_SUBITEM_START && nID <= ID_NAVIGATE_CHAP_SUBITEM_END)
continue;
CString str;
pPopupMenu->GetMenuString(i, str, MF_BYPOSITION);
int k = str.Find('t');
if(k > 0) str = str.Left(k);
CString key = CPPageAccelTbl::MakeAccelShortcutLabel(nID);
if(!key.IsEmpty()) str += _T("t") + key;
if(key.IsEmpty() && i < 0) continue;
// BUG(?): this disables menu item update ui calls for some reason...
// pPopupMenu->ModifyMenu(i, MF_BYPOSITION|MF_STRING, nID, str);
// this works fine
MENUITEMINFO mii;
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STRING;
mii.dwTypeData = (LPTSTR)(LPCTSTR)str;
pPopupMenu->SetMenuItemInfo(i, &mii, TRUE);
}
//
bool fPnSPresets = false;
for(UINT i = 0, j = pPopupMenu->GetMenuItemCount(); i < j; i++)
{
UINT nID = pPopupMenu->GetMenuItemID(i);
if(nID >= ID_PANNSCAN_PRESETS_START && nID < ID_PANNSCAN_PRESETS_END)
{
do
{
nID = pPopupMenu->GetMenuItemID(i);
pPopupMenu->DeleteMenu(i, MF_BYPOSITION);
j--;
}
while(i < j && nID >= ID_PANNSCAN_PRESETS_START && nID < ID_PANNSCAN_PRESETS_END);
nID = pPopupMenu->GetMenuItemID(i);
}
if(nID == ID_VIEW_RESET)
{
fPnSPresets = true;
}
}
if(fPnSPresets)
{
AppSettings& s = AfxGetAppSettings();
int i = 0, j = s.m_pnspresets.GetCount();
for(; i < j; i++)
{
int k = 0;
CString label = s.m_pnspresets[i].Tokenize(_T(","), k);
pPopupMenu->InsertMenu(ID_VIEW_RESET, MF_BYCOMMAND, ID_PANNSCAN_PRESETS_START+i, label);
}
// if(j > 0)
{
pPopupMenu->InsertMenu(ID_VIEW_RESET, MF_BYCOMMAND, ID_PANNSCAN_PRESETS_START+i, _T("Edit..."));
pPopupMenu->InsertMenu(ID_VIEW_RESET, MF_BYCOMMAND|MF_SEPARATOR);
}
}
}
BOOL CMainFrame::OnMenu(CMenu* pMenu)
{
if(!pMenu) return FALSE;
KillTimer(TIMER_FULLSCREENMOUSEHIDER);
m_fHideCursor = false;
CPoint point;
GetCursorPos(&point);
pMenu->TrackPopupMenu(TPM_RIGHTBUTTON|TPM_NOANIMATION, point.x, point.y, this);
return TRUE;
}
void CMainFrame::OnMenuPlayerShort()
{
if(IsCaptionMenuHidden())
{
OnMenu(m_popupmain.GetSubMenu(0));
}
else
{
OnMenu(m_popup.GetSubMenu(0));
}
}
void CMainFrame::OnMenuPlayerLong()
{
OnMenu(m_popupmain.GetSubMenu(0));
}
void CMainFrame::OnMenuFilters()
{
SetupFiltersSubMenu();
OnMenu(&m_filters);
}
void CMainFrame::OnUpdatePlayerStatus(CCmdUI* pCmdUI)
{
if(m_iMediaLoadState == MLS_LOADING)
{
pCmdUI->SetText(_T("Opening..."));
}
else if(m_iMediaLoadState == MLS_LOADED)
{
CString msg;
if(!m_playingmsg.IsEmpty())
{
msg = m_playingmsg;
}
else if(m_fCapturing)
{
msg = _T("Capturing...");
if(pAMDF)
{
long lDropped = 0;
pAMDF->GetNumDropped(&lDropped);
long lNotDropped = 0;
pAMDF->GetNumNotDropped(&lNotDropped);
if((lDropped + lNotDropped) > 0)
{
CString str;
str.Format(_T(", Total: %d, Dropped: %d"), lDropped + lNotDropped, lDropped);
msg += str;
}
}
CComPtr<IPin> pPin;
if(SUCCEEDED(pCGB->FindPin(m_wndCaptureBar.m_capdlg.m_pDst, PINDIR_INPUT, NULL, NULL, FALSE, 0, &pPin)))
{
LONGLONG size = 0;
if(CComQIPtr<IStream> pStream = pPin)
{
pStream->Commit(STGC_DEFAULT);
WIN32_FIND_DATA findFileData;
HANDLE h = FindFirstFile(m_wndCaptureBar.m_capdlg.m_file, &findFileData);
if(h != INVALID_HANDLE_VALUE)
{
size = ((LONGLONG)findFileData.nFileSizeHigh << 32) | findFileData.nFileSizeLow;
CString str;
if(size < 1024i64*1024)
str.Format(_T(", Size: %I64dKB"), size/1024);
else //if(size < 1024i64*1024*1024)
str.Format(_T(", Size: %I64dMB"), size/1024/1024);
msg += str;
FindClose(h);
}
}
ULARGE_INTEGER FreeBytesAvailable, TotalNumberOfBytes, TotalNumberOfFreeBytes;
if(GetDiskFreeSpaceEx(
m_wndCaptureBar.m_capdlg.m_file.Left(m_wndCaptureBar.m_capdlg.m_file.ReverseFind('\')+1),
&FreeBytesAvailable, &TotalNumberOfBytes, &TotalNumberOfFreeBytes))
{
CString str;
if(FreeBytesAvailable.QuadPart < 1024i64*1024)
str.Format(_T(", Free: %I64dKB"), FreeBytesAvailable.QuadPart/1024);
else //if(FreeBytesAvailable.QuadPart < 1024i64*1024*1024)
str.Format(_T(", Free: %I64dMB"), FreeBytesAvailable.QuadPart/1024/1024);
msg += str;
}
if(m_wndCaptureBar.m_capdlg.m_pMux)
{
__int64 pos = 0;
CComQIPtr<IMediaSeeking> pMuxMS = m_wndCaptureBar.m_capdlg.m_pMux;
if(pMuxMS && SUCCEEDED(pMuxMS->GetCurrentPosition(&pos)) && pos > 0)
{
double bytepersec = 10000000.0 * size / pos;
if(bytepersec > 0)
m_rtDurationOverride = __int64(10000000.0 * (FreeBytesAvailable.QuadPart+size) / bytepersec);
}
}
if(m_wndCaptureBar.m_capdlg.m_pVidBuffer
|| m_wndCaptureBar.m_capdlg.m_pAudBuffer)
{
int nFreeVidBuffers = 0, nFreeAudBuffers = 0;
if(CComQIPtr<IBufferFilter> pVB = m_wndCaptureBar.m_capdlg.m_pVidBuffer)
nFreeVidBuffers = pVB->GetFreeBuffers();
if(CComQIPtr<IBufferFilter> pAB = m_wndCaptureBar.m_capdlg.m_pAudBuffer)
nFreeAudBuffers = pAB->GetFreeBuffers();
CString str;
str.Format(_T(", Free V/A Buffers: %03d/%03d"), nFreeVidBuffers, nFreeAudBuffers);
msg += str;
}
}
}
else if(m_fBuffering)
{
BeginEnumFilters(pGB, pEF, pBF)
{
if(CComQIPtr<IAMNetworkStatus, &IID_IAMNetworkStatus> pAMNS = pBF)
{
long BufferingProgress = 0;
if(SUCCEEDED(pAMNS->get_BufferingProgress(&BufferingProgress)) && BufferingProgress > 0)
{
msg.Format(_T("Buffering... (%d%%)"), BufferingProgress);
__int64 start = 0, stop = 0;
m_wndSeekBar.GetRange(start, stop);
m_fLiveWM = (stop == start);
}
break;
}
}
EndEnumFilters
}
else if(pAMOP)
{
__int64 t = 0, c = 0;
if(SUCCEEDED(pAMOP->QueryProgress(&t, &c)) && t > 0 && c < t)
msg.Format(_T("Buffering... (%d%%)"), c*100/t);
if(m_fUpdateInfoBar)
OpenSetupInfoBar();
}
OAFilterState fs = GetMediaState();
pCmdUI->SetText(
!msg.IsEmpty() ? msg :
fs == State_Stopped ? _T("Stopped") :
(fs == State_Paused || m_fFrameSteppingActive) ? _T("Paused") :
fs == State_Running ? _T("Playing") :
_T(""));
}
else if(m_iMediaLoadState == MLS_CLOSING)
{
pCmdUI->SetText(_T("Closing..."));
}
else
{
pCmdUI->SetText(m_closingmsg);
}
}
void CMainFrame::OnFilePostOpenmedia()
{
OpenSetupInfoBar();
OpenSetupStatsBar();
OpenSetupStatusBar();
// OpenSetupToolBar();
OpenSetupCaptureBar();
__int64 rtDur = 0;
pMS->GetDuration(&rtDur);
m_wndPlaylistBar.SetCurTime(rtDur);
if(m_iPlaybackMode == PM_CAPTURE)
{
ShowControlBar(&m_wndSubresyncBar, FALSE, TRUE);
// ShowControlBar(&m_wndPlaylistBar, FALSE, TRUE);
// ShowControlBar(&m_wndCaptureBar, TRUE, TRUE);
}
m_iMediaLoadState = MLS_LOADED;
// IMPORTANT: must not call any windowing msgs before
// this point, it will deadlock when OpenMediaPrivate is
// still running and the renderer window was created on
// the same worker-thread
{
WINDOWPLACEMENT wp;
wp.length = sizeof(wp);
GetWindowPlacement(&wp);
// restore magnification
if(IsWindowVisible() && AfxGetAppSettings().fRememberZoomLevel
&& !(m_fFullScreen || wp.showCmd == SW_SHOWMAXIMIZED || wp.showCmd == SW_SHOWMINIMIZED))
{
ZoomVideoWindow();
}
}
if(!m_fAudioOnly && (AfxGetAppSettings().nCLSwitches&CLSW_FULLSCREEN))
{
SendMessage(WM_COMMAND, ID_VIEW_FULLSCREEN);
AfxGetAppSettings().nCLSwitches &= ~CLSW_FULLSCREEN;
}
SendNowPlayingToMSN();
}
void CMainFrame::OnUpdateFilePostOpenmedia(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADING);
}
void CMainFrame::OnFilePostClosemedia()
{
m_wndView.SetVideoRect();
m_wndSeekBar.Enable(false);
m_wndSeekBar.SetPos(0);
m_wndInfoBar.RemoveAllLines();
m_wndStatsBar.RemoveAllLines();
m_wndStatusBar.Clear();
m_wndStatusBar.ShowTimer(false);
if(IsWindow(m_wndSubresyncBar.m_hWnd))
{
ShowControlBar(&m_wndSubresyncBar, FALSE, TRUE);
SetSubtitle(NULL);
}
if(IsWindow(m_wndCaptureBar.m_hWnd))
{
ShowControlBar(&m_wndCaptureBar, FALSE, TRUE);
m_wndCaptureBar.m_capdlg.SetupVideoControls(_T(""), NULL, NULL, NULL);
m_wndCaptureBar.m_capdlg.SetupAudioControls(_T(""), NULL, CInterfaceArray<IAMAudioInputMixer>());
}
RecalcLayout();
SetWindowText(ResStr(IDR_MAINFRAME));
SetAlwaysOnTop(AfxGetAppSettings().iOnTop);
// this will prevent any further UI updates on the dynamically added menu items
SetupFiltersSubMenu();
SetupAudioSwitcherSubMenu();
SetupSubtitlesSubMenu();
SetupNavAudioSubMenu();
SetupNavSubtitleSubMenu();
SetupNavAngleSubMenu();
SetupNavChaptersSubMenu();
SetupFavoritesSubMenu();
SendNowPlayingToMSN();
}
void CMainFrame::OnUpdateFilePostClosemedia(CCmdUI* pCmdUI)
{
pCmdUI->Enable(!!m_hWnd && m_iMediaLoadState == MLS_CLOSING);
}
void CMainFrame::OnBossKey()
{
SendMessage(WM_COMMAND, ID_PLAY_PAUSE);
if(m_fFullScreen) SendMessage(WM_COMMAND, ID_VIEW_FULLSCREEN);
SendMessage(WM_SYSCOMMAND, SC_MINIMIZE, -1);
}
void CMainFrame::OnStreamAudio(UINT nID)
{
nID -= ID_STREAM_AUDIO_NEXT;
if(m_iMediaLoadState != MLS_LOADED) return;
CComQIPtr<IAMStreamSelect> pSS = FindFilter(__uuidof(CAudioSwitcherFilter), pGB);
if(!pSS) pSS = FindFilter(L"{D3CD7858-971A-4838-ACEC-40CA5D529DC8}", pGB); // morgan's switcher
DWORD cStreams = 0;
if(pSS && SUCCEEDED(pSS->Count(&cStreams)) && cStreams > 1)
{
for(int i = 0; i < (int)cStreams; i++)
{
AM_MEDIA_TYPE* pmt = NULL;
DWORD dwFlags = 0;
LCID lcid = 0;
DWORD dwGroup = 0;
WCHAR* pszName = NULL;
if(FAILED(pSS->Info(i, &pmt, &dwFlags, &lcid, &dwGroup, &pszName, NULL, NULL)))
return;
if(pmt) DeleteMediaType(pmt);
if(pszName) CoTaskMemFree(pszName);
if(dwFlags&(AMSTREAMSELECTINFO_ENABLED|AMSTREAMSELECTINFO_EXCLUSIVE))
{
pSS->Enable((i+(nID==0?1:cStreams-1))%cStreams, AMSTREAMSELECTENABLE_ENABLE);
break;
}
}
}
else if(m_iPlaybackMode == PM_FILE) SendMessage(WM_COMMAND, ID_OGM_AUDIO_NEXT+nID);
else if(m_iPlaybackMode == PM_DVD) SendMessage(WM_COMMAND, ID_DVD_AUDIO_NEXT+nID);
}
void CMainFrame::OnStreamSub(UINT nID)
{
nID -= ID_STREAM_SUB_NEXT;
if(m_iMediaLoadState != MLS_LOADED) return;
int cnt = 0;
POSITION pos = m_pSubStreams.GetHeadPosition();
while(pos) cnt += m_pSubStreams.GetNext(pos)->GetStreamCount();
if(cnt > 1)
{
int i = ((m_iSubtitleSel&0x7fffffff)+(nID==0?1:cnt-1))%cnt;
m_iSubtitleSel = i | (m_iSubtitleSel&0x80000000);
UpdateSubtitle();
SetFocus();
}
else if(m_iPlaybackMode == PM_FILE) SendMessage(WM_COMMAND, ID_OGM_SUB_NEXT+nID);
else if(m_iPlaybackMode == PM_DVD) SendMessage(WM_COMMAND, ID_DVD_SUB_NEXT+nID);
}
void CMainFrame::OnStreamSubOnOff()
{
if(m_iMediaLoadState != MLS_LOADED) return;
int cnt = 0;
POSITION pos = m_pSubStreams.GetHeadPosition();
while(pos) cnt += m_pSubStreams.GetNext(pos)->GetStreamCount();
if(cnt > 0)
{
m_iSubtitleSel ^= 0x80000000;
UpdateSubtitle();
SetFocus();
}
else if(m_iPlaybackMode == PM_DVD) SendMessage(WM_COMMAND, ID_DVD_SUB_ONOFF);
}
void CMainFrame::OnOgmAudio(UINT nID)
{
nID -= ID_OGM_AUDIO_NEXT;
if(m_iMediaLoadState != MLS_LOADED) return;
CComQIPtr<IAMStreamSelect> pSS = FindFilter(CLSID_OggSplitter, pGB);
if(!pSS) pSS = FindFilter(L"{55DA30FC-F16B-49fc-BAA5-AE59FC65F82D}", pGB);
if(!pSS) return;
CArray<int> snds;
int iSel = -1;
DWORD cStreams = 0;
if(SUCCEEDED(pSS->Count(&cStreams)) && cStreams > 1)
{
for(int i = 0; i < (int)cStreams; i++)
{
AM_MEDIA_TYPE* pmt = NULL;
DWORD dwFlags = 0;
LCID lcid = 0;
DWORD dwGroup = 0;
WCHAR* pszName = NULL;
if(FAILED(pSS->Info(i, &pmt, &dwFlags, &lcid, &dwGroup, &pszName, NULL, NULL)))
return;
if(dwGroup == 1)
{
if(dwFlags&(AMSTREAMSELECTINFO_ENABLED|AMSTREAMSELECTINFO_EXCLUSIVE))
iSel = snds.GetCount();
snds.Add(i);
}
if(pmt) DeleteMediaType(pmt);
if(pszName) CoTaskMemFree(pszName);
}
int cnt = snds.GetCount();
if(cnt > 1 && iSel >= 0)
pSS->Enable(snds[(iSel+(nID==0?1:cnt-1))%cnt], AMSTREAMSELECTENABLE_ENABLE);
}
}
void CMainFrame::OnOgmSub(UINT nID)
{
nID -= ID_OGM_SUB_NEXT;
if(m_iMediaLoadState != MLS_LOADED) return;
CComQIPtr<IAMStreamSelect> pSS = FindFilter(CLSID_OggSplitter, pGB);
if(!pSS) pSS = FindFilter(L"{55DA30FC-F16B-49fc-BAA5-AE59FC65F82D}", pGB);
if(!pSS) return;
CArray<int> subs;
int iSel = -1;
DWORD cStreams = 0;
if(SUCCEEDED(pSS->Count(&cStreams)) && cStreams > 1)
{
for(int i = 0; i < (int)cStreams; i++)
{
AM_MEDIA_TYPE* pmt = NULL;
DWORD dwFlags = 0;
LCID lcid = 0;
DWORD dwGroup = 0;
WCHAR* pszName = NULL;
if(FAILED(pSS->Info(i, &pmt, &dwFlags, &lcid, &dwGroup, &pszName, NULL, NULL)))
return;
if(dwGroup == 2)
{
if(dwFlags&(AMSTREAMSELECTINFO_ENABLED|AMSTREAMSELECTINFO_EXCLUSIVE))
iSel = subs.GetCount();
subs.Add(i);
}
if(pmt) DeleteMediaType(pmt);
if(pszName) CoTaskMemFree(pszName);
}
int cnt = subs.GetCount();
if(cnt > 1 && iSel >= 0)
pSS->Enable(subs[(iSel+(nID==0?1:cnt-1))%cnt], AMSTREAMSELECTENABLE_ENABLE);
}
}
void CMainFrame::OnDvdAngle(UINT nID)
{
nID -= ID_DVD_ANGLE_NEXT;
if(m_iMediaLoadState != MLS_LOADED) return;
if(pDVDI && pDVDC)
{
ULONG ulAnglesAvailable, ulCurrentAngle;
if(SUCCEEDED(pDVDI->GetCurrentAngle(&ulAnglesAvailable, &ulCurrentAngle))
&& ulAnglesAvailable > 1)
{
pDVDC->SelectAngle(
(ulCurrentAngle+(nID==0?1:ulAnglesAvailable-1))%ulAnglesAvailable,
DVD_CMD_FLAG_Block, NULL);
}
}
}
void CMainFrame::OnDvdAudio(UINT nID)
{
nID -= ID_DVD_AUDIO_NEXT;
if(m_iMediaLoadState != MLS_LOADED) return;
if(pDVDI && pDVDC)
{
ULONG nStreamsAvailable, nCurrentStream;
if(SUCCEEDED(pDVDI->GetCurrentAudio(&nStreamsAvailable, &nCurrentStream))
&& nStreamsAvailable > 1)
{
pDVDC->SelectAudioStream(
(nCurrentStream+(nID==0?1:nStreamsAvailable-1))%nStreamsAvailable,
DVD_CMD_FLAG_Block, NULL);
}
}
}
void CMainFrame::OnDvdSub(UINT nID)
{
nID -= ID_DVD_SUB_NEXT;
if(m_iMediaLoadState != MLS_LOADED) return;
if(pDVDI && pDVDC)
{
ULONG ulStreamsAvailable, ulCurrentStream;
BOOL bIsDisabled;
if(SUCCEEDED(pDVDI->GetCurrentSubpicture(&ulStreamsAvailable, &ulCurrentStream, &bIsDisabled))
&& ulStreamsAvailable > 1)
{
pDVDC->SelectSubpictureStream(
(ulCurrentStream+(nID==0?1:ulStreamsAvailable-1))%ulStreamsAvailable,
DVD_CMD_FLAG_Block, NULL);
}
}
}
void CMainFrame::OnDvdSubOnOff()
{
if(m_iMediaLoadState != MLS_LOADED) return;
if(pDVDI && pDVDC)
{
ULONG ulStreamsAvailable, ulCurrentStream;
BOOL bIsDisabled;
if(SUCCEEDED(pDVDI->GetCurrentSubpicture(&ulStreamsAvailable, &ulCurrentStream, &bIsDisabled)))
{
pDVDC->SetSubpictureState(bIsDisabled, DVD_CMD_FLAG_Block, NULL);
}
}
}
//
// menu item handlers
//
// file
void CMainFrame::OnFileOpenmedia()
{
if(m_iMediaLoadState == MLS_LOADING || !IsWindow(m_wndPlaylistBar)) return;
COpenDlg dlg;
if(dlg.DoModal() != IDOK || dlg.m_fns.GetCount() == 0) return;
SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);
ShowWindow(SW_SHOW);
SetForegroundWindow();
m_wndPlaylistBar.Open(dlg.m_fns, dlg.m_fMultipleFiles);
if(m_wndPlaylistBar.GetCount() == 1 && m_wndPlaylistBar.IsWindowVisible() && !m_wndPlaylistBar.IsFloating())
{
ShowControlBar(&m_wndPlaylistBar, FALSE, TRUE);
}
OpenCurPlaylistItem();
}
void CMainFrame::OnUpdateFileOpen(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState != MLS_LOADING);
}
BOOL CMainFrame::OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCDS)
{
if(m_iMediaLoadState == MLS_LOADING || !IsWindow(m_wndPlaylistBar))
return FALSE;
if(pCDS->dwData != 0x6ABE51 || pCDS->cbData < sizeof(DWORD))
return FALSE;
DWORD len = *((DWORD*)pCDS->lpData);
TCHAR* pBuff = (TCHAR*)((DWORD*)pCDS->lpData + 1);
TCHAR* pBuffEnd = (TCHAR*)((BYTE*)pBuff + pCDS->cbData - sizeof(DWORD));
CList<CString> cmdln;
while(len-- > 0)
{
CString str;
while(pBuff < pBuffEnd && *pBuff) str += *pBuff++;
pBuff++;
cmdln.AddTail(str);
}
AppSettings& s = AfxGetAppSettings();
s.ParseCommandLine(cmdln);
POSITION pos = s.slFilters.GetHeadPosition();
while(pos)
{
CString fullpath = MakeFullPath(s.slFilters.GetNext(pos));
CPath tmp(fullpath);
tmp.RemoveFileSpec();
tmp.AddBackslash();
CString path = tmp;
WIN32_FIND_DATA fd = {0};
HANDLE hFind = FindFirstFile(fullpath, &fd);
if(hFind != INVALID_HANDLE_VALUE)
{
do
{
if(fd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) continue;
CFilterMapper2 fm2(false);
fm2.Register(path + fd.cFileName);
while(!fm2.m_filters.IsEmpty())
{
if(Filter* f = fm2.m_filters.RemoveTail())
{
f->fTemporary = true;
bool fFound = false;
POSITION pos2 = s.filters.GetHeadPosition();
while(pos2)
{
Filter* f2 = s.filters.GetNext(pos2);
if(f2->type == Filter::EXTERNAL && !f2->path.CompareNoCase(f->path))
{
fFound = true;
break;
}
}
if(!fFound)
{
CAutoPtr<Filter> p(f);
s.filters.AddHead(p);
}
}
}
}
while(FindNextFile(hFind, &fd));
FindClose(hFind);
}
}
bool fSetForegroundWindow = false;
if((s.nCLSwitches&CLSW_DVD) && !s.slFiles.IsEmpty())
{
SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);
fSetForegroundWindow = true;
CAutoPtr<OpenDVDData> p(new OpenDVDData());
if(p) {p->path = s.slFiles.GetHead(); p->subs.AddTail(&s.slSubs);}
OpenMedia(p);
}
else if(s.nCLSwitches&CLSW_CD)
{
SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);
fSetForegroundWindow = true;
CList<CString> sl;
if(!s.slFiles.IsEmpty())
{
GetCDROMType(s.slFiles.GetHead()[0], sl);
}
else
{
CString dir;
dir.ReleaseBufferSetLength(GetCurrentDirectory(MAX_PATH, dir.GetBuffer(MAX_PATH)));
GetCDROMType(dir[0], sl);
for(TCHAR drive = 'C'; sl.IsEmpty() && drive <= 'Z'; drive++)
{
GetCDROMType(drive, sl);
}
}
m_wndPlaylistBar.Open(sl, true);
OpenCurPlaylistItem();
}
else if(!s.slFiles.IsEmpty())
{
bool fMulti = s.slFiles.GetCount() > 1;
CList<CString> sl;
sl.AddTail((CList<CString>*)&s.slFiles);
if(!fMulti) sl.AddTail((CList<CString>*)&s.slDubs);
if((s.nCLSwitches&CLSW_ADD) && m_wndPlaylistBar.GetCount() > 0)
{
m_wndPlaylistBar.Append(sl, fMulti, &s.slSubs);
if(s.nCLSwitches&(CLSW_OPEN|CLSW_PLAY))
{
m_wndPlaylistBar.SetLast();
OpenCurPlaylistItem();
}
}
else
{
SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);
fSetForegroundWindow = true;
m_wndPlaylistBar.Open(sl, fMulti, &s.slSubs);
OpenCurPlaylistItem((s.nCLSwitches&CLSW_STARTVALID) ? s.rtStart : 0);
s.nCLSwitches &= ~CLSW_STARTVALID;
s.rtStart = 0;
}
}
else
{
s.nCLSwitches = CLSW_NONE;
}
if(fSetForegroundWindow && !(s.nCLSwitches&CLSW_NOFOCUS))
SetForegroundWindow();
s.nCLSwitches &= ~CLSW_NOFOCUS;
return TRUE;
}
void CMainFrame::OnFileOpendvd()
{
if(m_iMediaLoadState == MLS_LOADING) return;
SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);
SetForegroundWindow();
ShowWindow(SW_SHOW);
CAutoPtr<OpenDVDData> p(new OpenDVDData());
if(p)
{
AppSettings& s = AfxGetAppSettings();
if(s.fUseDVDPath && !s.sDVDPath.IsEmpty())
{
p->path = s.sDVDPath;
p->path.Replace('/', '\');
if(p->path[p->path.GetLength()-1] != '\') p->path += '\';
}
}
OpenMedia(p);
}
void CMainFrame::OnFileOpendevice()
{
if(m_iMediaLoadState == MLS_LOADING) return;
COpenCapDeviceDlg capdlg;
if(capdlg.DoModal() != IDOK)
return;
SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);
SetForegroundWindow();
ShowWindow(SW_SHOW);
m_wndPlaylistBar.Empty();
CAutoPtr<OpenDeviceData> p(new OpenDeviceData());
if(p) {p->DisplayName[0] = capdlg.m_vidstr; p->DisplayName[1] = capdlg.m_audstr;}
OpenMedia(p);
}
void CMainFrame::OnFileOpenCD(UINT nID)
{
nID -= ID_FILE_OPEN_CD_START;
nID++;
for(TCHAR drive = 'C'; drive <= 'Z'; drive++)
{
CList<CString> sl;
switch(GetCDROMType(drive, sl))
{
case CDROM_Audio:
case CDROM_VideoCD:
case CDROM_DVDVideo:
nID--;
break;
default:
break;
}
if(nID == 0)
{
SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);
SetForegroundWindow();
ShowWindow(SW_SHOW);
m_wndPlaylistBar.Open(sl, true);
OpenCurPlaylistItem();
break;
}
}
}
void CMainFrame::OnDropFiles(HDROP hDropInfo)
{
SetForegroundWindow();
if(m_wndPlaylistBar.IsWindowVisible())
{
m_wndPlaylistBar.OnDropFiles(hDropInfo);
return;
}
CList<CString> sl;
UINT nFiles = ::DragQueryFile(hDropInfo, (UINT)-1, NULL, 0);
for(UINT iFile = 0; iFile < nFiles; iFile++)
{
CString fn;
fn.ReleaseBuffer(::DragQueryFile(hDropInfo, iFile, fn.GetBuffer(MAX_PATH), MAX_PATH));
sl.AddTail(fn);
}
::DragFinish(hDropInfo);
if(!sl.IsEmpty())
{
m_wndPlaylistBar.Open(sl, true);
OpenCurPlaylistItem();
}
}
void CMainFrame::OnFileSaveas()
{
CString ext, in = m_wndPlaylistBar.GetCur(), out = in;
if(out.Find(_T("://")) < 0)
{
ext = CString(CPath(out).GetExtension()).MakeLower();
if(ext == _T(".cda")) out = out.Left(out.GetLength()-4) + _T(".wav");
else if(ext == _T(".ifo")) out = out.Left(out.GetLength()-4) + _T(".vob");
}
else
{
out.Empty();
}
CFileDialog fd(FALSE, 0, out,
OFN_EXPLORER|OFN_ENABLESIZING|OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT|OFN_PATHMUSTEXIST,
_T("All files (*.*)|*.*||"), this, 0);
if(fd.DoModal() != IDOK || !in.CompareNoCase(fd.GetPathName())) return;
CPath p(fd.GetPathName());
if(!ext.IsEmpty()) p.AddExtension(ext);
OAFilterState fs = State_Stopped;
pMC->GetState(0, &fs);
if(fs == State_Running) pMC->Pause();
CSaveDlg dlg(in, p);
dlg.DoModal();
if(fs == State_Running) pMC->Run();
}
void CMainFrame::OnUpdateFileSaveas(CCmdUI* pCmdUI)
{
if(m_iMediaLoadState != MLS_LOADED || m_iPlaybackMode != PM_FILE)
{
pCmdUI->Enable(FALSE);
return;
}
CString fn = m_wndPlaylistBar.GetCur();
CString ext = fn.Mid(fn.ReverseFind('.')+1).MakeLower();
if(fn.Find(_T("://")) >= 0)
{
pCmdUI->Enable(FALSE);
return;
}
if((GetVersion()&0x80000000) && (ext == _T("cda") || ext == _T("ifo")))
{
pCmdUI->Enable(FALSE);
return;
}
pCmdUI->Enable(TRUE);
}
bool CMainFrame::GetDIB(BYTE** ppData, long& size, bool fSilent)
{
if(!ppData) return false;
*ppData = NULL;
size = 0;
bool fNeedsToPause = !m_pCAP;
if(fNeedsToPause) fNeedsToPause = !IsVMR7InGraph(pGB);
if(fNeedsToPause) fNeedsToPause = !IsVMR9InGraph(pGB);
OAFilterState fs = GetMediaState();
if(!(m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly && (fs == State_Paused || fs == State_Running)))
return false;
if(fs == State_Running && fNeedsToPause)
{
pMC->Pause();
GetMediaState(); // wait for completion of the pause command
}
HRESULT hr;
CString errmsg;
do
{
if(m_pCAP)
{
hr = m_pCAP->GetDIB(NULL, (DWORD*)&size);
if(FAILED(hr)) {errmsg.Format(_T("GetDIB failed, hr = %08x"), hr); break;}
if(!(*ppData = new BYTE[size])) return false;
hr = m_pCAP->GetDIB(*ppData, (DWORD*)&size);
if(FAILED(hr)) {errmsg.Format(_T("GetDIB failed, hr = %08x"), hr); break;}
}
else
{
hr = pBV->GetCurrentImage(&size, NULL);
if(FAILED(hr) || size == 0) {errmsg.Format(_T("GetCurrentImage failed, hr = %08x"), hr); break;}
if(!(*ppData = new BYTE[size])) return false;
hr = pBV->GetCurrentImage(&size, (long*)*ppData);
if(FAILED(hr)) {errmsg.Format(_T("GetCurrentImage failed, hr = %08x"), hr); break;}
}
}
while(0);
if(!fSilent)
{
if(!errmsg.IsEmpty())
{
AfxMessageBox(errmsg, MB_OK);
}
}
if(fs == State_Running && GetMediaState() != State_Running)
{
pMC->Run();
}
return !!*ppData;
}
#include "jpeg.h"
void CMainFrame::SaveImage(LPCTSTR fn)
{
BYTE* pData = NULL;
long size = 0;
if(GetDIB(&pData, size))
{
CString ext = CString(CPath(fn).GetExtension()).MakeLower();
if(ext == _T(".bmp"))
{
if(FILE* f = _tfopen(fn, _T("wb")))
{
BITMAPINFO* bi = (BITMAPINFO*)pData;
BITMAPFILEHEADER bfh;
bfh.bfType = 'MB';
bfh.bfOffBits = sizeof(bfh) + sizeof(bi->bmiHeader);
bfh.bfSize = sizeof(bfh) + size;
bfh.bfReserved1 = bfh.bfReserved2 = 0;
if(bi->bmiHeader.biBitCount <= 8)
{
if(bi->bmiHeader.biClrUsed) bfh.bfOffBits += bi->bmiHeader.biClrUsed * sizeof(bi->bmiColors[0]);
else bfh.bfOffBits += (1 << bi->bmiHeader.biBitCount) * sizeof(bi->bmiColors[0]);
}
fwrite(&bfh, 1, sizeof(bfh), f);
fwrite(pData, 1, size, f);
fclose(f);
}
else
{
AfxMessageBox(_T("Cannot create file"), MB_OK);
}
}
else if(ext == _T(".jpg"))
{
CJpegEncoderFile(fn).Encode(pData);
}
delete [] pData;
CPath p(fn);
if(CDC* pDC = m_wndStatusBar.m_status.GetDC())
{
CRect r;
m_wndStatusBar.m_status.GetClientRect(r);
p.CompactPath(pDC->m_hDC, r.Width());
m_wndStatusBar.m_status.ReleaseDC(pDC);
}
SendStatusMessage((LPCTSTR)p, 3000);
}
}
static CString MakeSnapshotFileName()
{
CTime t = CTime::GetCurrentTime();
CString fn;
fn.Format(_T("snapshot%s%s"),
t.Format(_T("%Y%m%d%H%M%S")), AfxGetAppSettings().SnapShotExt);
return fn;
}
void CMainFrame::OnFileSaveImage()
{
AppSettings& s = AfxGetAppSettings();
CPath psrc(s.SnapShotPath);
psrc.Combine(s.SnapShotPath, MakeSnapshotFileName());
CFileDialog fd(FALSE, 0, (LPCTSTR)psrc,
OFN_EXPLORER|OFN_ENABLESIZING|OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT|OFN_PATHMUSTEXIST,
_T("Bitmaps (*.bmp)|*.bmp|Jpeg (*.jpg)|*.jpg||"), this, 0);
if(s.SnapShotExt == _T(".bmp")) fd.m_pOFN->nFilterIndex = 1;
else if(s.SnapShotExt == _T(".jpg")) fd.m_pOFN->nFilterIndex = 2;
if(fd.DoModal() != IDOK) return;
if(fd.m_pOFN->nFilterIndex == 1) s.SnapShotExt = _T(".bmp");
else if(fd.m_pOFN->nFilterIndex = 2) s.SnapShotExt = _T(".jpg");
CPath pdst(fd.GetPathName());
pdst.AddExtension(s.SnapShotExt);
CString path = (LPCTSTR)pdst;
pdst.RemoveFileSpec();
s.SnapShotPath = (LPCTSTR)pdst;
SaveImage(path);
}
void CMainFrame::OnFileSaveImageAuto()
{
CString fn;
fn.Format(_T("%s\%s"), AfxGetAppSettings().SnapShotPath, MakeSnapshotFileName());
SaveImage(fn);
}
void CMainFrame::OnUpdateFileSaveImage(CCmdUI* pCmdUI)
{
OAFilterState fs = GetMediaState();
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly
&& (fs == State_Paused || fs == State_Running));
}
void CMainFrame::OnFileConvert()
{
CConvertDlg().DoModal();
}
void CMainFrame::OnUpdateFileConvert(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
}
void CMainFrame::OnFileLoadsubtitles()
{
if(!m_pCAP)
{
AfxMessageBox(_T("To load subtitles you have change the video renderer type and reopen the file.n")
_T("- DirectShow: VMR7 or VMR9 renderlessn")
_T("- RealMedia: Special renderer for RealMedia, or open it through DirectShown")
_T("- Quicktime: DX7 or DX9 renderer for QuickTimen")
_T("- ShockWave: n/an")
, MB_OK);
return;
}
static TCHAR BASED_CODE szFilter[] =
_T(".srt .sub .ssa .ass .smi .psb .txt .idx .usf .xss|")
_T("*.srt;*.sub;*.ssa;*.ass;*smi;*.psb;*.txt;*.idx;*.usf;*.xss||");
CFileDialog fd(TRUE, NULL, NULL,
OFN_EXPLORER | OFN_ENABLESIZING | OFN_HIDEREADONLY,
szFilter, this, 0);
if(fd.DoModal() != IDOK) return;
if(LoadSubtitle(fd.GetPathName()))
SetSubtitle(m_pSubStreams.GetTail());
}
void CMainFrame::OnUpdateFileLoadsubtitles(CCmdUI *pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && /*m_pCAP &&*/ !m_fAudioOnly);
}
void CMainFrame::OnFileSavesubtitles()
{
int i = m_iSubtitleSel;
POSITION pos = m_pSubStreams.GetHeadPosition();
while(pos && i >= 0)
{
CComPtr<ISubStream> pSubStream = m_pSubStreams.GetNext(pos);
if(i < pSubStream->GetStreamCount())
{
CLSID clsid;
if(FAILED(pSubStream->GetClassID(&clsid)))
continue;
if(clsid == __uuidof(CVobSubFile))
{
CVobSubFile* pVSF = (CVobSubFile*)(ISubStream*)pSubStream;
CFileDialog fd(FALSE, NULL, NULL,
OFN_EXPLORER|OFN_ENABLESIZING|OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT|OFN_PATHMUSTEXIST,
_T("VobSub (*.idx, *.sub)|*.idx;*.sub||"), this, 0);
if(fd.DoModal() == IDOK)
{
CAutoLock cAutoLock(&m_csSubLock);
pVSF->Save(fd.GetPathName());
}
return;
}
else if(clsid == __uuidof(CRenderedTextSubtitle))
{
CRenderedTextSubtitle* pRTS = (CRenderedTextSubtitle*)(ISubStream*)pSubStream;
CString filter;
filter += _T("Subripper (*.srt)|*.srt|");
filter += _T("Microdvd (*.sub)|*.sub|");
filter += _T("Sami (*.smi)|*.smi|");
filter += _T("Psb (*.psb)|*.psb|");
filter += _T("Sub Station Alpha (*.ssa)|*.ssa|");
filter += _T("Advanced Sub Station Alpha (*.ass)|*.ass|");
filter += _T("|");
CSaveTextFileDialog fd(pRTS->m_encoding, NULL, NULL, filter, this);
if(fd.DoModal() == IDOK)
{
CAutoLock cAutoLock(&m_csSubLock);
pRTS->SaveAs(fd.GetPathName(), (exttype)(fd.m_ofn.nFilterIndex-1), m_pCAP->GetFPS(), fd.GetEncoding());
}
return;
}
}
i -= pSubStream->GetStreamCount();
}
}
void CMainFrame::OnUpdateFileSavesubtitles(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_iSubtitleSel >= 0);
}
///////////////
#include "SubtitleDlDlg.h"
#include "ISDb.h"
void CMainFrame::OnSubtitledatabaseSearch()
{
CStringA url = "http://" + AfxGetAppSettings().ISDb + "/index.php?";
CStringA args = makeargs(m_wndPlaylistBar.m_pl);
ShellExecute(m_hWnd, _T("open"), CString(url+args), NULL, NULL, SW_SHOWDEFAULT);
}
void CMainFrame::OnUpdateSubtitledatabaseSearch(CCmdUI *pCmdUI)
{
pCmdUI->Enable(TRUE);
}
void CMainFrame::OnSubtitledatabaseUpload()
{
CStringA url = "http://" + AfxGetAppSettings().ISDb + "/ul.php?";
CStringA args = makeargs(m_wndPlaylistBar.m_pl);
ShellExecute(m_hWnd, _T("open"), CString(url+args), NULL, NULL, SW_SHOWDEFAULT);
}
void CMainFrame::OnUpdateSubtitledatabaseUpload(CCmdUI *pCmdUI)
{
pCmdUI->Enable(m_wndPlaylistBar.GetCount() > 0);
}
void CMainFrame::OnSubtitledatabaseDownload()
{
filehash fh;
if(!hash(m_wndPlaylistBar.GetCur(), fh))
{
MessageBeep(-1);
return;
}
// TODO: put this on a worker thread
CStringA url = "http://" + AfxGetAppSettings().ISDb + "/index.php?";
CStringA args;
args.Format("player=mpc&name[0]=%s&size[0]=%016I64x&hash[0]=%016I64x",
UrlEncode(CStringA(fh.name)), fh.size, fh.hash);
try
{
CInternetSession is;
CStringA str;
if(!OpenUrl(is, CString(url+args), str))
{
MessageBeep(-1);
return;
}
CStringA ticket;
CList<isdb_movie> movies;
isdb_movie m;
isdb_subtitle s;
CList<CStringA> sl;
Explode(str, sl, 'n');
POSITION pos = sl.GetHeadPosition();
while(pos)
{
str = sl.GetNext(pos);
CStringA param = str.Left(max(0, str.Find('=')));
CStringA value = str.Mid(str.Find('=')+1);
if(param == "ticket") ticket = value;
else if(param == "movie") {m.reset(); Explode(value, m.titles, '|');}
else if(param == "subtitle") {s.reset(); s.id = atoi(value);}
else if(param == "name") s.name = value;
else if(param == "discs") s.discs = atoi(value);
else if(param == "disc_no") s.disc_no = atoi(value);
else if(param == "format") s.format = value;
else if(param == "iso639_2") s.iso639_2 = value;
else if(param == "language") s.language = value;
else if(param == "nick") s.nick = value;
else if(param == "email") s.email = value;
else if(param == "" && value == "endsubtitle") {m.subs.AddTail(s);}
else if(param == "" && value == "endmovie") {movies.AddTail(m);}
else if(param == "" && value == "end") break;
}
CSubtitleDlDlg dlg(movies, this);
if(IDOK == dlg.DoModal())
{
if(dlg.m_fReplaceSubs)
m_pSubStreams.RemoveAll();
CComPtr<ISubStream> pSubStreamToSet;
POSITION pos = dlg.m_selsubs.GetHeadPosition();
while(pos)
{
isdb_subtitle& s = dlg.m_selsubs.GetNext(pos);
CStringA url = "http://" + AfxGetAppSettings().ISDb + "/dl.php?";
CStringA args;
args.Format("id=%d&ticket=%s", s.id, UrlEncode(ticket));
if(OpenUrl(is, CString(url+args), str))
{
CAutoPtr<CRenderedTextSubtitle> pRTS(new CRenderedTextSubtitle(&m_csSubLock));
if(pRTS && pRTS->Open((BYTE*)(LPCSTR)str, str.GetLength(), DEFAULT_CHARSET, CString(s.name)) && pRTS->GetStreamCount() > 0)
{
CComPtr<ISubStream> pSubStream = pRTS.Detach();
m_pSubStreams.AddTail(pSubStream);
if(!pSubStreamToSet) pSubStreamToSet = pSubStream;
}
}
}
if(pSubStreamToSet)
SetSubtitle(pSubStreamToSet);
}
}
catch(CInternetException* ie)
{
ie->Delete();
return;
}
}
void CMainFrame::OnUpdateSubtitledatabaseDownload(CCmdUI *pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && m_pCAP && !m_fAudioOnly);
}
void CMainFrame::OnFileProperties()
{
CPPageFileInfoSheet m_fileinfo(m_wndPlaylistBar.GetCur(), this);
m_fileinfo.DoModal();
}
void CMainFrame::OnUpdateFileProperties(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && m_iPlaybackMode == PM_FILE);
}
void CMainFrame::OnFileCloseMedia()
{
CloseMedia();
}
void CMainFrame::OnFileClosePlaylist()
{
SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);
RestoreDefaultWindowRect();
}
void CMainFrame::OnUpdateFileClose(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED || m_iMediaLoadState == MLS_LOADING);
}
// view
void CMainFrame::OnViewCaptionmenu()
{
bool fHideCaptionMenu = AfxGetAppSettings().fHideCaptionMenu;
AfxGetAppSettings().fHideCaptionMenu = !fHideCaptionMenu;
if(m_fFullScreen) return;
DWORD dwRemove = 0, dwAdd = 0;
HMENU hMenu;
if(!fHideCaptionMenu)
{
dwRemove = WS_CAPTION;
hMenu = NULL;
}
else
{
dwAdd = WS_CAPTION;
hMenu = m_hMenuDefault;
}
ModifyStyle(dwRemove, dwAdd, SWP_NOZORDER);
::SetMenu(m_hWnd, hMenu);
SetWindowPos(NULL, 0, 0, 0, 0, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER);
MoveVideoWindow();
}
void CMainFrame::OnUpdateViewCaptionmenu(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck(!AfxGetAppSettings().fHideCaptionMenu);
}
void CMainFrame::OnViewControlBar(UINT nID)
{
nID -= ID_VIEW_SEEKER;
ShowControls(AfxGetAppSettings().nCS ^ (1<<nID));
}
void CMainFrame::OnUpdateViewControlBar(CCmdUI* pCmdUI)
{
UINT nID = pCmdUI->m_nID - ID_VIEW_SEEKER;
pCmdUI->SetCheck(!!(AfxGetAppSettings().nCS & (1<<nID)));
}
void CMainFrame::OnViewSubresync()
{
ShowControlBar(&m_wndSubresyncBar, !m_wndSubresyncBar.IsWindowVisible(), TRUE);
}
void CMainFrame::OnUpdateViewSubresync(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck(m_wndSubresyncBar.IsWindowVisible());
pCmdUI->Enable(m_pCAP && m_iSubtitleSel >= 0);
}
void CMainFrame::OnViewPlaylist()
{
ShowControlBar(&m_wndPlaylistBar, !m_wndPlaylistBar.IsWindowVisible(), TRUE);
}
void CMainFrame::OnUpdateViewPlaylist(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck(m_wndPlaylistBar.IsWindowVisible());
pCmdUI->Enable(m_iMediaLoadState == MLS_CLOSED && m_iMediaLoadState != MLS_LOADED
|| m_iMediaLoadState == MLS_LOADED /*&& (m_iPlaybackMode == PM_FILE || m_iPlaybackMode == PM_CAPTURE)*/);
}
void CMainFrame::OnViewCapture()
{
ShowControlBar(&m_wndCaptureBar, !m_wndCaptureBar.IsWindowVisible(), TRUE);
}
void CMainFrame::OnUpdateViewCapture(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck(m_wndCaptureBar.IsWindowVisible());
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && m_iPlaybackMode == PM_CAPTURE);
}
void CMainFrame::OnViewMinimal()
{
if(!AfxGetAppSettings().fHideCaptionMenu)
SendMessage(WM_COMMAND, ID_VIEW_CAPTIONMENU);
ShowControls(0);
}
void CMainFrame::OnUpdateViewMinimal(CCmdUI* pCmdUI)
{
}
void CMainFrame::OnViewCompact()
{
if(AfxGetAppSettings().fHideCaptionMenu)
SendMessage(WM_COMMAND, ID_VIEW_CAPTIONMENU);
ShowControls(CS_TOOLBAR);
}
void CMainFrame::OnUpdateViewCompact(CCmdUI* pCmdUI)
{
}
void CMainFrame::OnViewNormal()
{
if(AfxGetAppSettings().fHideCaptionMenu)
SendMessage(WM_COMMAND, ID_VIEW_CAPTIONMENU);
ShowControls(CS_SEEKBAR|CS_TOOLBAR|CS_STATUSBAR|CS_INFOBAR);
}
void CMainFrame::OnUpdateViewNormal(CCmdUI* pCmdUI)
{
}
void CMainFrame::OnViewFullscreen()
{
ToggleFullscreen(true, true);
}
void CMainFrame::OnViewFullscreenSecondary()
{
ToggleFullscreen(true, false);
}
void CMainFrame::OnUpdateViewFullscreen(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly || m_fFullScreen);
pCmdUI->SetCheck(m_fFullScreen);
}
void CMainFrame::OnViewZoom(UINT nID)
{
ZoomVideoWindow(nID == ID_VIEW_ZOOM_50 ? 0.5 : nID == ID_VIEW_ZOOM_200 ? 2.0 : 1.0);
}
void CMainFrame::OnUpdateViewZoom(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly);
}
void CMainFrame::OnViewDefaultVideoFrame(UINT nID)
{
AfxGetAppSettings().iDefaultVideoSize = nID - ID_VIEW_VF_HALF;
m_ZoomX = m_ZoomY = 1;
m_PosX = m_PosY = 0.5;
MoveVideoWindow();
}
void CMainFrame::OnUpdateViewDefaultVideoFrame(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly);
pCmdUI->SetRadio(AfxGetAppSettings().iDefaultVideoSize == (pCmdUI->m_nID - ID_VIEW_VF_HALF));
}
void CMainFrame::OnViewKeepaspectratio()
{
AfxGetAppSettings().fKeepAspectRatio = !AfxGetAppSettings().fKeepAspectRatio;
MoveVideoWindow();
}
void CMainFrame::OnUpdateViewKeepaspectratio(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly);
pCmdUI->SetCheck(AfxGetAppSettings().fKeepAspectRatio);
}
void CMainFrame::OnViewCompMonDeskARDiff()
{
AfxGetAppSettings().fCompMonDeskARDiff = !AfxGetAppSettings().fCompMonDeskARDiff;
MoveVideoWindow();
}
void CMainFrame::OnUpdateViewCompMonDeskARDiff(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly);
pCmdUI->SetCheck(AfxGetAppSettings().fCompMonDeskARDiff);
}
void CMainFrame::OnViewPanNScan(UINT nID)
{
if(m_iMediaLoadState != MLS_LOADED) return;
int x = 0, y = 0;
int dx = 0, dy = 0;
switch(nID)
{
case ID_VIEW_RESET: m_ZoomX = m_ZoomY = 1.0; m_PosX = m_PosY = 0.5; m_AngleX = m_AngleY = m_AngleZ = 0; break;
case ID_VIEW_INCSIZE: x = y = 1; break;
case ID_VIEW_DECSIZE: x = y = -1; break;
case ID_VIEW_INCWIDTH: x = 1; break;
case ID_VIEW_DECWIDTH: x = -1; break;
case ID_VIEW_INCHEIGHT: y = 1; break;
case ID_VIEW_DECHEIGHT: y = -1; break;
case ID_PANSCAN_CENTER: m_PosX = m_PosY = 0.5; break;
case ID_PANSCAN_MOVELEFT: dx = -1; break;
case ID_PANSCAN_MOVERIGHT: dx = 1; break;
case ID_PANSCAN_MOVEUP: dy = -1; break;
case ID_PANSCAN_MOVEDOWN: dy = 1; break;
case ID_PANSCAN_MOVEUPLEFT: dx = dy = -1; break;
case ID_PANSCAN_MOVEUPRIGHT: dx = 1; dy = -1; break;
case ID_PANSCAN_MOVEDOWNLEFT: dx = -1; dy = 1; break;
case ID_PANSCAN_MOVEDOWNRIGHT: dx = dy = 1; break;
default: break;
}
if(x > 0 && m_ZoomX < 3) m_ZoomX *= 1.02;
if(x < 0 && m_ZoomX > 0.2) m_ZoomX /= 1.02;
if(y > 0 && m_ZoomY < 3) m_ZoomY *= 1.02;
if(y < 0 && m_ZoomY > 0.2) m_ZoomY /= 1.02;
if(dx < 0 && m_PosX > 0) m_PosX = max(m_PosX - 0.005*m_ZoomX, 0);
if(dx > 0 && m_PosX < 1) m_PosX = min(m_PosX + 0.005*m_ZoomX, 1);
if(dy < 0 && m_PosY > 0) m_PosY = max(m_PosY - 0.005*m_ZoomY, 0);
if(dy > 0 && m_PosY < 1) m_PosY = min(m_PosY + 0.005*m_ZoomY, 1);
MoveVideoWindow(true);
if(nID == ID_VIEW_RESET && m_pCAP)
{
m_pCAP->SetVideoAngle(Vector(DegToRad(m_AngleX), DegToRad(m_AngleY), DegToRad(m_AngleZ)));
}
}
void CMainFrame::OnUpdateViewPanNScan(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly);
}
void CMainFrame::OnViewPanNScanPresets(UINT nID)
{
if(m_iMediaLoadState != MLS_LOADED) return;
AppSettings& s = AfxGetAppSettings();
nID -= ID_PANNSCAN_PRESETS_START;
if(nID == s.m_pnspresets.GetCount())
{
CPnSPresetsDlg dlg;
dlg.m_pnspresets.Copy(s.m_pnspresets);
if(dlg.DoModal() == IDOK)
{
s.m_pnspresets.Copy(dlg.m_pnspresets);
s.UpdateData(true);
}
return;
}
m_PosX = 0.5;
m_PosY = 0.5;
m_ZoomX = 1.0;
m_ZoomY = 1.0;
CString str = s.m_pnspresets[nID];
int i = 0, j = 0;
for(CString token = str.Tokenize(_T(","), i); !token.IsEmpty(); token = str.Tokenize(_T(","), i), j++)
{
float f = 0;
if(_stscanf(token, _T("%f"), &f) != 1) continue;
switch(j)
{
case 0: break;
case 1: m_PosX = f; break;
case 2: m_PosY = f; break;
case 3: m_ZoomX = f; break;
case 4: m_ZoomY = f; break;
default: break;
}
}
if(j != 5) return;
m_PosX = min(max(m_PosX, 0), 1);
m_PosY = min(max(m_PosY, 0), 1);
m_ZoomX = min(max(m_ZoomX, 0.2), 3);
m_ZoomY = min(max(m_ZoomY, 0.2), 3);
MoveVideoWindow(true);
}
void CMainFrame::OnUpdateViewPanNScanPresets(CCmdUI* pCmdUI)
{
int nID = pCmdUI->m_nID - ID_PANNSCAN_PRESETS_START;
AppSettings& s = AfxGetAppSettings();
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly && nID >= 0 && nID <= s.m_pnspresets.GetCount());
}
void CMainFrame::OnViewRotate(UINT nID)
{
if(!m_pCAP) return;
switch(nID)
{
case ID_PANSCAN_ROTATEXP: m_AngleX += 2; break;
case ID_PANSCAN_ROTATEXM: m_AngleX -= 2; break;
case ID_PANSCAN_ROTATEYP: m_AngleY += 2; break;
case ID_PANSCAN_ROTATEYM: m_AngleY -= 2; break;
case ID_PANSCAN_ROTATEZP: m_AngleZ += 2; break;
case ID_PANSCAN_ROTATEZM: m_AngleZ -= 2; break;
default: return;
}
m_pCAP->SetVideoAngle(Vector(DegToRad(m_AngleX), DegToRad(m_AngleY), DegToRad(m_AngleZ)));
CString info;
info.Format(_T("x: %d, y: %d, z: %d"), m_AngleX, m_AngleY, m_AngleZ);
SendStatusMessage(info, 3000);
}
void CMainFrame::OnUpdateViewRotate(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly && m_pCAP);
}
void CMainFrame::OnViewAspectRatio(UINT nID)
{
CSize& ar = AfxGetAppSettings().AspectRatio;
switch(nID)
{
default: ar.SetSize(0, 0); break;
case ID_ASPECTRATIO_4: ar.SetSize(4, 3); break;
case ID_ASPECTRATIO_5: ar.SetSize(5, 4); break;
case ID_ASPECTRATIO_16: ar.SetSize(16, 9); break;
}
CString info;
if(ar.cx && ar.cy) info.Format(_T("Aspect Ratio: %d:%d"), ar.cx, ar.cy);
else info.Format(_T("Aspect Ratio: Default"));
SendStatusMessage(info, 3000);
MoveVideoWindow();
}
void CMainFrame::OnUpdateViewAspectRatio(CCmdUI* pCmdUI)
{
const CSize& ar = AfxGetAppSettings().AspectRatio;
switch(pCmdUI->m_nID)
{
default: pCmdUI->SetRadio(ar == CSize(0, 0)); break;
case ID_ASPECTRATIO_4: pCmdUI->SetRadio(ar == CSize(4, 3)); break;
case ID_ASPECTRATIO_5: pCmdUI->SetRadio(ar == CSize(5, 4)); break;
case ID_ASPECTRATIO_16: pCmdUI->SetRadio(ar == CSize(16, 9)); break;
}
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly);
}
void CMainFrame::OnViewOntop(UINT nID)
{
nID -= ID_ONTOP_NEVER;
if(AfxGetAppSettings().iOnTop == nID)
nID = !nID;
SetAlwaysOnTop(nID);
}
void CMainFrame::OnUpdateViewOntop(CCmdUI* pCmdUI)
{
pCmdUI->SetRadio(AfxGetAppSettings().iOnTop == (pCmdUI->m_nID - ID_ONTOP_NEVER));
}
void CMainFrame::OnViewOptions()
{
ShowOptions();
}
// play
void CMainFrame::OnPlayPlay()
{
if(m_iMediaLoadState == MLS_LOADED)
{
if(GetMediaState() == State_Stopped) m_iSpeedLevel = 0;
if(m_iPlaybackMode == PM_FILE)
{
if(m_fEndOfStream) SendMessage(WM_COMMAND, ID_PLAY_STOP);
pMC->Run();
}
else if(m_iPlaybackMode == PM_DVD)
{
double dRate = 1.0;
if(m_iSpeedLevel != -4 && m_iSpeedLevel != 0)
dRate = pow(2.0, m_iSpeedLevel >= -3 ? m_iSpeedLevel : (-m_iSpeedLevel - 8));
pDVDC->PlayForwards(dRate, DVD_CMD_FLAG_Block, NULL);
pDVDC->Pause(FALSE);
pMC->Run();
}
else if(m_iPlaybackMode == PM_CAPTURE)
{
pMC->Stop(); // audio preview won't be in sync if we run it from paused state
pMC->Run();
}
SetTimer(TIMER_STREAMPOSPOLLER, 40, NULL);
SetTimer(TIMER_STREAMPOSPOLLER2, 500, NULL);
SetTimer(TIMER_STATS, 1000, NULL);
if(m_fFrameSteppingActive) // FIXME
{
m_fFrameSteppingActive = false;
pBA->put_Volume(m_VolumeBeforeFrameStepping);
}
SetAlwaysOnTop(AfxGetAppSettings().iOnTop);
}
MoveVideoWindow();
}
void CMainFrame::OnPlayPause()
{
if(m_iMediaLoadState == MLS_LOADED)
{
SetAlwaysOnTop(AfxGetAppSettings().iOnTop);
if(m_iPlaybackMode == PM_FILE)
{
pMC->Pause();
}
else if(m_iPlaybackMode == PM_DVD)
{
pMC->Pause();
}
else if(m_iPlaybackMode == PM_CAPTURE)
{
pMC->Pause();
}
SetTimer(TIMER_STREAMPOSPOLLER, 40, NULL);
SetTimer(TIMER_STREAMPOSPOLLER2, 500, NULL);
SetTimer(TIMER_STATS, 1000, NULL);
}
MoveVideoWindow();
}
void CMainFrame::OnPlayPlaypause()
{
OAFilterState fs = GetMediaState();
if(fs == State_Running) SendMessage(WM_COMMAND, ID_PLAY_PAUSE);
else if(fs == State_Stopped || fs == State_Paused) SendMessage(WM_COMMAND, ID_PLAY_PLAY);
}
void CMainFrame::OnPlayStop()
{
if(m_iMediaLoadState == MLS_LOADED)
{
if(m_iPlaybackMode == PM_FILE)
{
LONGLONG pos = 0;
pMS->SetPositions(&pos, AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);
pMC->Stop();
// BUG: after pause or stop the netshow url source filter won't continue
// on the next play command, unless we cheat it by setting the file name again.
//
// Note: WMPx may be using some undocumented interface to restart streaming.
BeginEnumFilters(pGB, pEF, pBF)
{
CComQIPtr<IAMNetworkStatus, &IID_IAMNetworkStatus> pAMNS = pBF;
CComQIPtr<IFileSourceFilter> pFSF = pBF;
if(pAMNS && pFSF)
{
WCHAR* pFN = NULL;
AM_MEDIA_TYPE mt;
if(SUCCEEDED(pFSF->GetCurFile(&pFN, &mt)) && pFN && *pFN)
{
pFSF->Load(pFN, NULL);
CoTaskMemFree(pFN);
}
break;
}
}
EndEnumFilters
}
else if(m_iPlaybackMode == PM_DVD)
{
pDVDC->SetOption(DVD_ResetOnStop, TRUE);
pMC->Stop();
pDVDC->SetOption(DVD_ResetOnStop, FALSE);
}
else if(m_iPlaybackMode == PM_CAPTURE)
{
pMC->Stop();
}
m_iSpeedLevel = 0;
if(m_fFrameSteppingActive) // FIXME
{
m_fFrameSteppingActive = false;
pBA->put_Volume(m_VolumeBeforeFrameStepping);
}
m_fEndOfStream = false;
}
m_nLoops = 0;
if(m_hWnd)
{
KillTimer(TIMER_STREAMPOSPOLLER2);
KillTimer(TIMER_STREAMPOSPOLLER);
KillTimer(TIMER_STATS);
MoveVideoWindow();
if(m_iMediaLoadState == MLS_LOADED)
{
__int64 start, stop;
m_wndSeekBar.GetRange(start, stop);
GUID tf;
pMS->GetTimeFormat(&tf);
m_wndStatusBar.SetStatusTimer(m_wndSeekBar.GetPosReal(), stop, !!m_wndSubresyncBar.IsWindowVisible(), &tf);
SetAlwaysOnTop(AfxGetAppSettings().iOnTop);
}
}
}
void CMainFrame::OnUpdatePlayPauseStop(CCmdUI* pCmdUI)
{
OAFilterState fs = m_fFrameSteppingActive ? State_Paused : GetMediaState();
pCmdUI->SetCheck(fs == State_Running && pCmdUI->m_nID == ID_PLAY_PLAY
|| fs == State_Paused && pCmdUI->m_nID == ID_PLAY_PAUSE
|| fs == State_Stopped && pCmdUI->m_nID == ID_PLAY_STOP
|| (fs == State_Paused || fs == State_Running) && pCmdUI->m_nID == ID_PLAY_PLAYPAUSE);
bool fEnable = false;
if(fs >= 0)
{
if(m_iPlaybackMode == PM_FILE || m_iPlaybackMode == PM_CAPTURE)
{
fEnable = true;
if(fs == State_Stopped && pCmdUI->m_nID == ID_PLAY_PAUSE && m_fRealMediaGraph) fEnable = false; // can't go into paused state from stopped with rm
else if(m_fCapturing) fEnable = false;
else if(m_fLiveWM && pCmdUI->m_nID == ID_PLAY_PAUSE) fEnable = false;
}
else if(m_iPlaybackMode == PM_DVD)
{
fEnable = m_iDVDDomain != DVD_DOMAIN_VideoManagerMenu
&& m_iDVDDomain != DVD_DOMAIN_VideoTitleSetMenu;
if(fs == State_Stopped && pCmdUI->m_nID == ID_PLAY_PAUSE) fEnable = false;
}
}
pCmdUI->Enable(fEnable);
}
void CMainFrame::OnPlayFramestep(UINT nID)
{
REFERENCE_TIME rt;
if(pFS && m_fQuicktimeGraph)
{
if(GetMediaState() != State_Paused)
SendMessage(WM_COMMAND, ID_PLAY_PAUSE);
pFS->Step(nID == ID_PLAY_FRAMESTEP ? 1 : -1, NULL);
}
else if(pFS && nID == ID_PLAY_FRAMESTEP)
{
if(GetMediaState() != State_Paused)
SendMessage(WM_COMMAND, ID_PLAY_PAUSE);
m_fFrameSteppingActive = true;
m_VolumeBeforeFrameStepping = m_wndToolBar.Volume;
pBA->put_Volume(-10000);
pFS->Step(1, NULL);
}
else if(S_OK == pMS->IsFormatSupported(&TIME_FORMAT_FRAME))
{
if(GetMediaState() != State_Paused)
SendMessage(WM_COMMAND, ID_PLAY_PAUSE);
pMS->SetTimeFormat(&TIME_FORMAT_FRAME);
pMS->GetCurrentPosition(&rt);
if(nID == ID_PLAY_FRAMESTEP) rt++;
else if(nID == ID_PLAY_FRAMESTEPCANCEL) rt--;
pMS->SetPositions(&rt, AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);
pMS->SetTimeFormat(&TIME_FORMAT_MEDIA_TIME);
}
}
void CMainFrame::OnUpdatePlayFramestep(CCmdUI* pCmdUI)
{
bool fEnable = false;
if(m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly
&& (m_iPlaybackMode != PM_DVD || m_iDVDDomain == DVD_DOMAIN_Title)
&& m_iPlaybackMode != PM_CAPTURE
&& !m_fLiveWM)
{
REFTIME AvgTimePerFrame = 0;
if(S_OK == pMS->IsFormatSupported(&TIME_FORMAT_FRAME)
|| pCmdUI->m_nID == ID_PLAY_FRAMESTEP && pFS && pFS->CanStep(0, NULL) == S_OK
|| m_fQuicktimeGraph && pFS)
{
fEnable = true;
}
}
pCmdUI->Enable(fEnable);
}
void CMainFrame::OnPlaySeek(UINT nID)
{
AppSettings& s = AfxGetAppSettings();
REFERENCE_TIME dt =
nID == ID_PLAY_SEEKBACKWARDSMALL ? -10000i64*s.nJumpDistS :
nID == ID_PLAY_SEEKFORWARDSMALL ? +10000i64*s.nJumpDistS :
nID == ID_PLAY_SEEKBACKWARDMED ? -10000i64*s.nJumpDistM :
nID == ID_PLAY_SEEKFORWARDMED ? +10000i64*s.nJumpDistM :
nID == ID_PLAY_SEEKBACKWARDLARGE ? -10000i64*s.nJumpDistL :
nID == ID_PLAY_SEEKFORWARDLARGE ? +10000i64*s.nJumpDistL :
0;
if(!dt) return;
// HACK: the custom graph should support frame based seeking instead
if(m_fShockwaveGraph) dt /= 10000i64*100;
SeekTo(m_wndSeekBar.GetPos() + dt);
}
static int rangebsearch(REFERENCE_TIME val, CArray<REFERENCE_TIME>& rta)
{
int i = 0, j = rta.GetSize() - 1, ret = -1;
if(j >= 0 && val >= rta[j]) return(j);
while(i < j)
{
int mid = (i + j) >> 1;
REFERENCE_TIME midt = rta[mid];
if(val == midt) {ret = mid; break;}
else if(val < midt) {ret = -1; if(j == mid) mid--; j = mid;}
else if(val > midt) {ret = mid; if(i == mid) mid++; i = mid;}
}
return(ret);
}
void CMainFrame::OnPlaySeekKey(UINT nID)
{
if(m_kfs.GetCount() > 0)
{
HRESULT hr;
if(GetMediaState() == State_Stopped)
SendMessage(WM_COMMAND, ID_PLAY_PAUSE);
REFERENCE_TIME rtCurrent, rtDur;
hr = pMS->GetCurrentPosition(&rtCurrent);
hr = pMS->GetDuration(&rtDur);
int dec = 1;
int i = rangebsearch(rtCurrent, m_kfs);
if(i > 0) dec = (UINT)max(min(rtCurrent - m_kfs[i-1], 10000000), 0);
rtCurrent =
nID == ID_PLAY_SEEKKEYBACKWARD ? max(rtCurrent - dec, 0) :
nID == ID_PLAY_SEEKKEYFORWARD ? rtCurrent : 0;
i = rangebsearch(rtCurrent, m_kfs);
if(nID == ID_PLAY_SEEKKEYBACKWARD)
rtCurrent = m_kfs[max(i, 0)];
else if(nID == ID_PLAY_SEEKKEYFORWARD && i < m_kfs.GetCount()-1)
rtCurrent = m_kfs[i+1];
else
return;
hr = pMS->SetPositions(
&rtCurrent, AM_SEEKING_AbsolutePositioning|AM_SEEKING_SeekToKeyFrame,
NULL, AM_SEEKING_NoPositioning);
}
}
void CMainFrame::OnUpdatePlaySeek(CCmdUI* pCmdUI)
{
bool fEnable = false;
OAFilterState fs = GetMediaState();
if(m_iMediaLoadState == MLS_LOADED && (fs == State_Paused || fs == State_Running))
{
fEnable = true;
if(m_iPlaybackMode == PM_DVD && (m_iDVDDomain != DVD_DOMAIN_Title || fs != State_Running)) fEnable = false;
else if(m_iPlaybackMode == PM_CAPTURE) fEnable = false;
}
pCmdUI->Enable(fEnable);
}
void CMainFrame::OnPlayGoto()
{
if(m_iMediaLoadState != MLS_LOADED)
return;
REFTIME atpf = 0;
if(FAILED(pBV->get_AvgTimePerFrame(&atpf)) || atpf < 0)
{
atpf = 0;
BeginEnumFilters(pGB, pEF, pBF)
{
if(atpf > 0) break;
BeginEnumPins(pBF, pEP, pPin)
{
if(atpf > 0) break;
AM_MEDIA_TYPE mt;
pPin->ConnectionMediaType(&mt);
if(mt.majortype == MEDIATYPE_Video && mt.formattype == FORMAT_VideoInfo)
{
atpf = (REFTIME)((VIDEOINFOHEADER*)mt.pbFormat)->AvgTimePerFrame / 10000000i64;
}
else if(mt.majortype == MEDIATYPE_Video && mt.formattype == FORMAT_VideoInfo2)
{
atpf = (REFTIME)((VIDEOINFOHEADER2*)mt.pbFormat)->AvgTimePerFrame / 10000000i64;
}
}
EndEnumPins
}
EndEnumFilters
}
CGoToDlg dlg((int)(m_wndSeekBar.GetPos()/10000), atpf > 0 ? (float)(1.0/atpf) : 0);
if(IDOK != dlg.DoModal() || dlg.m_time < 0) return;
SeekTo(10000i64 * dlg.m_time);
}
void CMainFrame::OnUpdateGoto(CCmdUI* pCmdUI)
{
bool fEnable = false;
if(m_iMediaLoadState == MLS_LOADED)
{
fEnable = true;
if(m_iPlaybackMode == PM_DVD && m_iDVDDomain != DVD_DOMAIN_Title) fEnable = false;
else if(m_iPlaybackMode == PM_CAPTURE) fEnable = false;
}
pCmdUI->Enable(fEnable);
}
void CMainFrame::OnPlayChangeRate(UINT nID)
{
if(m_iMediaLoadState != MLS_LOADED)
return;
if(m_iPlaybackMode == PM_CAPTURE)
{
if(GetMediaState() != State_Running)
SendMessage(WM_COMMAND, ID_PLAY_PLAY);
long lChannelMin = 0, lChannelMax = 0;
pAMTuner->ChannelMinMax(&lChannelMin, &lChannelMax);
long lChannel = 0, lVivSub = 0, lAudSub = 0;
pAMTuner->get_Channel(&lChannel, &lVivSub, &lAudSub);
long lFreqOrg = 0, lFreqNew = -1;
pAMTuner->get_VideoFrequency(&lFreqOrg);
// long lSignalStrength;
do
{
if(nID == ID_PLAY_DECRATE) lChannel--;
else if(nID == ID_PLAY_INCRATE) lChannel++;
// if(lChannel < lChannelMin) lChannel = lChannelMax;
// if(lChannel > lChannelMax) lChannel = lChannelMin;
if(lChannel < lChannelMin || lChannel > lChannelMax)
break;
if(FAILED(pAMTuner->put_Channel(lChannel, AMTUNER_SUBCHAN_DEFAULT, AMTUNER_SUBCHAN_DEFAULT)))
break;
long flFoundSignal;
pAMTuner->AutoTune(lChannel, &flFoundSignal);
pAMTuner->get_VideoFrequency(&lFreqNew);
int i = 0;
}
while(FALSE);
/* SUCCEEDED(pAMTuner->SignalPresent(&lSignalStrength))
&& (lSignalStrength != AMTUNER_SIGNALPRESENT || lFreqNew == lFreqOrg));*/
}
else
{
int iNewSpeedLevel;
if(nID == ID_PLAY_INCRATE) iNewSpeedLevel = m_iSpeedLevel+1;
else if(nID == ID_PLAY_DECRATE) iNewSpeedLevel = m_iSpeedLevel-1;
else return;
HRESULT hr = E_FAIL;
if(iNewSpeedLevel == -4)
{
if(GetMediaState() != State_Paused)
SendMessage(WM_COMMAND, ID_PLAY_PAUSE);
if(GetMediaState() == State_Paused) hr = S_OK;
}
else
{
double dRate = pow(2.0, iNewSpeedLevel >= -3 ? iNewSpeedLevel : (-iNewSpeedLevel - 8));
if(fabs(dRate - 1.0) < 0.01) dRate = 1.0;
if(GetMediaState() != State_Running)
SendMessage(WM_COMMAND, ID_PLAY_PLAY);
if(m_iPlaybackMode == PM_FILE)
{
hr = pMS->SetRate(dRate);
}
else if(m_iPlaybackMode == PM_DVD)
{
if(iNewSpeedLevel >= -3)
hr = pDVDC->PlayForwards(dRate, DVD_CMD_FLAG_Block, NULL);
else
hr = pDVDC->PlayBackwards(dRate, DVD_CMD_FLAG_Block, NULL);
}
}
if(SUCCEEDED(hr))
m_iSpeedLevel = iNewSpeedLevel;
}
}
void CMainFrame::OnUpdatePlayChangeRate(CCmdUI* pCmdUI)
{
bool fEnable = false;
if(m_iMediaLoadState == MLS_LOADED)
{
bool fInc = pCmdUI->m_nID == ID_PLAY_INCRATE;
fEnable = true;
if(fInc && m_iSpeedLevel >= 3) fEnable = false;
else if(!fInc && m_iPlaybackMode == PM_FILE && m_iSpeedLevel <= -4) fEnable = false;
else if(!fInc && m_iPlaybackMode == PM_DVD && m_iSpeedLevel <= -11) fEnable = false;
else if(m_iPlaybackMode == PM_DVD && m_iDVDDomain != DVD_DOMAIN_Title) fEnable = false;
else if(m_fRealMediaGraph || m_fShockwaveGraph) fEnable = false;
else if(m_iPlaybackMode == PM_CAPTURE && (!m_wndCaptureBar.m_capdlg.IsTunerActive() || m_fCapturing)) fEnable = false;
else if(m_fLiveWM) fEnable = false;
}
pCmdUI->Enable(fEnable);
}
void CMainFrame::OnPlayResetRate()
{
if(m_iMediaLoadState != MLS_LOADED)
return;
HRESULT hr = E_FAIL;
if(GetMediaState() != State_Running)
SendMessage(WM_COMMAND, ID_PLAY_PLAY);
if(m_iPlaybackMode == PM_FILE)
{
hr = pMS->SetRate(1.0);
}
else if(m_iPlaybackMode == PM_DVD)
{
hr = pDVDC->PlayForwards(1.0, DVD_CMD_FLAG_Block, NULL);
}
if(SUCCEEDED(hr))
m_iSpeedLevel = 0;
}
void CMainFrame::OnUpdatePlayResetRate(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_iMediaLoadState == MLS_LOADED);
}
void CMainFrame::OnPlayChangeAudDelay(UINT nID)
{
if(CComQIPtr<IAudioSwitcherFilter> pAS = FindFilter(__uuidof(CAudioSwitcherFilter), pGB))
{
REFERENCE_TIME rtShift = pAS->GetAudioTimeShift();
rtShift +=
nID == ID_PLAY_INCAUDDELAY ? 100000 :
nID == ID_PLAY_DECAUDDELAY ? -100000 :
0;