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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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.