Changeset 545


Ignore:
Timestamp:
Nov 26, 2015, 3:24:03 AM (6 years ago)
Author:
roman
Message:

Added previously not included hooks; added IFilterMapper3 hook suppors; template library related updates; added FGT to replace ROT (to access services in particular) - work in progress; fixed class enumeration hook

Location:
trunk/DirectShowSpy
Files:
2 added
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/DirectShowSpy/Common.h

    r468 r545  
    4343public:
    4444// CProcessTokenPrivileges
    45         CProcessTokenPrivileges() throw() :
     45        CProcessTokenPrivileges() :
    4646                m_bTakeOwnershipPrivilegeEnabled(FALSE),
    4747                m_bRestorePrivilegeEnabled(FALSE)
     
    6666                __E(m_ProcessToken.EnablePrivilege(SE_RESTORE_NAME));
    6767                m_bRestorePrivilegeEnabled = TRUE;
     68        }
     69        BOOL IsTakeOwnershipPrivilegeEnabled() const
     70        {
     71                return m_bTakeOwnershipPrivilegeEnabled;
     72        }
     73        BOOL IsRestorePrivilegeEnabled() const
     74        {
     75                return m_bRestorePrivilegeEnabled;
    6876        }
    6977};
  • trunk/DirectShowSpy/DirectShowSpy.vcxproj

    r503 r545  
    163163      <WarningLevel>Level3</WarningLevel>
    164164      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     165      <AdditionalIncludeDirectories>
     166      </AdditionalIncludeDirectories>
    165167    </ClCompile>
    166168    <ResourceCompile>
     
    200202      <WarningLevel>Level3</WarningLevel>
    201203      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     204      <AdditionalIncludeDirectories>
     205      </AdditionalIncludeDirectories>
    202206    </ClCompile>
    203207    <ResourceCompile>
     
    243247      <WarningLevel>Level3</WarningLevel>
    244248      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     249      <AdditionalIncludeDirectories>
     250      </AdditionalIncludeDirectories>
    245251    </ClCompile>
    246252    <ResourceCompile>
     
    288294      <WarningLevel>Level3</WarningLevel>
    289295      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     296      <AdditionalIncludeDirectories>
     297      </AdditionalIncludeDirectories>
    290298    </ClCompile>
    291299    <ResourceCompile>
     
    334342      <WarningLevel>Level3</WarningLevel>
    335343      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     344      <AdditionalIncludeDirectories>
     345      </AdditionalIncludeDirectories>
    336346    </ClCompile>
    337347    <ResourceCompile>
     
    379389      <WarningLevel>Level3</WarningLevel>
    380390      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     391      <AdditionalIncludeDirectories>
     392      </AdditionalIncludeDirectories>
    381393    </ClCompile>
    382394    <ResourceCompile>
  • trunk/DirectShowSpy/FilterGraphList.h

    r503 r545  
    275275                                {
    276276                                        CComPtr<IMoniker> pMoniker;
    277                                         if(pEnumMoniker->Next(1, &pMoniker, NULL) != S_OK)
     277                                        ULONG nElementCount;
     278                                        if(pEnumMoniker->Next(1, &pMoniker, &nElementCount) != S_OK)
    278279                                                break;
    279280                                        _ATLTRY
  • trunk/DirectShowSpy/FilterGraphSpy.cpp

    r440 r545  
    1616#include "stdafx.h"
    1717#include "resource.h"
     18#include "FilterGraphSpy.h"
     19#include "FilterMapperSpy.h"
     20#include "SystemDeviceEnumeratorSpy.h"
    1821
    1922////////////////////////////////////////////////////////////
  • trunk/DirectShowSpy/FilterGraphSpy.h

    r519 r545  
    412412                public CComObjectRootEx<CComMultiThreadModelNoCS>,
    413413                public CComCoClass<CLogFilter, &__uuidof(CLogFilterBase)>,
    414                 public CTransformationFilterT<CLogFilter>,
     414                public CTransformFilterT<CLogFilter>,
    415415                public CBasePersistT<CLogFilter>
    416416        {
  • trunk/DirectShowSpy/FilterMapperSpy.h

    r376 r545  
    1717
    1818#include "rodshow.h"
    19 #include <..\Samples\multimedia\directshow\misc\mapper\fil_data.h>
     19#include "fil_data.h" //<..\Samples\multimedia\directshow\misc\mapper\fil_data.h>
    2020#include "Module_i.h"
    2121#include "Common.h"
     
    3131        public IDispatchImpl<IFilterMapperSpy>,
    3232        public IAMFilterData,
    33         public IFilterMapper2
     33        public IFilterMapper,
     34        public IFilterMapper3
    3435{
    3536        typedef CFilterMapperSpyT<T, t_pFilterMapperClassIdentifier> CFilterMapperSpy;
     
    4445DECLARE_GET_CONTROLLING_UNKNOWN()
    4546
    46 DECLARE_QI_TRACE(CFilterMapperSpy)
    47 
    48 BEGIN_COM_MAP(CFilterMapperSpy)
     47DECLARE_QI_TRACE(CFilterMapperSpyT)
     48
     49BEGIN_COM_MAP(CFilterMapperSpyT)
    4950        COM_INTERFACE_ENTRY(IFilterMapperSpy)
    5051        COM_INTERFACE_ENTRY(IAMFilterData)
     52        COM_INTERFACE_ENTRY(IFilterMapper3)
    5153        COM_INTERFACE_ENTRY(IFilterMapper2)
     54        COM_INTERFACE_ENTRY(IFilterMapper)
    5255        COM_INTERFACE_ENTRY_AGGREGATE_BLIND(m_pInnerUnknown)
    5356        //COM_INTERFACE_ENTRY(IDispatch)
     
    5861        HINSTANCE m_hQuartzModule;
    5962        CComPtr<IUnknown> m_pInnerUnknown;
    60         CComPtr<IFilterMapper2> m_pFilterMapper2;
     63        CComPtr<IFilterMapper3> m_pFilterMapper3;
     64        CComPtr<IFilterMapper> m_pFilterMapper;
    6165        CComPtr<IAMFilterData> m_pAmFilterData;
    6266
     
    6468        {
    6569                _A(pFilterInformation);
    66                 _Z4(atlTraceCOM, 4, _T("pFilterInformation { dwVersion %d, dwMerit 0x%08x, cPins2 %d }\n"), pFilterInformation->dwVersion, pFilterInformation->dwMerit, pFilterInformation->cPins2);
     70                _Z4(atlTraceCOM, 4, _T("pFilterInformation { dwVersion %d, dwMerit 0x%08X, cPins2 %d }\n"), pFilterInformation->dwVersion, pFilterInformation->dwMerit, pFilterInformation->cPins2);
    6771                if(pFilterInformation->dwVersion == 2)
    6872                        for(ULONG nPinIndex = 0; nPinIndex < pFilterInformation->cPins2; nPinIndex++)
    6973                        {
    7074                                const REGFILTERPINS2& Pin = pFilterInformation->rgPins2[nPinIndex];
    71                                 _Z4(atlTraceCOM, 4, _T("pFilterInformation->rgPins2[%d] { dwFlags 0x%x, cInstances %d, nMediaTypes %d, nMediums %d }\n"), nPinIndex, Pin.dwFlags, Pin.cInstances, Pin.nMediaTypes, Pin.nMediums, Pin.clsPinCategory ? (LPCWSTR) _PersistHelper::StringFromIdentifier(*Pin.clsPinCategory) : L"NULL");
     75                                _Z4(atlTraceCOM, 4, _T("pFilterInformation->rgPins2[%d] { dwFlags 0x%X, cInstances %d, nMediaTypes %d, nMediums %d }\n"), nPinIndex, Pin.dwFlags, Pin.cInstances, Pin.nMediaTypes, Pin.nMediums, Pin.clsPinCategory ? (LPCWSTR) _PersistHelper::StringFromIdentifier(*Pin.clsPinCategory) : L"NULL");
    7276                                for(UINT nIndex = 0; nIndex < Pin.nMediaTypes; nIndex++)
    7377                                {
     
    7882                                {
    7983                                        const REGPINMEDIUM& Medium = Pin.lpMedium[nIndex];
    80                                         _Z4(atlTraceCOM, 4, _T("pFilterInformation->rgPins2[...].lpMedium[%d] { clsMedium %ls, dw1 0x%x, dw2 0x%x }\n"), nIndex, _PersistHelper::StringFromIdentifier(Medium.clsMedium), Medium.dw1, Medium.dw2);
     84                                        _Z4(atlTraceCOM, 4, _T("pFilterInformation->rgPins2[...].lpMedium[%d] { clsMedium %ls, dw1 0x%X, dw2 0x%X }\n"), nIndex, _PersistHelper::StringFromIdentifier(Medium.clsMedium), Medium.dw1, Medium.dw2);
    8185                                }
    8286                        }
    8387        }
    84         BOOL IsAggregated() const throw()
     88        BOOL IsAggregated() const
    8589        {
    8690                return (ULONG) m_dwRef >= 0x00001000;
     
    8993public:
    9094// CFilterMapperSpyT
    91         static LPCTSTR GetOriginalLibraryName() throw()
     95        static LPCTSTR GetOriginalLibraryName()
    9296        {
    9397                return _T("quartz.dll");
     
    97101                return _StringHelper::GetLine(T::IDR, 2);
    98102        }
    99         static HRESULT WINAPI UpdateRegistry(BOOL bRegister) throw()
     103        static HRESULT WINAPI UpdateRegistry(BOOL bRegister)
    100104        {
    101105                _Z2(atlTraceRegistrar, 2, _T("bRegister %d\n"), bRegister);
     
    110114                return S_OK;
    111115        }
    112         CFilterMapperSpyT() throw() :
     116        CFilterMapperSpyT() :
    113117                m_hQuartzModule(NULL)
    114118        {
    115119                _Z4_THIS();
    116120        }
    117         ~CFilterMapperSpyT() throw()
     121        ~CFilterMapperSpyT()
    118122        {
    119123                _Z4_THIS();
    120124        }
    121         HRESULT FinalConstruct() throw()
     125        HRESULT FinalConstruct()
    122126        {
    123127                _ATLTRY
     
    126130                        TCHAR pszPath[MAX_PATH] = { 0 };
    127131                        _W(GetModuleFileName(NULL, pszPath, DIM(pszPath)));
    128                         _Z4(atlTraceRefcount, 4, _T("pszPath \"%s\", this 0x%08x, m_dwRef %d, m_bIsAggregated %d\n"), pszPath, this, m_dwRef, m_bIsAggregated);
     132                        _Z4(atlTraceRefcount, 4, _T("pszPath \"%s\", this 0x%p, m_dwRef %d, m_bIsAggregated %d\n"), pszPath, this, m_dwRef, m_bIsAggregated);
    129133                        const HINSTANCE hModule = CoLoadLibrary(const_cast<LPOLESTR>((LPCOLESTR) CT2COLE(GetOriginalLibraryName())), TRUE);
    130134                        _ATLTRY
     
    140144                                        CComPtr<IUnknown> pUnknown;
    141145                                        __C(pClassFactory->CreateInstance(pControllingUnknown, __uuidof(IUnknown), (VOID**) &pUnknown));
    142                                         const CComQIPtr<IFilterMapper2> pFilterMapper2 = pUnknown;
    143                                         __D(pFilterMapper2, E_NOINTERFACE);
    144                                         pFilterMapper2.p->Release();
     146                                        const CComQIPtr<IFilterMapper3> pFilterMapper3 = pUnknown;
     147                                        __D(pFilterMapper3, E_NOINTERFACE);
     148                                        pFilterMapper3.p->Release();
     149                                        const CComQIPtr<IFilterMapper> pFilterMapper = pUnknown;
     150                                        __D(pFilterMapper, E_NOINTERFACE);
     151                                        pFilterMapper.p->Release();
    145152                                        const CComQIPtr<IAMFilterData> pAmFilterData = pUnknown;
    146153                                        __D(pAmFilterData, E_NOINTERFACE);
    147154                                        pAmFilterData.p->Release();
    148155                                        m_pInnerUnknown = pUnknown;
    149                                         m_pFilterMapper2 = pFilterMapper2;
     156                                        m_pFilterMapper3 = pFilterMapper3;
     157                                        m_pFilterMapper = pFilterMapper;
    150158                                        m_pAmFilterData = pAmFilterData;
    151159                                }
     
    165173                return S_OK;
    166174        }
    167         VOID FinalRelease() throw()
    168         {
    169                 _Z5(atlTraceRefcount, 5, _T("m_dwRef 0x%x\n"), m_dwRef);
     175        VOID FinalRelease()
     176        {
     177                _Z5(atlTraceRefcount, 5, _T("m_dwRef 0x%X\n"), m_dwRef);
    170178                CComPtr<IUnknown> pControllingUnknown = GetControllingUnknown();
    171                 if(m_pFilterMapper2)
     179                if(m_pFilterMapper3)
    172180                {
    173181                        pControllingUnknown.p->AddRef();
    174                         m_pFilterMapper2 = NULL;
     182                        m_pFilterMapper3.Release();
     183                }
     184                if(m_pFilterMapper)
     185                {
     186                        pControllingUnknown.p->AddRef();
     187                        m_pFilterMapper.Release();
    175188                }
    176189                if(m_pAmFilterData)
    177190                {
    178191                        pControllingUnknown.p->AddRef();
    179                         m_pAmFilterData = NULL;
     192                        m_pAmFilterData.Release();
    180193                }
    181194                _ATLTRY
    182195                {
    183                         m_pInnerUnknown = NULL;
     196                        m_pInnerUnknown.Release();
    184197                }
    185198                _ATLCATCHALL()
     
    199212
    200213// IAMFilterData
    201         STDMETHOD(ParseFilterData)(BYTE* pnFilterData, ULONG nFilterDataSize, BYTE** ppFilterInformation) throw()
     214        STDMETHOD(ParseFilterData)(BYTE* pnFilterData, ULONG nFilterDataSize, BYTE** ppFilterInformation) override
    202215        {
    203216                _Z4(atlTraceCOM, 4, _T("nFilterDataSize %d\n"), nFilterDataSize);
     
    214227                return nResult;
    215228        }
    216         STDMETHOD(CreateFilterData)(REGFILTER2* pFilterInformation, BYTE** ppnFilterData, ULONG* pnFilterDataSize) throw()
     229        STDMETHOD(CreateFilterData)(REGFILTER2* pFilterInformation, BYTE** ppnFilterData, ULONG* pnFilterDataSize) override
    217230        {
    218231                _Z4(atlTraceCOM, 4, _T("...\n"));
     
    229242        }
    230243
     244// IFilterMapper3
     245        STDMETHOD(GetICreateDevEnum)(ICreateDevEnum** ppEnum) override
     246        {
     247                _Z4(atlTraceCOM, 4, _T("...\n"));
     248                return m_pFilterMapper3->GetICreateDevEnum(ppEnum);
     249        }
     250
    231251// IFilterMapper2
    232         STDMETHOD(CreateCategory)(REFCLSID CategoryIdentifier, DWORD nMerit, LPCWSTR pszDescription) throw()
    233         {
    234                 _Z4(atlTraceCOM, 4, _T("CategoryIdentifier %ls, nMerit 0x%08x, pszDescription \"%s\"\n"), _PersistHelper::StringFromIdentifier(CategoryIdentifier), nMerit, CString(pszDescription));
    235                 return m_pFilterMapper2->CreateCategory(CategoryIdentifier, nMerit, pszDescription);
    236         }
    237         STDMETHOD(UnregisterFilter)(const CLSID* pCategoryIdentifier, LPCOLESTR pszInstance, REFCLSID FilterClassIdentifier) throw()
     252        STDMETHOD(CreateCategory)(REFCLSID CategoryIdentifier, DWORD nMerit, LPCWSTR pszDescription) override
     253        {
     254                _Z4(atlTraceCOM, 4, _T("CategoryIdentifier %ls, nMerit 0x%08X, pszDescription \"%s\"\n"), _PersistHelper::StringFromIdentifier(CategoryIdentifier), nMerit, CString(pszDescription));
     255                return m_pFilterMapper3->CreateCategory(CategoryIdentifier, nMerit, pszDescription);
     256        }
     257        STDMETHOD(UnregisterFilter)(const CLSID* pCategoryIdentifier, LPCOLESTR pszInstance, REFCLSID FilterClassIdentifier) override
    238258        {
    239259                _Z4(atlTraceCOM, 4, _T("pCategoryIdentifier %ls, pszInstance %s, FilterClassIdentifier %ls\n"), pCategoryIdentifier ? (LPCWSTR) _PersistHelper::StringFromIdentifier(*pCategoryIdentifier) : L"NULL", pszInstance ? (LPCTSTR) AtlFormatString(_T("\"%s\""), CString(pszInstance)) : _T("NULL"), _PersistHelper::StringFromIdentifier(FilterClassIdentifier));
    240                 return m_pFilterMapper2->UnregisterFilter(pCategoryIdentifier, pszInstance, FilterClassIdentifier);
    241         }
    242         STDMETHOD(RegisterFilter)(REFCLSID FilterClassIdentifier, LPCWSTR pszName, IMoniker** ppMoniker, const CLSID* pCategoryIdentifier, LPCOLESTR pszInstance, const REGFILTER2* pFilterInformation) throw()
     260                return m_pFilterMapper3->UnregisterFilter(pCategoryIdentifier, pszInstance, FilterClassIdentifier);
     261        }
     262        STDMETHOD(RegisterFilter)(REFCLSID FilterClassIdentifier, LPCWSTR pszName, IMoniker** ppMoniker, const CLSID* pCategoryIdentifier, LPCOLESTR pszInstance, const REGFILTER2* pFilterInformation) override
    243263        {
    244264                _Z4(atlTraceCOM, 4, _T("FilterClassIdentifier %ls, pszName \"%s\", pCategoryIdentifier %ls, pszInstance %s\n"), _PersistHelper::StringFromIdentifier(FilterClassIdentifier), CString(pszName), pCategoryIdentifier ? (LPCWSTR) _PersistHelper::StringFromIdentifier(*pCategoryIdentifier) : L"NULL", pszInstance ? (LPCTSTR) AtlFormatString(_T("\"%s\""), CString(pszInstance)) : _T("NULL"));
     
    252272                                _Z_EXCEPTION();
    253273                        }
    254                 return m_pFilterMapper2->RegisterFilter(FilterClassIdentifier, pszName, ppMoniker, pCategoryIdentifier, pszInstance, pFilterInformation);
    255         }
    256         STDMETHOD(EnumMatchingFilters)(IEnumMoniker** ppEnumMoniker, DWORD nFlags, BOOL bExactMatch, DWORD nMinimalMerit, BOOL bInputNeeded, DWORD nInputTypeCount, const GUID* pInputTypes, const REGPINMEDIUM* pInputMedium, const CLSID* pInputPinCategory, BOOL bRender, BOOL bOutputNeeded, DWORD nOutputTypeCount, const GUID* pOutputTypes, const REGPINMEDIUM* pOutputMedium, const CLSID* pOutputPinCategory) throw()
    257         {
    258                 _Z4(atlTraceCOM, 4, _T("nFlags 0x%x, bExactMatch %d, nMinimalMerit 0x%08x, bInputNeeded %d, nInputTypeCount %d, pInputPinCategory %ls, bRender %d, bOutputNeeded %d, nOutputTypeCount %d, pOutputPinCategory %ls\n"), nFlags, bExactMatch, nMinimalMerit, bInputNeeded, nInputTypeCount, pInputPinCategory ? (LPCWSTR) _PersistHelper::StringFromIdentifier(*pInputPinCategory) : L"NULL", bRender, bOutputNeeded, nOutputTypeCount, pOutputPinCategory ? (LPCWSTR) _PersistHelper::StringFromIdentifier(*pOutputPinCategory) : L"NULL");
     274                return m_pFilterMapper3->RegisterFilter(FilterClassIdentifier, pszName, ppMoniker, pCategoryIdentifier, pszInstance, pFilterInformation);
     275        }
     276        STDMETHOD(EnumMatchingFilters)(IEnumMoniker** ppEnumMoniker, DWORD nFlags, BOOL bExactMatch, DWORD nMinimalMerit, BOOL bInputNeeded, DWORD nInputTypeCount, const GUID* pInputTypes, const REGPINMEDIUM* pInputMedium, const CLSID* pInputPinCategory, BOOL bRender, BOOL bOutputNeeded, DWORD nOutputTypeCount, const GUID* pOutputTypes, const REGPINMEDIUM* pOutputMedium, const CLSID* pOutputPinCategory) override
     277        {
     278                _Z4(atlTraceCOM, 4, _T("nFlags 0x%X, bExactMatch %d, nMinimalMerit 0x%08X, bInputNeeded %d, nInputTypeCount %d, pInputPinCategory %ls, bRender %d, bOutputNeeded %d, nOutputTypeCount %d, pOutputPinCategory %ls\n"), nFlags, bExactMatch, nMinimalMerit, bInputNeeded, nInputTypeCount, pInputPinCategory ? (LPCWSTR) _PersistHelper::StringFromIdentifier(*pInputPinCategory) : L"NULL", bRender, bOutputNeeded, nOutputTypeCount, pOutputPinCategory ? (LPCWSTR) _PersistHelper::StringFromIdentifier(*pOutputPinCategory) : L"NULL");
    259279                for(DWORD nInputTypeIndex = 0; nInputTypeIndex < nInputTypeCount; nInputTypeIndex++)
    260280                {
     
    264284                }
    265285                if(pInputMedium)
    266                         _Z4(atlTraceCOM, 4, _T("pInputMedium { clsMedium %ls, dw1 0x%x, dw2 0x%x }\n"), _PersistHelper::StringFromIdentifier(pInputMedium->clsMedium), pInputMedium->dw1, pInputMedium->dw2);
     286                        _Z4(atlTraceCOM, 4, _T("pInputMedium { clsMedium %ls, dw1 0x%X, dw2 0x%X }\n"), _PersistHelper::StringFromIdentifier(pInputMedium->clsMedium), pInputMedium->dw1, pInputMedium->dw2);
    267287                for(DWORD nOutputTypeIndex = 0; nOutputTypeIndex < nOutputTypeCount; nOutputTypeIndex++)
    268288                {
     
    272292                }
    273293                if(pOutputMedium)
    274                         _Z4(atlTraceCOM, 4, _T("pOutputMedium { clsMedium %ls, dw1 0x%x, dw2 0x%x }\n"), _PersistHelper::StringFromIdentifier(pOutputMedium->clsMedium), pOutputMedium->dw1, pOutputMedium->dw2);
    275                 const HRESULT nResult = m_pFilterMapper2->EnumMatchingFilters(ppEnumMoniker, nFlags, bExactMatch, nMinimalMerit, bInputNeeded, nInputTypeCount, pInputTypes, pInputMedium, pInputPinCategory, bRender, bOutputNeeded, nOutputTypeCount, pOutputTypes, pOutputMedium, pOutputPinCategory);
     294                        _Z4(atlTraceCOM, 4, _T("pOutputMedium { clsMedium %ls, dw1 0x%X, dw2 0x%X }\n"), _PersistHelper::StringFromIdentifier(pOutputMedium->clsMedium), pOutputMedium->dw1, pOutputMedium->dw2);
     295                const HRESULT nResult = m_pFilterMapper3->EnumMatchingFilters(ppEnumMoniker, nFlags, bExactMatch, nMinimalMerit, bInputNeeded, nInputTypeCount, pInputTypes, pInputMedium, pInputPinCategory, bRender, bOutputNeeded, nOutputTypeCount, pOutputTypes, pOutputMedium, pOutputPinCategory);
    276296                if(SUCCEEDED(nResult))
    277297                        _ATLTRY
     
    279299                                const CComPtr<IEnumMoniker>& pEnumMoniker = reinterpret_cast<const CComPtr<IEnumMoniker>&>(*ppEnumMoniker);
    280300                                __C(pEnumMoniker->Reset());
    281                                 CComPtr<IMoniker> pMoniker;
    282                                 while(pEnumMoniker->Next(1, &pMoniker, NULL) == S_OK)
     301                                for(; ; )
    283302                                {
    284                                         _Z4(atlTraceCOM, 4, _T("pMoniker %ls\n"), _FilterGraphHelper::GetMonikerDisplayName(pMoniker));
     303                                        CComPtr<IMoniker> pMoniker;
     304                                        ULONG nElementCount;
     305                                        if(pEnumMoniker->Next(1, &pMoniker, &nElementCount) != S_OK)
     306                                                break;
     307                                        _Z4(atlTraceGeneral, 4, _T("pMoniker %ls\n"), _FilterGraphHelper::GetMonikerDisplayName(pMoniker));
    285308                                        CComPtr<IBindCtx> pBindCtx;
    286309                                        __C(CreateBindCtx(0, &pBindCtx));
     
    291314                                        const CStringW sDevicePath = _FilterGraphHelper::ReadPropertyBagString(pPropertyBag, OLESTR("DevicePath"));
    292315                                        _Z4(atlTraceCOM, 4, _T("sFriendlyName \"%ls\", sDescription \"%ls\", sDevicePath \"%ls\"\n"), sFriendlyName, sDescription, sDevicePath);
    293                                         pMoniker.Release();
    294316                                }
    295317                                __C(pEnumMoniker->Reset());
     
    300322                        }
    301323                return nResult;
     324        }
     325
     326// IFilterMapper
     327        STDMETHOD(RegisterFilter)(CLSID FilterClassIdentifier, LPCWSTR pszName, DWORD nMerit) override
     328        {
     329                _Z4(atlTraceCOM, 4, _T("...\n"));
     330                return m_pFilterMapper->RegisterFilter(FilterClassIdentifier, pszName, nMerit);
     331        }
     332        STDMETHOD(RegisterFilterInstance)(CLSID FilterClassIdentifier, LPCWSTR pszName, CLSID* pMediaResourceIdentifier) override
     333        {
     334                _Z4(atlTraceCOM, 4, _T("...\n"));
     335                return m_pFilterMapper->RegisterFilterInstance(FilterClassIdentifier, pszName, pMediaResourceIdentifier);
     336        }
     337        STDMETHOD(RegisterPin)(CLSID Filter, LPCWSTR pszName, BOOL bRendered, BOOL bOutput, BOOL bZero, BOOL bMany, CLSID ConnectsToFilter, LPCWSTR pszConnectsToPin) override
     338        {
     339                _Z4(atlTraceCOM, 4, _T("...\n"));
     340                return m_pFilterMapper->RegisterPin(Filter, pszName, bRendered, bOutput, bZero, bMany, ConnectsToFilter, pszConnectsToPin);
     341        }
     342        STDMETHOD(RegisterPinType)(CLSID FilterClassIdentifier, LPCWSTR pszName, CLSID MajorType, CLSID Subtype) override
     343        {
     344                _Z4(atlTraceCOM, 4, _T("...\n"));
     345                return m_pFilterMapper->RegisterPinType(FilterClassIdentifier, pszName, MajorType, Subtype);
     346        }
     347        STDMETHOD(UnregisterFilter)(CLSID FilterClassIdentifier) override
     348        {
     349                _Z4(atlTraceCOM, 4, _T("...\n"));
     350                return m_pFilterMapper->UnregisterFilter(FilterClassIdentifier);
     351        }
     352        STDMETHOD(UnregisterFilterInstance)(CLSID MediaResourceIdentifier) override
     353        {
     354                _Z4(atlTraceCOM, 4, _T("...\n"));
     355                return m_pFilterMapper->UnregisterFilterInstance(MediaResourceIdentifier);
     356        }
     357        STDMETHOD(UnregisterPin)(CLSID FilterClassIdentifier, LPCWSTR pszName) override
     358        {
     359                _Z4(atlTraceCOM, 4, _T("...\n"));
     360                return m_pFilterMapper->UnregisterPin(FilterClassIdentifier, pszName);
     361        }
     362        STDMETHOD(EnumMatchingFilters)(IEnumRegFilters** ppEnum, DWORD nMerit, BOOL bInputNeeded, CLSID clsInMaj, CLSID clsInSub, BOOL bRender, BOOL bOutputNeeded, CLSID clsOutMaj, CLSID clsOutSub) override
     363        {
     364                _Z4(atlTraceCOM, 4, _T("...\n"));
     365                return m_pFilterMapper->EnumMatchingFilters(ppEnum, nMerit, bInputNeeded, clsInMaj, clsInSub, bRender, bOutputNeeded, clsOutMaj, clsOutSub);
    302366        }
    303367};
  • trunk/DirectShowSpy/SystemDeviceEnumeratorSpy.h

    r376 r545  
    4444DECLARE_GET_CONTROLLING_UNKNOWN()
    4545
    46 DECLARE_QI_TRACE(CSystemDeviceEnumeratorSpy)
    47 
    48 BEGIN_COM_MAP(CSystemDeviceEnumeratorSpy)
     46DECLARE_QI_TRACE(CSystemDeviceEnumeratorSpyT)
     47
     48BEGIN_COM_MAP(CSystemDeviceEnumeratorSpyT)
    4949        COM_INTERFACE_ENTRY(ISystemDeviceEnumeratorSpy)
    5050        COM_INTERFACE_ENTRY(ICreateDevEnum)
     
    9595
    9696        // IPropertyBag
    97                 STDMETHOD(Read)(LPCOLESTR pszPropertyName, VARIANT* pvValue, IErrorLog* pErrorLog) throw()
     97                STDMETHOD(Read)(LPCOLESTR pszPropertyName, VARIANT* pvValue, IErrorLog* pErrorLog) override
    9898                {
    9999                        _Z4(atlTraceCOM, 4, _T("pszPropertyName %s\n"), CString(pszPropertyName));
     
    104104                                //if(nResult == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) && pszPropertyName && _wcsicmp(pszPropertyName, L"DevicePath") == 0 && pvValue)
    105105                                //{
    106                                 //      _Z4(atlTraceGeneral, 4, _T("nResult 0x%08x\n"), nResult);
     106                                //      _Z4(atlTraceGeneral, 4, _T("nResult 0x%08X\n"), nResult);
    107107                                //      CComVariant vValue = L"\\\\?\\fake";
    108108                                //      _V(vValue.Detach(pvValue));
     
    116116                                        if(SUCCEEDED(vStringValue.ChangeType(VT_BSTR, pvValue)))
    117117                                                sValue = CString(vStringValue.bstrVal);
    118                                         _Z4(atlTraceGeneral, 4, _T("nResult 0x%08x, pvValue->vt 0x%x, %s\n"), nResult, pvValue->vt, sValue);
     118                                        _Z4(atlTraceGeneral, 4, _T("nResult 0x%08X, pvValue->vt 0x%X, %s\n"), nResult, pvValue->vt, sValue);
    119119                                } else
    120120                                {
    121                                         _Z4(atlTraceGeneral, 4, _T("nResult 0x%08x\n"), nResult);
     121                                        _Z4(atlTraceGeneral, 4, _T("nResult 0x%08X\n"), nResult);
    122122                                }
    123123                                return nResult;
     
    129129                        return S_OK;
    130130                }
    131                 STDMETHOD(Write)(LPCOLESTR pszPropertyName, VARIANT* pvValue) throw()
    132                 {
    133                         _Z4(atlTraceCOM, 4, _T("pszPropertyName %s, pvValue->vt 0x%x\n"), CString(pszPropertyName), pvValue->vt);
     131                STDMETHOD(Write)(LPCOLESTR pszPropertyName, VARIANT* pvValue) override
     132                {
     133                        _Z4(atlTraceCOM, 4, _T("pszPropertyName %s, pvValue->vt 0x%X\n"), CString(pszPropertyName), pvValue->vt);
    134134                        _ATLTRY
    135135                        {
    136136                                const HRESULT nResult = m_pPropertyBag->Write(pszPropertyName, pvValue);
    137                                 _Z4(atlTraceGeneral, 4, _T("nResult 0x%08x\n"), nResult);
     137                                _Z4(atlTraceGeneral, 4, _T("nResult 0x%08X\n"), nResult);
    138138                                return nResult;
    139139                        }
     
    146146
    147147        // IPropertyBag2
    148                 STDMETHOD(Read)(ULONG cProperties, PROPBAG2 *pPropBag, IErrorLog *pErrLog, VARIANT *pvarValue, HRESULT *phrError) throw()
     148                STDMETHOD(Read)(ULONG cProperties, PROPBAG2 *pPropBag, IErrorLog *pErrLog, VARIANT *pvarValue, HRESULT *phrError) override
    149149                {
    150150                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    152152                        {
    153153                                const HRESULT nResult = m_pPropertyBag2->Read(cProperties, pPropBag, pErrLog, pvarValue, phrError);
    154                                 _Z4(atlTraceGeneral, 4, _T("nResult 0x%08x\n"), nResult);
     154                                _Z4(atlTraceGeneral, 4, _T("nResult 0x%08X\n"), nResult);
    155155                                return nResult;
    156156                        }
     
    161161                        return S_OK;
    162162                }
    163                 STDMETHOD(Write)(ULONG cProperties, PROPBAG2 *pPropBag, VARIANT *pvarValue) throw()
     163                STDMETHOD(Write)(ULONG cProperties, PROPBAG2 *pPropBag, VARIANT *pvarValue) override
    164164                {
    165165                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    167167                        {
    168168                                const HRESULT nResult = m_pPropertyBag2->Write(cProperties, pPropBag, pvarValue);
    169                                 _Z4(atlTraceGeneral, 4, _T("nResult 0x%08x\n"), nResult);
     169                                _Z4(atlTraceGeneral, 4, _T("nResult 0x%08X\n"), nResult);
    170170                                return nResult;
    171171                        }
     
    176176                        return S_OK;
    177177                }
    178                 STDMETHOD(CountProperties)(ULONG *pcProperties) throw()
     178                STDMETHOD(CountProperties)(ULONG *pcProperties) override
    179179                {
    180180                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    182182                        {
    183183                                const HRESULT nResult = m_pPropertyBag2->CountProperties(pcProperties);
    184                                 _Z4(atlTraceGeneral, 4, _T("nResult 0x%08x\n"), nResult);
     184                                _Z4(atlTraceGeneral, 4, _T("nResult 0x%08X\n"), nResult);
    185185                                return nResult;
    186186                        }
     
    191191                        return S_OK;
    192192                }
    193                 STDMETHOD(GetPropertyInfo)(ULONG iProperty, ULONG cProperties, PROPBAG2* pPropBag, ULONG *pcProperties) throw()
     193                STDMETHOD(GetPropertyInfo)(ULONG iProperty, ULONG cProperties, PROPBAG2* pPropBag, ULONG *pcProperties) override
    194194                {
    195195                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    197197                        {
    198198                                const HRESULT nResult = m_pPropertyBag2->GetPropertyInfo(iProperty, cProperties, pPropBag, pcProperties);
    199                                 _Z4(atlTraceGeneral, 4, _T("nResult 0x%08x\n"), nResult);
     199                                _Z4(atlTraceGeneral, 4, _T("nResult 0x%08X\n"), nResult);
    200200                                return nResult;
    201201                        }
     
    206206                        return S_OK;
    207207                }
    208                 STDMETHOD(LoadObject)(LPCOLESTR pstrName, DWORD dwHint, IUnknown *pUnkObject, IErrorLog *pErrLog) throw()
     208                STDMETHOD(LoadObject)(LPCOLESTR pstrName, DWORD dwHint, IUnknown *pUnkObject, IErrorLog *pErrLog) override
    209209                {
    210210                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    212212                        {
    213213                                const HRESULT nResult = m_pPropertyBag2->LoadObject(pstrName, dwHint, pUnkObject, pErrLog);
    214                                 _Z4(atlTraceGeneral, 4, _T("nResult 0x%08x\n"), nResult);
     214                                _Z4(atlTraceGeneral, 4, _T("nResult 0x%08X\n"), nResult);
    215215                                return nResult;
    216216                        }
     
    261261
    262262        // IPersist
    263                 STDMETHOD(GetClassID)(CLSID* pClassIdentifier) throw()
     263                STDMETHOD(GetClassID)(CLSID* pClassIdentifier) override
    264264                {
    265265                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    268268
    269269    // IPersistStream
    270                 STDMETHOD(IsDirty)() throw()
     270                STDMETHOD(IsDirty)() override
    271271                {
    272272                        _Z4(atlTraceCOM, 4, _T("...\n"));
    273273                        return m_pMoniker->IsDirty();
    274274                }
    275                 STDMETHOD(Load)(IStream* pStream) throw()
     275                STDMETHOD(Load)(IStream* pStream) override
    276276                {
    277277                        _Z4(atlTraceCOM, 4, _T("...\n"));
    278278                        return m_pMoniker->Load(pStream);
    279279                }
    280                 STDMETHOD(Save)(IStream* pStream, BOOL bClearDirty) throw()
     280                STDMETHOD(Save)(IStream* pStream, BOOL bClearDirty) override
    281281                {
    282282                        _Z4(atlTraceCOM, 4, _T("...\n"));
    283283                        return m_pMoniker->Save(pStream, bClearDirty);
    284284                }
    285                 STDMETHOD(GetSizeMax)(ULARGE_INTEGER* pnMaximalSize) throw()
     285                STDMETHOD(GetSizeMax)(ULARGE_INTEGER* pnMaximalSize) override
    286286                {
    287287                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    290290
    291291        // IMoniker
    292                 STDMETHOD(BindToObject)(IBindCtx* pBindCtx, IMoniker* pLeftMoniker, REFIID InterfaceIdentifier, VOID** ppvObject) throw()
     292                STDMETHOD(BindToObject)(IBindCtx* pBindCtx, IMoniker* pLeftMoniker, REFIID InterfaceIdentifier, VOID** ppvObject) override
    293293                {
    294294                        _Z4(atlTraceCOM, 4, _T("pBindCtx 0x%p, pLeftMoniker 0x%p, InterfaceIdentifier %ls\n"), pBindCtx, pLeftMoniker, _PersistHelper::StringFromInterfaceIdentifier(InterfaceIdentifier));
     
    303303                        return S_OK;
    304304                }
    305                 STDMETHOD(BindToStorage)(IBindCtx* pBindCtx, IMoniker* pLeftMoniker, REFIID InterfaceIdentifier, VOID** ppvObject) throw()
     305                STDMETHOD(BindToStorage)(IBindCtx* pBindCtx, IMoniker* pLeftMoniker, REFIID InterfaceIdentifier, VOID** ppvObject) override
    306306                {
    307307                        _Z4(atlTraceCOM, 4, _T("pBindCtx 0x%p, pLeftMoniker 0x%p, InterfaceIdentifier %ls\n"), pBindCtx, pLeftMoniker, _PersistHelper::StringFromInterfaceIdentifier(InterfaceIdentifier));
     
    327327                        return S_OK;
    328328                }
    329                 STDMETHOD(Reduce)(IBindCtx* pBindCtx, DWORD nDepth, IMoniker** ppLeftMoniker, IMoniker** ppReducedMoniker) throw()
     329                STDMETHOD(Reduce)(IBindCtx* pBindCtx, DWORD nDepth, IMoniker** ppLeftMoniker, IMoniker** ppReducedMoniker) override
    330330                {
    331331                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    340340                        return S_OK;
    341341                }
    342                 STDMETHOD(ComposeWith)(IMoniker* pRightMoniker, BOOL bOnlyIfNotGeneric, IMoniker** ppCompositeMoniker) throw()
     342                STDMETHOD(ComposeWith)(IMoniker* pRightMoniker, BOOL bOnlyIfNotGeneric, IMoniker** ppCompositeMoniker) override
    343343                {
    344344                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    353353                        return S_OK;
    354354                }
    355                 STDMETHOD(Enum)(BOOL bForward, IEnumMoniker** ppEnumMoniker) throw()
     355                STDMETHOD(Enum)(BOOL bForward, IEnumMoniker** ppEnumMoniker) override
    356356                {
    357357                        _Z4(atlTraceCOM, 4, _T("bForward %d\n"), bForward);
     
    366366                        return S_OK;
    367367                }
    368                 STDMETHOD(IsEqual)(IMoniker* pMoniker) throw()
     368                STDMETHOD(IsEqual)(IMoniker* pMoniker) override
    369369                {
    370370                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    379379                        return S_OK;
    380380                }
    381                 STDMETHOD(Hash)(DWORD* pnHashValue) throw()
     381                STDMETHOD(Hash)(DWORD* pnHashValue) override
    382382                {
    383383                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    392392                        return S_OK;
    393393                }
    394                 STDMETHOD(IsRunning)(IBindCtx* pBindCtx, IMoniker* pLeftMoniker, IMoniker* pNewlyRunning) throw()
     394                STDMETHOD(IsRunning)(IBindCtx* pBindCtx, IMoniker* pLeftMoniker, IMoniker* pNewlyRunning) override
    395395                {
    396396                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    405405                        return S_OK;
    406406                }
    407                 STDMETHOD(GetTimeOfLastChange)(IBindCtx* pBindCtx, IMoniker* pLeftMoniker, FILETIME* pFileTime) throw()
     407                STDMETHOD(GetTimeOfLastChange)(IBindCtx* pBindCtx, IMoniker* pLeftMoniker, FILETIME* pFileTime) override
    408408                {
    409409                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    418418                        return S_OK;
    419419                }
    420                 STDMETHOD(Inverse)(IMoniker** ppMoniker) throw()
     420                STDMETHOD(Inverse)(IMoniker** ppMoniker) override
    421421                {
    422422                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    431431                        return S_OK;
    432432                }
    433                 STDMETHOD(CommonPrefixWith)(IMoniker* pMoniker, IMoniker** ppPrefixMoniker) throw()
     433                STDMETHOD(CommonPrefixWith)(IMoniker* pMoniker, IMoniker** ppPrefixMoniker) override
    434434                {
    435435                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    444444                        return S_OK;
    445445                }
    446                 STDMETHOD(RelativePathTo)(IMoniker* pMoniker, IMoniker** ppRelativeMoniker) throw()
     446                STDMETHOD(RelativePathTo)(IMoniker* pMoniker, IMoniker** ppRelativeMoniker) override
    447447                {
    448448                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    457457                        return S_OK;
    458458                }
    459                 STDMETHOD(GetDisplayName)(IBindCtx* pBindCtx, IMoniker* pLeftMoniker, LPOLESTR* ppszDisplayName) throw()
     459                STDMETHOD(GetDisplayName)(IBindCtx* pBindCtx, IMoniker* pLeftMoniker, LPOLESTR* ppszDisplayName) override
    460460                {
    461461                        _Z4(atlTraceCOM, 4, _T("pBindCtx 0x%p, pLeftMoniker 0x%p\n"), pBindCtx, pLeftMoniker);
     
    464464                                const HRESULT nResult = m_pMoniker->GetDisplayName(pBindCtx, pLeftMoniker, ppszDisplayName);
    465465                                if(SUCCEEDED(nResult))
    466                                         _Z4(atlTraceGeneral, 4, _T("nResult 0x%08x, *ppszDisplayName %s\n"), nResult, CString(*ppszDisplayName));
     466                                        _Z4(atlTraceGeneral, 4, _T("nResult 0x%08X, *ppszDisplayName %s\n"), nResult, CString(*ppszDisplayName));
    467467                                else
    468                                         _Z4(atlTraceGeneral, 4, _T("nResult 0x%08x\n"), nResult);
     468                                        _Z4(atlTraceGeneral, 4, _T("nResult 0x%08X\n"), nResult);
    469469                                return nResult;
    470470                        }
     
    475475                        return S_OK;
    476476                }
    477                 STDMETHOD(ParseDisplayName)(IBindCtx* pBindCtx, IMoniker* pLeftMoniker, LPOLESTR pszDisplayName, ULONG* pnEatenLength, IMoniker** ppOutputMoniker) throw()
     477                STDMETHOD(ParseDisplayName)(IBindCtx* pBindCtx, IMoniker* pLeftMoniker, LPOLESTR pszDisplayName, ULONG* pnEatenLength, IMoniker** ppOutputMoniker) override
    478478                {
    479479                        _Z4(atlTraceCOM, 4, _T("pBindCtx 0x%p, pLeftMoniker 0x%p, pszDisplayName %s\n"), pBindCtx, pLeftMoniker, CString(pszDisplayName));
     
    488488                        return S_OK;
    489489                }
    490                 STDMETHOD(IsSystemMoniker)(DWORD* pnSystemMonikerType) throw()
     490                STDMETHOD(IsSystemMoniker)(DWORD* pnSystemMonikerType) override
    491491                {
    492492                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    539539
    540540        // IEnumMoniker
    541                 STDMETHOD(Next)(ULONG nElementCount, IMoniker** ppMoniker, ULONG* pnFetchedElementCount) throw()
     541                STDMETHOD(Next)(ULONG nElementCount, IMoniker** ppMoniker, ULONG* pnFetchElementCount) override
    542542                {
    543543                        _Z4(atlTraceCOM, 4, _T("nElementCount %d\n"), nElementCount);
    544544                        _ATLTRY
    545545                        {
    546                                 const HRESULT nNextResult = m_pEnumMoniker->Next(nElementCount, ppMoniker, pnFetchedElementCount);
    547                                 _Z4(atlTraceGeneral, 4, _T("nNextResult 0x%08x, *pnFetchedElementCount %s\n"), nNextResult, pnFetchedElementCount ? (LPCTSTR) AtlFormatString(_T("%d"), *pnFetchedElementCount) : _T("(null)"));
     546                                const HRESULT nNextResult = m_pEnumMoniker->Next(nElementCount, ppMoniker, pnFetchElementCount);
     547                                CRoArrayT<CString> Array;
     548                                if(pnFetchElementCount)
     549                                        Array.Add(AtlFormatString(_T("*pnFetchElementCount %d"), *pnFetchElementCount));
     550                                _Z4(atlTraceGeneral, 4, _T("nNextResult 0x%08X, %s\n"), nNextResult, _StringHelper::Join(Array, _T(", ")));
    548551                                if(SUCCEEDED(nNextResult))
    549552                                {
    550553                                        ULONG nFetchedElementCount = nElementCount;
    551                                         if(nNextResult != S_OK && pnFetchedElementCount)
    552                                                 nFetchedElementCount = *pnFetchedElementCount;
    553                                         for(SIZE_T nIndex = 0; nIndex < nFetchedElementCount; nIndex++)
     554                                        if(nNextResult != S_OK && pnFetchElementCount)
     555                                                nFetchedElementCount = *pnFetchElementCount;
     556                                        for(ULONG nIndex = 0; nIndex < nFetchedElementCount; nIndex++)
    554557                                        {
    555558                                                CComPtr<IMoniker>& pMoniker = reinterpret_cast<CComPtr<IMoniker>&>(ppMoniker[nIndex]);
     
    569572                        return S_OK;
    570573                }
    571                 STDMETHOD(Skip)(ULONG nElementCount) throw()
     574                STDMETHOD(Skip)(ULONG nElementCount) override
    572575                {
    573576                        _Z4(atlTraceCOM, 4, _T("nElementCount %d\n"), nElementCount);
     
    582585                        return S_OK;
    583586                }
    584                 STDMETHOD(Reset)() throw()
     587                STDMETHOD(Reset)() override
    585588                {
    586589                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    595598                        return S_OK;
    596599                }
    597                 STDMETHOD(Clone)(IEnumMoniker** ppEnumMoniker) throw()
     600                STDMETHOD(Clone)(IEnumMoniker** ppEnumMoniker) override
    598601                {
    599602                        _Z4(atlTraceCOM, 4, _T("...\n"));
     
    627630                return S_OK;
    628631        }
    629         static HRESULT WINAPI QuerySystemDeviceEnumInterface(VOID* pvInstance, REFIID InterfaceIdentifier, VOID** ppvObject, DWORD)
     632        static HRESULT WINAPI QuerySystemDeviceEnumInterface(VOID* pvInstance, REFIID InterfaceIdentifier, VOID** ppvObject, DWORD_PTR)
    630633        {
    631634                return ((CSystemDeviceEnumeratorSpy*) pvInstance)->QuerySystemDeviceEnumInterface(InterfaceIdentifier, ppvObject);
     
    634637public:
    635638// CSystemDeviceEnumeratorSpyT
    636         static LPCTSTR GetOriginalLibraryName() throw()
     639        static LPCTSTR GetOriginalLibraryName()
    637640        {
    638641                return _T("devenum.dll");
     
    642645                return _StringHelper::GetLine(T::IDR, 2);
    643646        }
    644         static HRESULT WINAPI UpdateRegistry(BOOL bRegister) throw()
     647        static HRESULT WINAPI UpdateRegistry(BOOL bRegister)
    645648        {
    646649                _Z2(atlTraceRegistrar, 2, _T("bRegister %d\n"), bRegister);
     
    655658                return S_OK;
    656659        }
    657         CSystemDeviceEnumeratorSpyT() throw() :
     660        CSystemDeviceEnumeratorSpyT() :
    658661                m_hDevEnumModule(NULL)
    659662        {
    660663                _Z4_THIS();
    661664        }
    662         ~CSystemDeviceEnumeratorSpyT() throw()
     665        ~CSystemDeviceEnumeratorSpyT()
    663666        {
    664667                _Z4_THIS();
    665668        }
    666         HRESULT FinalConstruct() throw()
     669        HRESULT FinalConstruct()
    667670        {
    668671                _ATLTRY
     
    670673                        TCHAR pszPath[MAX_PATH] = { 0 };
    671674                        _W(GetModuleFileName(NULL, pszPath, DIM(pszPath)));
    672                         _Z4(atlTraceRefcount, 4, _T("pszPath \"%s\", this 0x%08x, m_dwRef %d\n"), pszPath, this, m_dwRef);
     675                        _Z4(atlTraceRefcount, 4, _T("pszPath \"%s\", this 0x%p, m_dwRef %d\n"), pszPath, this, m_dwRef);
    673676                        const HINSTANCE hModule = CoLoadLibrary(const_cast<LPOLESTR>((LPCOLESTR) CT2COLE(GetOriginalLibraryName())), TRUE);
    674677                        _ATLTRY
     
    704707                return S_OK;
    705708        }
    706         VOID FinalRelease() throw()
    707         {
    708                 _Z5(atlTraceRefcount, 5, _T("m_dwRef 0x%x\n"), m_dwRef);
    709                 m_pSystemDeviceEnum = NULL;
    710                 m_pCreateDevEnum = NULL;
     709        VOID FinalRelease()
     710        {
     711                _Z5(atlTraceRefcount, 5, _T("m_dwRef 0x%X\n"), m_dwRef);
     712                m_pSystemDeviceEnum.Release();
     713                m_pCreateDevEnum.Release();
    711714                if(m_hDevEnumModule)
    712715                {
     
    717720        static CString FormatDeviceCategory(const GUID& DeviceCategory)
    718721        {
    719                 static const struct { const GUID* pIdentifier; LPCSTR pszName; } g_pMap[] =
     722                static const struct
     723                {
     724                        const GUID* pIdentifier;
     725                        LPCSTR pszName;
     726                } g_pMap[] =
    720727                {
    721728                        #define A(x) { &x, #x },
     
    735742                        #undef A
    736743                };
    737                 for(SIZE_T nIndex = 0; nIndex < DIM(g_pMap); nIndex++)
    738                         if(*g_pMap[nIndex].pIdentifier == DeviceCategory)
    739                                 return CString(g_pMap[nIndex].pszName);
     744                for(auto&& Item: g_pMap)
     745                        if(*Item.pIdentifier == DeviceCategory)
     746                                return CString(Item.pszName);
    740747                return CString(_PersistHelper::StringFromIdentifier(DeviceCategory));
    741748        }
     
    744751
    745752// ICreateDevEnum
    746         STDMETHOD(CreateClassEnumerator)(REFCLSID DeviceCategory, IEnumMoniker** ppEnumMoniker, DWORD nFlags) throw()
    747         {
    748                 _Z4(atlTraceCOM, 4, _T("DeviceCategory %s, nFlags 0x%x\n"), FormatDeviceCategory(DeviceCategory), nFlags);
     753        STDMETHOD(CreateClassEnumerator)(REFCLSID DeviceCategory, IEnumMoniker** ppEnumMoniker, DWORD nFlags) override
     754        {
     755                _Z4(atlTraceCOM, 4, _T("DeviceCategory %s, nFlags 0x%X\n"), FormatDeviceCategory(DeviceCategory), nFlags);
    749756                _ATLTRY
    750757                {
    751                         __C(m_pCreateDevEnum->CreateClassEnumerator(DeviceCategory, ppEnumMoniker, nFlags));
     758                        const HRESULT nCreateClassEnumeratorResult = m_pCreateDevEnum->CreateClassEnumerator(DeviceCategory, ppEnumMoniker, nFlags);
     759                        __C(nCreateClassEnumeratorResult);
     760                        _D(nCreateClassEnumeratorResult == S_OK, nCreateClassEnumeratorResult);
    752761                        CComPtr<IEnumMoniker>& pEnumMoniker = reinterpret_cast<CComPtr<IEnumMoniker>&>(*ppEnumMoniker);
    753762                        if(pEnumMoniker)
    754763                        {
    755                                 #pragma region Trace Monikers
     764                                #pragma region Trace Moniker
    756765                                __C(pEnumMoniker->Reset());
    757                                 CComPtr<IMoniker> pMoniker;
    758                                 while(pEnumMoniker->Next(1, &pMoniker, NULL) == S_OK)
     766                                for(; ; )
    759767                                {
    760                                         _Z4(atlTraceCOM, 4, _T("pMoniker %ls\n"), _FilterGraphHelper::GetMonikerDisplayName(pMoniker));
     768                                        CComPtr<IMoniker> pMoniker;
     769                                        ULONG nElementCount;
     770                                        if(pEnumMoniker->Next(1, &pMoniker, &nElementCount) != S_OK)
     771                                                break;
     772                                        _Z4(atlTraceGeneral, 4, _T("pMoniker %ls\n"), _FilterGraphHelper::GetMonikerDisplayName(pMoniker));
    761773                                        CComPtr<IBindCtx> pBindCtx;
    762774                                        __C(CreateBindCtx(0, &pBindCtx));
     
    767779                                        const CStringW sDevicePath = _FilterGraphHelper::ReadPropertyBagString(pPropertyBag, OLESTR("DevicePath"));
    768780                                        _Z4(atlTraceCOM, 4, _T("sFriendlyName \"%ls\", sDescription \"%ls\", sDevicePath \"%ls\"\n"), sFriendlyName, sDescription, sDevicePath);
    769                                         pMoniker.Release();
    770781                                }
    771782                                __C(pEnumMoniker->Reset());
Note: See TracChangeset for help on using the changeset viewer.