Windows/Windows-classic-samples
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Windows-classic-samples/Samples/Win7Samples/multimedia/mediafoundation/topoedit/app/tedapp.cpp
Raten 12d6772ad2 new
2025-11-28 00:35:46 +09:00

2098 lines
53 KiB
C++
Raw Blame History

// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (c) Microsoft Corporation. All rights reserved
#include "stdafx.h"
#include "resource.h"
#include "tedapp.h"
#include "tedmaintoolbar.h"
#include "dock.h"
#include "mfapi.h"
#include "mferror.h"
#include "commdlg.h"
#include "splitterbar.h"
#include "tedtransformdialog.h"
#include "dmo.h"
#include "propertyview.h"
#include "tedinputguiddialog.h"
#include "Tedcontentprotectionmanager.h"
#include "tedplayer.h"
#include <initguid.h>
#include <mferror.h>
#include <uuids.h>
#include <Windowsx.h>
#include "tedtranscode.h"
#include <assert.h>
unsigned int CTedApp::MAIN_TOOLBAR_ID = 5000;
const int CTedApp::m_nSeekerRange = 100;
const UINT_PTR CTedApp::ms_nTimerID = 0;
const DWORD CTedApp::ms_dwTimerLen = 200;
const double CTedApp::m_dblInitialSplitterPos = 0.65;
///////////////////////////////////////////////////////////////////////////////
//
HINSTANCE g_hInst = NULL;
HINSTANCE g_hTedUtilInst = NULL;
CTedApp * g_pApp;
//////////////////////////////////
// CTedAppVideoWindowHandler
// Provides video windows to TEDUTIL.
CTedAppVideoWindowHandler::CTedAppVideoWindowHandler(HWND hWndParent)
: m_hWndParent(hWndParent)
, m_cRef(0)
{
}
CTedAppVideoWindowHandler::~CTedAppVideoWindowHandler()
{
for(size_t i = 0; i < m_arrWindows.GetCount(); i++)
{
if(m_arrWindows.GetAt(i)->m_hWnd) m_arrWindows.GetAt(i)->DestroyWindow();
delete m_arrWindows.GetAt(i);
}
}
HRESULT CTedAppVideoWindowHandler::GetVideoWindow(LONG_PTR* phWnd)
{
HRESULT hr = S_OK;
RECT rectLastWindow = {0, 0, 0, 0};
if(m_arrWindows.GetCount() >= 1)
{
m_arrWindows.GetAt(m_arrWindows.GetCount() - 1)->GetWindowRect(&rectLastWindow);
}
RECT rect;
rect.left = m_dwCascadeMargin + rectLastWindow.left;
rect.top = m_dwCascadeMargin + rectLastWindow.top;
rect.right = rect.left + m_dwDefaultWindowWidth;
rect.bottom = rect.top + m_dwDefaultWindowHeight;
if(NULL == phWnd)
{
IFC( E_POINTER );
}
CTedVideoWindow* pVideoWindow = new CTedVideoWindow();
if(pVideoWindow->Create(m_hWndParent, &rect, LoadAtlString(IDS_VIDEO_PLAYBACK), WS_CAPTION | WS_POPUPWINDOW, 0, 0U, NULL) == NULL)
{
IFC( HRESULT_FROM_WIN32(GetLastError()) );
}
*phWnd = (LONG_PTR) pVideoWindow->m_hWnd;
m_arrWindows.Add(pVideoWindow);
Cleanup:
return hr;
}
HRESULT CTedAppVideoWindowHandler::ReleaseVideoWindow(LONG_PTR hWnd)
{
for(size_t i = 0; i < m_arrWindows.GetCount(); ++i)
{
CTedVideoWindow* pWindow = m_arrWindows.GetAt(i);
if(pWindow->m_hWnd == (HWND) hWnd)
{
m_arrWindows.RemoveAt(i);
--i;
pWindow->DestroyWindow();
delete pWindow;
break;
}
}
return S_OK;
}
HRESULT CTedAppVideoWindowHandler::ShowWindows(int nCmdShow)
{
for(size_t i = 0; i < m_arrWindows.GetCount(); i++)
{
m_arrWindows.GetAt(i)->ShowWindow(nCmdShow);
}
return S_OK;
}
HRESULT CTedAppVideoWindowHandler::QueryInterface(REFIID riid, void** ppInterface)
{
if(NULL == ppInterface)
{
return E_POINTER;
}
HRESULT hr = S_OK;
if(riid == IID_IUnknown)
{
IUnknown* punk = this;
*ppInterface = punk;
AddRef();
}
else if(riid == IID_ITedVideoWindowHandler)
{
ITedVideoWindowHandler* ptvwh = this;
*ppInterface = ptvwh;
AddRef();
}
else
{
*ppInterface = NULL;
hr = E_NOINTERFACE;
}
return hr;
}
ULONG CTedAppVideoWindowHandler::AddRef()
{
LONG cRef = InterlockedIncrement(&m_cRef);
return cRef;
}
ULONG CTedAppVideoWindowHandler::Release()
{
LONG cRef = InterlockedDecrement(&m_cRef);
if(0 == cRef)
{
delete this;
}
return cRef;
}
///////////////////////////////////////////////////////////////////////////////
// CTedAppMediaEventHandler
// Decouples player from app class. Initiates application response to media events
CTedAppMediaEventHandler::CTedAppMediaEventHandler(CTedApp* pApp)
: m_pApp(pApp)
{
}
CTedAppTopoEventHandler::~CTedAppTopoEventHandler()
{
}
void CTedAppMediaEventHandler::NotifyEventError(HRESULT hr)
{
m_pApp->HandleMMError(LoadAtlString(IDS_E_MEDIA_EVENT), hr);
}
void CTedAppMediaEventHandler::HandleMediaEvent(IMFMediaEvent* pEvent)
{
HRESULT hr = S_OK;
MediaEventType met;
HRESULT hrEvent;
IFC( pEvent->GetType(&met) );
IFC( pEvent->GetStatus(&hrEvent) );
if(SUCCEEDED(hrEvent))
{
switch(met)
{
case MESessionStarted:
m_pApp->PostMessage(WM_MF_SESSIONPLAY, hrEvent, 0);
break;
case MESessionEnded:
m_pApp->PostMessage(WM_MF_SESSIONENDED, hrEvent, 0);
break;
case MESessionTopologySet:
m_pApp->PostMessage(WM_MF_TOPOLOGYSET, hrEvent, 0);
break;
case MESessionTopologyStatus:
{
UINT32 unTopoStatus = MFGetAttributeUINT32(pEvent, MF_EVENT_TOPOLOGY_STATUS, 0);
if(MF_TOPOSTATUS_READY == unTopoStatus)
{
m_pApp->PostMessage(WM_MF_TOPOLOGYREADY, hrEvent, 0);
}
}
break;
case MESessionCapabilitiesChanged:
m_pApp->PostMessageW(WM_MF_CAPABILITIES_CHANGED, hrEvent, 0);
break;
}
}
else
{
switch(met)
{
case MESessionStarted:
m_pApp->HandleMMError(LoadAtlString(IDS_E_PLAYBACK_START), hrEvent);
break;
case MESessionTopologySet:
m_pApp->PostMessage(WM_MF_TOPOLOGYSET, hrEvent, 0);
break;
case MESessionTopologiesCleared:
// This can fail if the session has been closed, but
// this is OK -- the session will still accept new topologies.
break;
default:
NotifyEventError(hrEvent);
}
}
Cleanup:
if(FAILED(hr))
{
NotifyEventError(hr);
}
}
//////////////////////////////////////////////////////////////////////////////
// CTedAppTopoEventHandler
// Receives event notifications from the topology editor
CTedAppTopoEventHandler::CTedAppTopoEventHandler(CTedApp* pApp)
: m_pApp(pApp)
{
}
HRESULT CTedAppTopoEventHandler::NotifyAddedNode(int nNodeID)
{
m_pApp->NotifyTopoChange();
return S_OK;
}
HRESULT CTedAppTopoEventHandler::NotifyRemovedNode(int nNodeID)
{
m_pApp->NotifyTopoChange();
return S_OK;
}
HRESULT CTedAppTopoEventHandler::NotifyConnection(int nUpNodeID, int nDownNodeID)
{
m_pApp->NotifyTopoChange();
return S_OK;
}
HRESULT CTedAppTopoEventHandler::NotifyDisconnection(int nUpNodeID, int nDownNodeID)
{
m_pApp->NotifyTopoChange();
return S_OK;
}
HRESULT CTedAppTopoEventHandler::QueryInterface(REFIID riid, void** ppInterface)
{
if(NULL == ppInterface)
{
return E_POINTER;
}
HRESULT hr = S_OK;
if(riid == IID_IUnknown)
{
IUnknown* punk = this;
*ppInterface = punk;
AddRef();
}
else if(riid == IID_ITedTopoEventHandler)
{
ITedTopoEventHandler* ptteh = this;
*ppInterface = ptteh;
AddRef();
}
else
{
*ppInterface = NULL;
hr = E_NOINTERFACE;
}
return hr;
}
ULONG CTedAppTopoEventHandler::AddRef()
{
LONG cRef = InterlockedIncrement(&m_cRef);
return cRef;
}
ULONG CTedAppTopoEventHandler::Release()
{
LONG cRef = InterlockedDecrement(&m_cRef);
if(0 == cRef)
{
delete this;
}
return cRef;
}
///////////////////////////////////////////////////////////////////////////////
//CTedChooserDialog
// Generic drop-down selection dialog
CTedChooserDialog::CTedChooserDialog(const CAtlString& strTitle)
: m_strTitle(strTitle)
{
}
void CTedChooserDialog::AddPossibleChoice(CAtlStringW strChoice)
{
m_arrChoices.Add(strChoice);
}
LRESULT CTedChooserDialog::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
SetWindowText(m_strTitle);
m_hChooserCombo = GetDlgItem(IDC_CHOOSER);
for(DWORD i = 0; i < m_arrChoices.GetCount(); i++)
{
::SendMessage(m_hChooserCombo, CB_ADDSTRING, 0, (LPARAM) m_arrChoices.GetAt(i).GetString());
}
return 0;
}
LRESULT CTedChooserDialog::OnOK(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr;
int comboLength = ::GetWindowTextLength(m_hChooserCombo);
LPWSTR strCombo = new WCHAR[comboLength + 1];
CHECK_ALLOC( strCombo );
::GetWindowText(m_hChooserCombo, strCombo, comboLength + 1);
m_strChoice = CAtlStringW(strCombo);
delete[] strCombo;
Cleanup:
EndDialog(IDOK);
return 0;
}
LRESULT CTedChooserDialog::OnCancel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
EndDialog(IDCANCEL);
return 0;
}
///////////////////////////////////////////////////////////////////////////////
//
LRESULT CTedAboutDialog::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
WCHAR szFileName[1024];
if ( !GetModuleFileName(g_hInst, szFileName, 1024) )
{
return GetLastError();
}
HANDLE hFile = CreateFile(szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if(NULL == hFile)
{
return GetLastError();
}
FILETIME LastModifiedTime;
if( !GetFileTime(hFile, NULL, NULL, &LastModifiedTime) )
{
CloseHandle(hFile);
return GetLastError();
}
CloseHandle(hFile);
SYSTEMTIME SystemTime;
if( !FileTimeToSystemTime(&LastModifiedTime, &SystemTime) )
{
return GetLastError();
}
SYSTEMTIME LocalTime;
if( !SystemTimeToTzSpecificLocalTime(NULL, &SystemTime, &LocalTime) )
{
return GetLastError();
}
WCHAR szVersion[10];
if( 0 == LoadString(g_hInst, IDS_VERSION, szVersion, 10) )
{
return GetLastError();
}
CAtlString strVersion;
strVersion.FormatMessage(IDS_APP_VERSION, szVersion, LocalTime.wMonth, LocalTime.wDay, LocalTime.wYear);
SetDlgItemText(IDS_VERSION, strVersion.GetString());
return 0;
}
///////////////////////////////////////////////////////////////////////////////
//
CAtlString CTedInputURLDialog::GetURL()
{
return m_strURL;
}
LRESULT CTedInputURLDialog::OnOK(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr;
HWND hInputURLWnd = GetDlgItem(IDC_INPUTURL);
int iTextLength = ::GetWindowTextLength(hInputURLWnd);
LPWSTR szURL = new WCHAR[iTextLength + 1];
CHECK_ALLOC( szURL );
::GetWindowText(hInputURLWnd, szURL, iTextLength + 1);
m_strURL.SetString(szURL);
delete[] szURL;
Cleanup:
EndDialog(IDOK);
return 0;
}
///////////////////////////////////////////////////////////////////////////////
//
CTedCaptureSourceDialog::CTedCaptureSourceDialog( bool bVideo )
: m_ppSourceActivates( NULL )
, m_dwActivates( 0 )
, m_dwSelectedIndex( 0 )
{
EnumCaptureSources( bVideo );
}
CTedCaptureSourceDialog::~CTedCaptureSourceDialog()
{
//
// Cleanup
//
if ( m_ppSourceActivates )
{
for ( DWORD i = 0; i < m_dwActivates; i++ )
{
m_ppSourceActivates[ i ]->Release();
}
CoTaskMemFree( m_ppSourceActivates );
}
}
IMFActivate* CTedCaptureSourceDialog::GetSourceActivate()
{
IMFActivate* pActivate = NULL;
if ( ( NULL != m_ppSourceActivates ) &&
( m_dwSelectedIndex < m_dwActivates ) )
{
pActivate = m_ppSourceActivates[ m_dwSelectedIndex ];
pActivate ->AddRef();
}
return pActivate;
}
LRESULT CTedCaptureSourceDialog::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
//
// Fill in the dropdown values based on enumerated activates
//
for ( DWORD i = 0; i < m_dwActivates; i++ )
{
UINT32 nLen = 0;
WCHAR* pwsz = NULL;
HRESULT hr = S_OK;
//
// Get the friendly name
//
hr = m_ppSourceActivates[ i ]->GetStringLength( MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME,
&nLen );
if ( SUCCEEDED( hr ) )
{
pwsz = new WCHAR[ nLen + 1 ];
if ( pwsz == NULL )
{
hr = E_OUTOFMEMORY;
}
}
if ( SUCCEEDED( hr ) )
{
hr = m_ppSourceActivates[ i ]->GetString( MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME,
pwsz,
nLen + 1,
&nLen );
}
//
// Add to the dropdown
//
if ( SUCCEEDED( hr ) )
{
ComboBox_AddString( GetDlgItem( IDC_COMBOSOURCES ), pwsz );
}
else
{
ComboBox_AddString( GetDlgItem( IDC_COMBOSOURCES ), TEXT("Capture Source") );
}
if ( pwsz )
{
delete[] pwsz;
}
}
if ( m_dwActivates != 0 )
{
//
// Preselect the first one
//
ComboBox_SetCurSel( GetDlgItem( IDC_COMBOSOURCES ), 0 );
}
return 0;
}
LRESULT CTedCaptureSourceDialog::OnOK(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
m_dwSelectedIndex = ComboBox_GetCurSel( GetDlgItem( IDC_COMBOSOURCES ) );
EndDialog(IDOK);
return 0;
}
HRESULT CTedCaptureSourceDialog::EnumCaptureSources( bool bVideo )
{
HRESULT hr = S_OK;
IMFAttributes* pAttributes = NULL;
//
// Set source type GUID to indicate video capture devices
//
hr = MFCreateAttributes( &pAttributes, 10 );
if ( SUCCEEDED( hr ) )
{
if ( bVideo )
{
hr = pAttributes->SetGUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID );
}
else
{
hr = pAttributes->SetGUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_GUID );
}
}
//
// Enumerate the capture sources
//
if ( SUCCEEDED( hr ) )
{
hr = MFEnumDeviceSources( pAttributes,
&m_ppSourceActivates,
(UINT32*)&m_dwActivates );
}
//
// Cleanup
//
if ( pAttributes )
{
pAttributes->Release();
}
return hr;
}
///////////////////////////////////////////////////////////////////////////////
//CTedApp
// Main application window controller
CTedApp::CTedApp()
: m_pPlayer(NULL)
, m_pVideoWindowHandler(NULL)
, m_pTopoEventHandler(NULL)
, m_pMediaEventHandler(NULL)
, m_pCPM(NULL)
, m_pPropertyController(NULL)
, m_pDock(NULL)
, m_pSplitter(NULL)
, m_pMainToolbar(NULL)
, m_fMergeRequired(false)
, m_fResolved(false)
, m_fPendingPlay(false)
, m_fStopTrackingUntilSessionStarted(false)
, m_pPendingTopo(NULL)
, m_pTopoView(NULL)
, m_fCanSeek(false)
{
CoInitializeEx( NULL, COINIT_MULTITHREADED );
if(FAILED(MFStartup( MF_VERSION )))
{
assert(false);
}
}
CTedApp::~CTedApp()
{
if(m_pTopoView)
{
m_pTopoView->CloseTopoWindow();
m_pTopoView->Release();
}
if(m_pVideoWindowHandler) m_pVideoWindowHandler->Release();
if(m_pTopoEventHandler) m_pTopoEventHandler->Release();
if(m_pPropertyController) m_pPropertyController->Release();
if(m_pCPM) m_pCPM->Release();
delete m_pMainToolbar;
delete m_pDock;
delete m_pSplitter;
delete m_pPlayer;
delete m_pPropSplitter;
delete m_pMediaEventHandler;
if(m_pPendingTopo) m_pPendingTopo->Release();
MFShutdown();
CoUninitialize();
}
HRESULT CTedApp::Init(LPCWSTR lpCmdLine)
{
HRESULT hr = S_OK;
// create window
m_hMenu = LoadMenu(g_hInst, MAKEINTRESOURCE(IDC_TRV));
if(m_hMenu == NULL)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
if(Create(NULL, NULL, LoadAtlString(IDS_WDW_NAME), WS_OVERLAPPEDWINDOW, 0, m_hMenu, NULL) == NULL)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
if(lpCmdLine && lpCmdLine[0] != 0)
{
LoadFile(lpCmdLine);
}
Cleanup:
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_APP_INIT), hr);
}
return hr;
}
void CTedApp::HandleMMError(const CAtlStringW& message, HRESULT errResult)
{
m_MFErrorHandler.HandleMFError(message, errResult);
}
void CTedApp::NotifySplitterMoved()
{
// No processing currently needed after splitter movement
}
void CTedApp::NotifyTopoChange()
{
m_pMainToolbar->MarkResolved(false);
m_fResolved = false;
}
void CTedApp::HandleSeekerScroll(WORD wPos)
{
HRESULT hr = S_OK;
if(m_pPlayer && m_pPlayer->IsPlaying() && m_fCanSeek)
{
MFTIME duration;
IFC( m_pPlayer->GetDuration(duration) );
MFTIME seekTime = (wPos * duration) / m_nSeekerRange;
IFC( m_pPlayer->PlayFrom(seekTime) );
m_fStopTrackingUntilSessionStarted = true;
}
Cleanup:
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_PLAY_MEDIA), hr);
}
}
void CTedApp::HandleRateScroll(WORD wPos)
{
HRESULT hr = S_OK;
if(m_pPlayer && m_pPlayer->IsTopologySet())
{
float flRate = wPos / 10.0f;
if(flRate != 0)
{
hr = m_pPlayer->SetRate(flRate);
}
m_pMainToolbar->UpdateRateDisplay(flRate);
}
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_PLAY_RATE), hr);
}
}
LRESULT CTedApp::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HRESULT hr = S_OK;
RECT rect;
RECT toolRect;
m_pMediaEventHandler = new CTedAppMediaEventHandler(this);
CHECK_ALLOC( m_pMediaEventHandler );
// create toolbar
m_pMainToolbar = new CTedMainToolbar();
CHECK_ALLOC( m_pMainToolbar );
IFC( m_pMainToolbar->Init(m_hWnd, MAIN_TOOLBAR_ID) );
m_pMainToolbar->SetTrackbarScrollCallback(&HandleSeekerScrollFunc);
m_pMainToolbar->GetRateBar()->SetScrollCallback(&HandleRateScrollFunc);
m_pMainToolbar->ShowRateBar(SW_HIDE);
m_pMainToolbar->GetClientRect(&toolRect);
GetClientRect(&rect);
rect.top = toolRect.bottom;
rect.bottom = rect.bottom - 100;
m_pDock = new CDock;
CHECK_ALLOC( m_pDock );
if(m_pDock->Create(m_hWnd, rect, LoadAtlString(IDS_DOCK), WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE) == NULL)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
ZeroMemory(&rect, sizeof(rect));
m_pSplitter = new CSplitterBar(m_pDock, false, m_hWnd);
CHECK_ALLOC( m_pSplitter );
if(m_pSplitter->Create(m_pDock->m_hWnd, &rect, LoadAtlString(IDS_SPLITTER)) == NULL)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
m_pPropSplitter = new CSplitterBar(m_pDock, true, m_hWnd);
CHECK_ALLOC( m_pPropSplitter );
if(m_pPropSplitter->Create(m_pDock->m_hWnd, &rect, LoadAtlString(IDS_SPLITTER), WS_CHILD | WS_CLIPSIBLINGS) == NULL)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
rect.top += 5;
CPropertyEditWindow* pPropView = new CPropertyEditWindow();
CHECK_ALLOC( pPropView );
if(pPropView->Create(m_pDock->m_hWnd, rect, LoadAtlString(IDS_PROP_VIEW), WS_CHILD | WS_BORDER | WS_VISIBLE) == NULL)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
m_pCPM = new CTedContentProtectionManager(this);
CHECK_ALLOC( m_pCPM );
m_pCPM->AddRef();
m_pPlayer = new CTedPlayer(m_pMediaEventHandler, m_pCPM);
CHECK_ALLOC( m_pPlayer );
m_pVideoWindowHandler = new CTedAppVideoWindowHandler(m_hWnd);
CHECK_ALLOC( m_pVideoWindowHandler );
m_pVideoWindowHandler->AddRef();
m_pTopoEventHandler = new CTedAppTopoEventHandler(this);
CHECK_ALLOC( m_pTopoEventHandler );
m_pTopoEventHandler->AddRef();
m_pPropertyController = new CPropertyController(pPropView);
CHECK_ALLOC( m_pPropertyController );
m_pPropertyController->AddRef();
IFC( TEDCreateTopoViewer(m_pVideoWindowHandler, m_pPropertyController, m_pTopoEventHandler, &m_pTopoView) );
IFC( m_pTopoView->CreateTopoWindow(LoadAtlString(IDS_WDW_TOPOVIEW), WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, (LONG_PTR) m_pDock->m_hWnd, (LONG_PTR*) &m_hEditWnd) );
m_EditWindow.Attach(m_hEditWnd);
RebuildDockWithOneView();
m_MFErrorHandler.SetParentWnd(m_hWnd);
HICON hIcon = ::LoadIcon(g_hInst, MAKEINTRESOURCE(IDI_TRV));
SetIcon(hIcon, TRUE);
SetIcon(hIcon, FALSE);
EnableInput(ID_PLAY_PLAY, TRUE);
Cleanup:
return (LRESULT) hr;
}
LRESULT CTedApp::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
PostQuitMessage(0);
return 0;
}
LRESULT CTedApp::OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
return 0;
}
LRESULT CTedApp::OnMediaCapabilitiesChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
DWORD dwCaps;
m_pPlayer->GetCapabilities(&dwCaps);
if(dwCaps & MFSESSIONCAP_SEEK)
{
m_fCanSeek = true;
}
else
{
m_fCanSeek = false;
}
return 0;
}
LRESULT CTedApp::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
m_pMainToolbar->SetWindowPos(NULL, 0, 0, LOWORD(lParam), 30,
SWP_NOZORDER | SWP_NOREDRAW);
m_pDock->SetWindowPos(NULL, 0, 30, LOWORD(lParam), HIWORD(lParam) - 30,
SWP_NOZORDER | SWP_NOREDRAW);
return 0;
}
LRESULT CTedApp::OnSessionPlay(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HRESULT hr = (HRESULT) wParam;
KillTimer(ms_nTimerID);
if(SUCCEEDED(hr))
{
SetTimer(ms_nTimerID, ms_dwTimerLen, NULL);
}
m_fStopTrackingUntilSessionStarted = false;
return 0;
}
LRESULT CTedApp::OnTopologySet(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HRESULT hrTopologySet = (HRESULT) wParam;
HandleTopologySet(hrTopologySet);
return 0;
}
LRESULT CTedApp::OnTopologyReady(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HRESULT hr;
float flSlowest, flFastest;
hr = m_pPlayer->GetRateBounds(MFRATE_FORWARD, &flSlowest, &flFastest);
if(FAILED(hr) || flSlowest == 0.0f && flFastest == 0.0f)
{
m_pMainToolbar->ShowRateBar(SW_HIDE);
}
else
{
m_pMainToolbar->ShowRateBar(SW_SHOW);
m_pMainToolbar->GetRateBar()->SetRange(DWORD(flSlowest * 10), DWORD(flFastest * 10));
m_pMainToolbar->GetRateBar()->SetPos(10);
m_pMainToolbar->GetRateBar()->SendMessage(TBM_CLEARTICS, 0, 0);
for(DWORD dwTicPos = 10; dwTicPos < flFastest * 10; dwTicPos += 10)
{
m_pMainToolbar->GetRateBar()->SendMessage(TBM_SETTIC, 0, dwTicPos);
}
}
return 0;
}
LRESULT CTedApp::OnSessionEnded(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
m_pVideoWindowHandler->ShowWindows(SW_HIDE);
EnableInput(ID_PLAY_PLAY, TRUE);
EnableInput(ID_PLAY_STOP, FALSE);
EnableInput(ID_PLAY_PAUSE, FALSE);
MFTIME duration;
m_pPlayer->GetDuration(duration);
m_pMainToolbar->UpdateTimeDisplay(0, duration);
KillTimer(ms_nTimerID);
return 0;
}
LRESULT CTedApp::OnSplitterMoved(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
NotifySplitterMoved();
return 0;
}
LRESULT CTedApp::OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
if(wParam == ms_nTimerID)
{
if(m_pPlayer->IsPlaying())
{
MFTIME time, duration;
HRESULT hr = m_pPlayer->GetTime(&time);
HRESULT hr2 = m_pPlayer->GetDuration(duration);
if(SUCCEEDED(hr) && SUCCEEDED(hr2) && !m_fStopTrackingUntilSessionStarted)
{
m_pMainToolbar->UpdateTimeDisplay(time, duration);
}
}
}
SetTimer(ms_nTimerID, ms_dwTimerLen, NULL);
return 0;
}
LRESULT CTedApp::OnUntrustedComponent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
MessageBox(LoadAtlString(IDS_E_UNTRUSTED_COMPONENTS), NULL, MB_OK);
return 0;
}
LRESULT CTedApp::OnProtectedContent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HRESULT hr = m_pCPM->ManualEnableContent();
if(FAILED(hr))
{
m_MFErrorHandler.HandleMFError(LoadAtlString(IDS_E_MANUAL_LICENSE), hr);
}
return 0;
}
LRESULT CTedApp::OnIndividualization(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HRESULT hr = m_pCPM->Individualize();
if(FAILED(hr))
{
m_MFErrorHandler.HandleMFError(LoadAtlString(IDS_E_PROT_CONTENT_PLAYBACK), hr);
}
return 0;
}
void CTedApp::HandleTopologySet(HRESULT hrTopologySet)
{
assert(m_pPlayer != NULL);
CComPtr<IMFTopology> spFullTopo;
CAtlStringW strTime;
HRESULT hr = S_OK;
if(FAILED(hrTopologySet))
{
// We failed to set the topology; merge the old topology
m_pTopoView->MergeTopology(m_pPendingTopo);
HandleMMError(LoadAtlString(IDS_E_TOPO_RESOLUTION), hrTopologySet);
m_fPendingPlay = false;
return;
}
if(m_fMergeRequired)
{
hr = m_pPlayer->GetFullTopology(&spFullTopo);
if(spFullTopo != NULL)
{
TOPOID TopoID = 0;
spFullTopo->GetTopologyID(&TopoID);
// Ensure this is the topology that was most recently set on the player
if(TopoID == m_PendingTopoID)
{
m_fMergeRequired = false;
hr = m_pTopoView->MergeTopology(spFullTopo);
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_TOPO_MERGE), hr);
}
else
{
m_pMainToolbar->MarkResolved(true);
m_fResolved = true;
if(m_fPendingPlay)
{
hr = Play();
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_TOPO_PLAY), hr);
}
}
}
}
}
else
{
HandleMMError(LoadAtlString(IDS_E_TOPO_RETRIEVE), hr);
}
}
MFTIME duration = 0;
m_pPlayer->GetDuration(duration);
m_pMainToolbar->UpdateTimeDisplay(0, duration);
m_fPendingPlay = false;
}
LRESULT CTedApp::OnLoad(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
CAtlString strFilter = LoadAtlString(IDS_FILE_XML);
CAtlString strTitle = LoadAtlString(IDS_FILE_LOAD);
strFilter.SetAt(strFilter.GetLength()-1,0); // force double-null termination
strFilter.SetAt(strFilter.GetLength()-2,0);
TCHAR fileBuffer[m_dwMaxAcceptedFileNameLength];
fileBuffer[0] = 0;
OPENFILENAME openFileInfo;
openFileInfo.lStructSize = sizeof(OPENFILENAME);
openFileInfo.hwndOwner = m_hWnd;
openFileInfo.hInstance = 0;
openFileInfo.lpstrFilter = strFilter;
openFileInfo.lpstrCustomFilter = NULL;
openFileInfo.nFilterIndex = 1;
openFileInfo.lpstrFile = fileBuffer;
openFileInfo.nMaxFile = m_dwMaxAcceptedFileNameLength;
openFileInfo.lpstrFileTitle = NULL;
openFileInfo.nMaxFileTitle = 0;
openFileInfo.lpstrInitialDir = NULL;
openFileInfo.lpstrTitle = strTitle;
openFileInfo.Flags = 0;
openFileInfo.nFileOffset = 0;
openFileInfo.nFileExtension = 0;
openFileInfo.lpstrDefExt = NULL;
openFileInfo.lCustData = NULL;
openFileInfo.pvReserved = NULL;
openFileInfo.dwReserved = 0;
openFileInfo.FlagsEx = 0;
if(GetOpenFileName(&openFileInfo))
{
LoadFile(openFileInfo.lpstrFile);
}
return 0;
}
LRESULT CTedApp::OnSave(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
CAtlString strFilter = LoadAtlString(IDS_FILE_XML);
CAtlString strTitle = LoadAtlString(IDS_FILE_SAVE);
strFilter.SetAt(strFilter.GetLength()-1,0); // force double-null termination
strFilter.SetAt(strFilter.GetLength()-2,0);
TCHAR fileBuffer[m_dwMaxAcceptedFileNameLength];
fileBuffer[0] = 0;
OPENFILENAME openFileInfo;
openFileInfo.lStructSize = sizeof(OPENFILENAME);
openFileInfo.hwndOwner = m_hWnd;
openFileInfo.hInstance = 0;
openFileInfo.lpstrFilter = strFilter;
openFileInfo.lpstrCustomFilter = NULL;
openFileInfo.nFilterIndex = 1;
openFileInfo.lpstrFile = fileBuffer;
openFileInfo.nMaxFile = m_dwMaxAcceptedFileNameLength;
openFileInfo.lpstrFileTitle = NULL;
openFileInfo.nMaxFileTitle = 0;
openFileInfo.lpstrInitialDir = NULL;
openFileInfo.lpstrTitle = strTitle;
openFileInfo.Flags = 0;
openFileInfo.nFileOffset = 0;
openFileInfo.nFileExtension = 0;
openFileInfo.lpstrDefExt = L"XML";
openFileInfo.lCustData = NULL;
openFileInfo.pvReserved = NULL;
openFileInfo.dwReserved = 0;
openFileInfo.FlagsEx = 0;
if(GetSaveFileName(&openFileInfo))
{
HRESULT hr = m_pTopoView->SaveTopology(openFileInfo.lpstrFile);
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_FILE_SAVE), hr);
}
}
return 0;
}
LRESULT CTedApp::OnDelete(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
m_pTopoView->DeleteSelectedNode();
bHandled = TRUE;
return 0;
}
LRESULT CTedApp::OnNewTopology(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
BOOL fIsSaved = FALSE;
m_pTopoView->IsSaved(&fIsSaved);
if(!fIsSaved)
{
int iMBResult = MessageBox(LoadAtlString(IDS_TOPO_NOT_SAVED), LoadAtlString(IDS_TOPO_NEW), MB_YESNO);
if(iMBResult == IDNO) return 0;
}
m_pTopoView->NewTopology();
ResetInterface();
return 0;
}
LRESULT CTedApp::OnAddSource(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
CAtlString strFilter = LoadAtlString(IDS_FILE_MEDIA);
CAtlString strTitle = LoadAtlString(IDS_FILE_SELECT);
strFilter.SetAt(strFilter.GetLength()-1,0); // force double-null termination
strFilter.SetAt(strFilter.GetLength()-2,0);
TCHAR fileBuffer[m_dwMaxAcceptedFileNameLength];
fileBuffer[0] = 0;
OPENFILENAME openFileInfo;
openFileInfo.lStructSize = sizeof(OPENFILENAME);
openFileInfo.hwndOwner = m_hWnd;
openFileInfo.hInstance = 0;
openFileInfo.lpstrFilter = strFilter;
openFileInfo.lpstrCustomFilter = NULL;
openFileInfo.nFilterIndex = 1;
openFileInfo.lpstrFile = fileBuffer;
openFileInfo.nMaxFile = m_dwMaxAcceptedFileNameLength;
openFileInfo.lpstrFileTitle = NULL;
openFileInfo.nMaxFileTitle = 0;
openFileInfo.lpstrInitialDir = NULL;
openFileInfo.lpstrTitle = strTitle;
openFileInfo.Flags = OFN_FILEMUSTEXIST;
openFileInfo.nFileOffset = 0;
openFileInfo.nFileExtension = 0;
openFileInfo.lpstrDefExt = NULL;
openFileInfo.lCustData = NULL;
openFileInfo.pvReserved = NULL;
openFileInfo.dwReserved = 0;
openFileInfo.FlagsEx = 0;
if(GetOpenFileName(&openFileInfo))
{
HRESULT hr = m_pTopoView->AddSource(openFileInfo.lpstrFile);
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_SOURCE_CREATE), hr);
}
}
bHandled = TRUE;
return 0;
}
LRESULT CTedApp::OnAddSink(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) {
// For future use
return 0;
}
LRESULT CTedApp::OnAddSAR(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = m_pTopoView->AddSAR();
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_AUDIO_RENDERER_CREATE), hr);
}
bHandled = TRUE;
return 0;
}
LRESULT CTedApp::OnAddEVR(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = m_pTopoView->AddEVR();
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_VIDEO_RENDERER_CREATE), hr);
}
bHandled = TRUE;
return 0;
}
LRESULT CTedApp::OnAddTransform(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
CTedTransformDialog transformDialog;
if(transformDialog.DoModal() == IDOK)
{
hr = m_pTopoView->AddTransformActivate(transformDialog.GetChosenActivate());
}
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_TRANSFORM_CREATE), hr);
}
bHandled = TRUE;
return 0;
}
LRESULT CTedApp::OnAddTee(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = m_pTopoView->AddTee();
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_TEE_CREATE), hr);
}
bHandled = TRUE;
return 0;
}
LRESULT CTedApp::OnAddCustomMFT(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
CTedInputGuidDialog dialog;
HRESULT hr = S_OK;
if(dialog.DoModal() == IDOK)
{
GUID gidTransID = dialog.GetInputGuid();
hr = m_pTopoView->AddTransform(gidTransID, LoadAtlString(IDS_MFT_CUSTOM));
}
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_TRANSFORM_CREATE), hr);
}
return 0;
}
LRESULT CTedApp::OnAddCustomSink(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
CTedInputGuidDialog dialog;
HRESULT hr = S_OK;
if(dialog.DoModal() == IDOK)
{
GUID gidSinkID = dialog.GetInputGuid();
hr = m_pTopoView->AddCustomSink(gidSinkID);
}
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_SINK_CREATE), hr);
}
return 0;
}
LRESULT CTedApp::OnAddVideoCaptureSource(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
IMFMediaSource* pSource = NULL;
CTedCaptureSourceDialog dialog( true );
if ( dialog.DoModal() == IDOK )
{
IMFActivate* pActivate = dialog.GetSourceActivate();
if ( pActivate )
{
hr = pActivate->ActivateObject( IID_IMFMediaSource, (void**)&pSource );
if ( SUCCEEDED( hr ) )
{
hr = m_pTopoView->AddCaptureSource( pSource );
}
}
if ( pActivate )
{
pActivate->Release();
}
}
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_VIDEO_CAP_SOURCE_CREATE), hr);
}
return 0;
}
LRESULT CTedApp::OnAddAudioCaptureSource(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
IMFMediaSource* pSource = NULL;
CTedCaptureSourceDialog dialog( false );
if ( dialog.DoModal() == IDOK )
{
IMFActivate* pActivate = dialog.GetSourceActivate();
if ( pActivate )
{
hr = pActivate->ActivateObject( IID_IMFMediaSource, (void**)&pSource );
if ( SUCCEEDED( hr ) )
{
hr = m_pTopoView->AddCaptureSource( pSource );
}
}
if ( pActivate )
{
pActivate->Release();
}
}
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_AUDIO_CAP_SOURCE_CREATE), hr);
}
return 0;
}
LRESULT CTedApp::OnLoadTopology(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
hr = ResolveTopologyFromEditor();
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_TOPO_RESOLUTION), hr);
}
bHandled = TRUE;
return 0;
}
LRESULT CTedApp::OnActionPlay(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
if(!m_fResolved)
{
m_fPendingPlay = true;
hr = ResolveTopologyFromEditor();
if(FAILED(hr))
{
m_fPendingPlay = false;
HandleMMError(LoadAtlString(IDS_E_TOPO_RESOLUTION), hr);
}
return 0;
}
hr = Play();
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_TOPO_PLAY), hr);
}
bHandled = TRUE;
return 0;
}
LRESULT CTedApp::OnActionStop(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr;
IFC(m_pPlayer->Stop());
m_pVideoWindowHandler->ShowWindows(SW_HIDE);
EnableInput(ID_PLAY_PLAY, TRUE);
EnableInput(ID_PLAY_STOP, FALSE);
EnableInput(ID_PLAY_PAUSE, FALSE);
MFTIME duration;
m_pPlayer->GetDuration(duration);
m_pMainToolbar->UpdateTimeDisplay(0, duration);
KillTimer(ms_nTimerID);
Cleanup:
bHandled = TRUE;
return 0;
}
LRESULT CTedApp::OnActionPause(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) {
HRESULT hr;
IFC( m_pPlayer->Pause() );
EnableInput(ID_PLAY_PLAY, TRUE);
EnableInput(ID_PLAY_STOP, TRUE);
EnableInput(ID_PLAY_PAUSE, FALSE);
Cleanup:
bHandled = TRUE;
return 0;
}
LRESULT CTedApp::OnSpy(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = m_pTopoView->SpySelectedNode();
if(FAILED(hr))
{
m_MFErrorHandler.HandleMFError(LoadAtlString(IDS_E_NODE_SPY), hr);
}
return 0;
}
LRESULT CTedApp::OnCustomTopoloader(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
CTedInputGuidDialog dialog;
HRESULT hr = S_OK;
if(dialog.DoModal() == IDOK && dialog.IsValidGuid())
{
CComPtr<IMFTopoLoader> spTopoLoader;
GUID gidTopoloader = dialog.GetInputGuid();
// Test creation of a topoloader with this CLSID to ensure it is valid, rather than
// fail when creating the session in a seemingly unrelated error.
hr = CoCreateInstance(gidTopoloader, NULL, CLSCTX_INPROC_SERVER, IID_IMFTopoLoader, (void **)&spTopoLoader);
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_TOPOLOADER_CREATE), hr);
}
else
{
m_pPlayer->SetCustomTopoloader(gidTopoloader);
}
}
return 0;
}
LRESULT CTedApp::OnExit(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
SendMessage(WM_CLOSE, 0, 0);
return 0;
}
LRESULT CTedApp::OnHelpHelp(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HINSTANCE hReturned = ShellExecute(NULL, L"open", L"http://go.microsoft.com/fwlink/?LinkId=92748", NULL, NULL, SW_SHOW);
if(hReturned <= HINSTANCE(32))
{
MessageBox(LoadAtlString(IDS_E_URL_OPEN), LoadAtlString(IDS_ERROR), MB_OK);
}
return 0;
}
LRESULT CTedApp::OnHelpAbout(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
CTedAboutDialog dialog;
dialog.DoModal();
return 0;
}
LRESULT CTedApp::OnRenderFile(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
CAtlString strFilter = LoadAtlString(IDS_FILE_MEDIA);
CAtlString strTitle = LoadAtlString(IDS_FILE_SELECT);
strFilter.SetAt(strFilter.GetLength()-1,0); // force double-null termination
strFilter.SetAt(strFilter.GetLength()-2,0);
TCHAR fileBuffer[m_dwMaxAcceptedFileNameLength];
fileBuffer[0] = 0;
OPENFILENAME openFileInfo;
openFileInfo.lStructSize = sizeof(OPENFILENAME);
openFileInfo.hwndOwner = m_hWnd;
openFileInfo.hInstance = 0;
openFileInfo.lpstrFilter = strFilter;
openFileInfo.lpstrCustomFilter = NULL;
openFileInfo.nFilterIndex = 1;
openFileInfo.lpstrFile = fileBuffer;
openFileInfo.nMaxFile = m_dwMaxAcceptedFileNameLength;
openFileInfo.lpstrFileTitle = NULL;
openFileInfo.nMaxFileTitle = 0;
openFileInfo.lpstrInitialDir = NULL;
openFileInfo.lpstrTitle = strTitle;
openFileInfo.Flags = OFN_FILEMUSTEXIST;
openFileInfo.nFileOffset = 0;
openFileInfo.nFileExtension = 0;
openFileInfo.lpstrDefExt = NULL;
openFileInfo.lCustData = NULL;
openFileInfo.pvReserved = NULL;
openFileInfo.dwReserved = 0;
openFileInfo.FlagsEx = 0;
if(GetOpenFileName(&openFileInfo))
{
CComPtr<IMFTopology> spTopology;
CComPtr<IMFTopology> spTedTopo;
HRESULT hrConstructor;
CTedMediaFileRenderer TedMediaFileRenderer(openFileInfo.lpstrFile, m_pVideoWindowHandler, hrConstructor);
IFC( hrConstructor );
IFC( TedMediaFileRenderer.Load(&spTopology) );
IFC( m_pTopoView->ShowTopology(spTopology, openFileInfo.lpstrFile) );
ResetInterface();
BOOL fIsProtected;
IFC( m_pTopoView->GetTopology(&spTedTopo, &fIsProtected) );
IFC( SetTopologyOnPlayer(spTedTopo, fIsProtected, FALSE) );
}
else
{
hr = HRESULT_FROM_WIN32( CommDlgExtendedError() );
}
Cleanup:
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_MEDIA_RENDER), hr);
}
return 0;
}
LRESULT CTedApp::OnRenderURL(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
CTedInputURLDialog dialog;
if(dialog.DoModal() == IDOK)
{
CComPtr<IMFTopology> spTopology;
CComPtr<IMFTopology> spTedTopo;
HRESULT hrConstructor;
CTedMediaFileRenderer TedMediaFileRenderer(dialog.GetURL(), m_pVideoWindowHandler, hrConstructor);
IFC( hrConstructor );
IFC( TedMediaFileRenderer.Load(&spTopology) );
IFC( m_pTopoView->ShowTopology(spTopology, dialog.GetURL()) );
ResetInterface();
BOOL fIsProtected;
IFC( m_pTopoView->GetTopology(&spTedTopo, &fIsProtected) );
IFC( SetTopologyOnPlayer(spTedTopo, fIsProtected, FALSE) );
}
Cleanup:
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_MEDIA_RENDER), hr);
}
return 0;
}
LRESULT CTedApp::OnRenderTranscode(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
CComPtr<IMFTopology> spTopology;
CComPtr<IMFTopology> spTedTopo;
TCHAR fileBuffer[m_dwMaxAcceptedFileNameLength];
fileBuffer[0] = 0;
OPENFILENAME openFileInfo;
ZeroMemory(&openFileInfo, sizeof(OPENFILENAME));
openFileInfo.lStructSize = sizeof(OPENFILENAME);
openFileInfo.hwndOwner = m_hWnd;
openFileInfo.hInstance = 0;
openFileInfo.lpstrFilter = L"Media Files\0*.*\0";
openFileInfo.lpstrCustomFilter = NULL;
openFileInfo.nFilterIndex = 1;
openFileInfo.lpstrFile = fileBuffer;
openFileInfo.nMaxFile = m_dwMaxAcceptedFileNameLength;
openFileInfo.lpstrFileTitle = NULL;
openFileInfo.nMaxFileTitle = 0;
openFileInfo.lpstrInitialDir = NULL;
openFileInfo.lpstrTitle = L"Select Media Source";
openFileInfo.Flags = OFN_FILEMUSTEXIST;
openFileInfo.nFileOffset = 0;
openFileInfo.nFileExtension = 0;
openFileInfo.lpstrDefExt = NULL;
openFileInfo.lCustData = NULL;
openFileInfo.pvReserved = NULL;
openFileInfo.dwReserved = 0;
openFileInfo.FlagsEx = 0;
if(GetOpenFileName(&openFileInfo))
{
CTedChooserDialog ChooserDialog(L"Choose Transcode Profile");
CTedTranscodeTopologyBuilder Builder(openFileInfo.lpstrFile, &hr);
IFC( hr );
size_t cProfiles = Builder.GetProfileCount();
for(size_t i = 0; i < cProfiles; i++)
{
ChooserDialog.AddPossibleChoice(Builder.GetProfileName(i));
}
if(ChooserDialog.DoModal() == IDOK)
{
TCHAR fileBuffer2[m_dwMaxAcceptedFileNameLength];
fileBuffer2[0] = 0;
OPENFILENAME targetFileInfo;
targetFileInfo.lStructSize = sizeof(OPENFILENAME);
targetFileInfo.hwndOwner = m_hWnd;
targetFileInfo.hInstance = 0;
targetFileInfo.lpstrFilter = L"Media Files\0*.*\0";
targetFileInfo.lpstrCustomFilter = NULL;
targetFileInfo.nFilterIndex = 1;
targetFileInfo.lpstrFile = fileBuffer2;
targetFileInfo.nMaxFile = m_dwMaxAcceptedFileNameLength;
targetFileInfo.lpstrFileTitle = NULL;
targetFileInfo.nMaxFileTitle = 0;
targetFileInfo.lpstrInitialDir = NULL;
targetFileInfo.lpstrTitle = L"Choose target file";
targetFileInfo.Flags = OFN_OVERWRITEPROMPT;
targetFileInfo.nFileOffset = 0;
targetFileInfo.nFileExtension = 0;
targetFileInfo.lpstrDefExt = NULL;
targetFileInfo.lCustData = NULL;
targetFileInfo.pvReserved = NULL;
targetFileInfo.dwReserved = 0;
targetFileInfo.FlagsEx = 0;
if(GetSaveFileName(&targetFileInfo))
{
IFC( Builder.BuildTranscodeTopology(ChooserDialog.GetChoice(), targetFileInfo.lpstrFile, &spTopology) );
IFC( m_pTopoView->ShowTopology(spTopology, openFileInfo.lpstrFile) );
ResetInterface();
BOOL fIsProtected;
IFC( m_pTopoView->GetTopology(&spTedTopo, &fIsProtected) );
IFC( SetTopologyOnPlayer(spTedTopo, fIsProtected, TRUE) );
}
else
{
hr = HRESULT_FROM_WIN32( CommDlgExtendedError() );
}
}
}
else
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
Cleanup:
if(FAILED(hr))
{
HandleMMError(L"Error rendering transcode topology", hr);
}
return 0;
}
void CTedApp::EnableInput(UINT item, BOOL enabled)
{
m_pMainToolbar->EnableButtonByCommand(item, enabled);
if(enabled)
{
EnableMenuItem(m_hMenu, item, MF_ENABLED);
}
else
{
EnableMenuItem(m_hMenu, item, MF_GRAYED);
}
}
void CTedApp::RebuildDockWithOneView()
{
m_pDock->RemoveAllAreas();
CDock::CArea* pEditArea = m_pDock->AddArea(CDock::MOVE_NO);
CDock::CArea* pPropertiesArea = m_pDock->AddArea(CDock::MOVE_NO);
CDock::CArea* pVerticalSplit = m_pDock->AddArea(CDock::MOVE_VERTICAL);
// Create the splitter between the properties view and the edit view
pVerticalSplit->m_Attach.pTop = m_pDock->GetStockArea(CDock::STOCK_AREA_TOP);
pVerticalSplit->m_Attach.pBottom = m_pDock->GetStockArea(CDock::STOCK_AREA_BOTTOM);
pVerticalSplit->m_pWindow = m_pPropSplitter;
pVerticalSplit->m_posFixed.left = m_dblInitialSplitterPos;
pVerticalSplit->m_posFixed.width = m_dwSplitterWidth;
// Create the edit view
pEditArea->m_Attach.pLeft = m_pDock->GetStockArea(CDock::STOCK_AREA_LEFT);
pEditArea->m_Attach.pRight = pVerticalSplit;
pEditArea->m_Attach.pTop = m_pDock->GetStockArea(CDock::STOCK_AREA_TOP);
pEditArea->m_Attach.pBottom = m_pDock->GetStockArea(CDock::STOCK_AREA_BOTTOM);
pEditArea->m_pWindow = &m_EditWindow; //m_pEditorView;
// Create the properties view
pPropertiesArea->m_Attach.pLeft = pVerticalSplit;
pPropertiesArea->m_Attach.pRight = m_pDock->GetStockArea(CDock::STOCK_AREA_RIGHT);
pPropertiesArea->m_Attach.pTop = m_pDock->GetStockArea(CDock::STOCK_AREA_TOP);
pPropertiesArea->m_Attach.pBottom = m_pDock->GetStockArea(CDock::STOCK_AREA_BOTTOM);
pPropertiesArea->m_pWindow = m_pPropertyController->GetWindow();
m_pPropSplitter->ShowWindow(SW_SHOW);
m_pPropertyController->GetWindow()->ShowWindow(SW_SHOW);
m_pSplitter->ShowWindow(SW_HIDE);
m_pDock->UpdateDock();
}
void CTedApp::DisablePlayback()
{
EnableInput(ID_PLAY_PLAY, FALSE);
EnableInput(ID_PLAY_STOP, FALSE);
EnableInput(ID_PLAY_PAUSE, FALSE);
}
HRESULT CTedApp::HasBuggedPins(IMFTopology* pTopology, bool* fBuggedPins)
{
HRESULT hr;
*fBuggedPins = false;
WORD cNodes;
IFC( pTopology->GetNodeCount(&cNodes) );
for(WORD i = 0; i < cNodes && !(*fBuggedPins); i++)
{
CComPtr<IMFTopologyNode> spNode;
IFC( pTopology->GetNode(i, &spNode) );
DWORD cInputs;
IFC( spNode->GetInputCount(&cInputs) )
for(DWORD j = 0; j < cInputs; j++)
{
CComPtr<IMFTopologyNode> spUpNode;
DWORD dwUpIndex;
HRESULT hrPin = spNode->GetInput(j, &spUpNode, &dwUpIndex);
if(FAILED(hrPin))
{
*fBuggedPins = true;
break;
}
}
if(!(*fBuggedPins))
{
DWORD cOutputs;
IFC( spNode->GetOutputCount(&cOutputs) );
for(DWORD j = 0; j < cOutputs; j++)
{
CComPtr<IMFTopologyNode> spDownNode;
DWORD dwDownIndex;
HRESULT hrPin = spNode->GetOutput(j, &spDownNode, &dwDownIndex);
if(FAILED(hrPin))
{
*fBuggedPins = true;
break;
}
}
}
}
Cleanup:
return hr;
}
void CTedApp::ResetInterface()
{
if(m_pPlayer && m_pPlayer->IsPlaying())
{
m_pPlayer->Stop();
}
m_pMainToolbar->UpdateTimeDisplay(0, 0);
m_pMainToolbar->ShowRateBar(SW_HIDE);
m_pMainToolbar->MarkResolved(false);
m_fResolved = false;
}
HRESULT CTedApp::ResolveTopologyFromEditor()
{
HRESULT hr;
BOOL fIsProtected;
CComPtr<IMFTopology> spTopo;
IFC( m_pTopoView->GetTopology(&spTopo, &fIsProtected) );
// WORKAROUND: Currently, disconnected pins are bugged in media foundation.
// The pin is disconnected, but the node will still have an input/output count of
// one. When trying to resolve a topology with a bugged pin like this, the
// topoloader will create a work item with a 'NULL' destination node.
// Executing this work item causes E_POINTER to be returned to the client.
// Since E_POINTER make little sense from the context of the UI, handle
// this issue here.
bool fHasBuggedPins;
IFC( HasBuggedPins(spTopo, &fHasBuggedPins) );
if(fHasBuggedPins)
{
MessageBox(LoadAtlString(IDS_E_TOPO_RESOLUTION_PINS), LoadAtlString(IDS_ERROR), MB_OK);
goto Cleanup;
}
IFC( SetTopologyOnPlayer(spTopo, fIsProtected, FALSE) );
Cleanup:
return hr;
}
HRESULT CTedApp::SetTopologyOnPlayer(IMFTopology* pTopo, BOOL fIsProtected, BOOL fIsTranscode)
{
HRESULT hr;
if(m_pPendingTopo) m_pPendingTopo->Release();
m_pPendingTopo = pTopo;
m_pPendingTopo->AddRef();
m_pPendingTopo->GetTopologyID(&m_PendingTopoID);
if(fIsProtected)
{
hr = m_pPlayer->InitProtected();
}
else
{
hr = m_pPlayer->InitClear();
}
if(SUCCEEDED(hr))
{
hr = m_pPlayer->SetTopology(pTopo, fIsTranscode);
if(FAILED(hr))
{
if(hr == MF_E_NOT_FOUND)
{
MessageBox(LoadAtlString(IDS_E_TOPO_RESOLUTION_NO_SOURCE), LoadAtlString(IDS_ERROR), MB_OK);
hr = S_OK;
m_fPendingPlay = false;
}
goto Cleanup;
}
m_fMergeRequired = true;
}
else
{
HandleMMError(LoadAtlString(IDS_E_TOPO_RESOLUTION_INIT), hr);
hr = S_OK;
}
Cleanup:
return hr;
}
HRESULT CTedApp::Play()
{
HRESULT hr;
m_pVideoWindowHandler->ShowWindows(SW_SHOW);
if(m_fCanSeek)
{
MFTIME duration;
WORD wPos = m_pMainToolbar->GetSeekBar()->GetPos();
IFC( m_pPlayer->GetDuration(duration) );
MFTIME seekTime = (wPos * duration) / m_nSeekerRange;
IFC( m_pPlayer->PlayFrom(seekTime) );
}
else
{
IFC( m_pPlayer->Start() );
}
EnableInput(ID_PLAY_PLAY, FALSE);
EnableInput(ID_PLAY_STOP, TRUE);
EnableInput(ID_PLAY_PAUSE, TRUE);
SetTimer(ms_nTimerID, ms_dwTimerLen, NULL);
Cleanup:
return hr;
}
void CTedApp::LoadFile(LPCWSTR szFile)
{
HRESULT hr = m_pTopoView->LoadTopology(szFile);
if(FAILED(hr))
{
HandleMMError(LoadAtlString(IDS_E_FILE_LOAD_XML), hr);
}
}
void HandleSeekerScrollFunc(WORD wPos)
{
g_pApp->HandleSeekerScroll(wPos);
}
void HandleRateScrollFunc(WORD wPos)
{
g_pApp->HandleRateScroll(wPos);
}
///////////////////////////////////////////////////////////////////////////////
//
HRESULT InitTedApp(LPCWSTR lpCmdLine, int nCmdShow)
{
HRESULT hr = S_OK;
g_pApp = new CTedApp;
if(g_pApp == NULL)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
IFC(g_pApp->Init(lpCmdLine));
/* Make the window visible; update its client area; and return "success" */
g_pApp->ShowWindow(nCmdShow);
g_pApp->UpdateWindow();
Cleanup:
return hr;
}
BOOL WINAPI wWinMain(
__in HINSTANCE hInstance,
__in_opt HINSTANCE hPrevInstance,
__in_opt LPWSTR lpCmdLine,
__in int nCmdShow
)
{
HRESULT hr = S_OK;
MSG msg;
HACCEL hAccelTable;
INITCOMMONCONTROLSEX iccex;
g_hInst = hInstance;
(void)HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
g_hTedUtilInst = LoadLibraryEx(L"TEDUTIL.dll", NULL, 0);
// Initialize common controls
iccex.dwSize = sizeof (INITCOMMONCONTROLSEX);
iccex.dwICC = ICC_LISTVIEW_CLASSES | ICC_BAR_CLASSES;
InitCommonControlsEx(&iccex);
hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_TRV));
/* Perform initializations that apply to a specific instance */
IFC(InitTedApp(lpCmdLine, nCmdShow));
/* Acquire and dispatch messages until a WM_QUIT uMessage is received. */
while(GetMessage( &msg, NULL, 0, 0))
{
if (!TranslateAccelerator(g_pApp->m_hWnd, hAccelTable, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
delete g_pApp;
DestroyAcceleratorTable(hAccelTable);
::FreeLibrary(g_hTedUtilInst);
return (int)msg.wParam;
Cleanup:
assert(SUCCEEDED(hr));
return FALSE;
}
Reference in New Issue View Git Blame Copy Permalink