DirectShow Filter Rejection using IAMGraphBuilderCallBack - c++

Question

I've been attempting to implement IAMGraphBuilderCallback interface
I would imagine that the callback gets called everytime a candidate filter is found through intelligent-connect, but the call back in my impelmentation only gets called once during graph construction regardless of if I accept or reject the filter, which I'm not sure why.
I've used grapheditNext.exe to view the default setup when constructing the graph, which uses both the Microsoft DTV Video and Audio decoder.
(Graph without callBack)
I've implemented the Select Filter Method to reject both of the filter.
(Graph with callBack)
Lav Video filter was inserted when viewed using grapheditNext remote graph and the select filter callback never gets called after. This behaviour brings me to conclude two problems with my current implementation.
even though multiple filters are inserted by intelligent connect (DTV Video and DTV Audio), the callback is only called once.
even when you reject the filter in a callback, the callback is not called for other filters that are proposed/inserted.
Update:
I've implemented manual connection method to Connect two filter. I've inserted a source filter, mp4 demux filter, video renderer and audio renderer. The connection sequence and its behavior is as follows:
Source Filter -> mp4 Demux (Direct Connect)
mp4 Demux -> Video Renderer
Callback happened once. Microsoft DTV video decoder was rejected with the callback. Lav filter was inserted after without triggering the callback.
mp4 Demux -> Audio Renderer
Microsoft DTV audio decoder was inserted without the callback.
The little test app I've wrote is as follows:
#include <iostream>
#include <dshow.h>
#include <Streams.h>
#include <Combase.h>
#include <vector>
#include <algorithm>
void insertCallBackHandle(IGraphBuilder* pGraph, IAMGraphBuilderCallback* pGraphBuilderCallBackWithExcluList);
class GraphBuilderCallBackWithExcluList : public IAMGraphBuilderCallback, public CUnknown
{
public:
DECLARE_IUNKNOWN
GraphBuilderCallBackWithExcluList()
: CUnknown(NAME("GraphBuilderCallback"), NULL)
{
}
virtual HRESULT STDMETHODCALLTYPE SelectedFilter(
/* [in] */ IMoniker *pMon);
{
GUID DTVVideo = { 0x212690FB, 0x83E5, 0x4526,{ 0x8F, 0xD7, 0x74, 0x47, 0x8B, 0x79, 0x39, 0xCD } };
GUID DTVAudio = { 0xE1F1A0B8, 0xBEEE, 0x490D,{ 0xBA, 0x7C, 0x06, 0x6C, 0x40, 0xB5, 0xE2, 0xB9 } };
std::vector<GUID> m_vFilterGuid;
m_vFilterGuid.push_back(DTVVideo);
m_vFilterGuid.push_back(DTVAudio);
IPropertyBag *pPropBag;
HRESULT hr = pMon->BindToStorage(0, 0, IID_IPropertyBag,
(void **)&pPropBag);
if (SUCCEEDED(hr))
{
VARIANT varName;
VariantInit(&varName);
hr = pPropBag->Read(L"CLSID", &varName, 0);
if (SUCCEEDED(hr))
{
LPCWSTR name = varName.bstrVal ? varName.bstrVal : L"";
GUID classIdOfFilter;;
HRESULT hr = CLSIDFromString(name,(LPCLSID)&classIdOfFilter);
if (SUCCEEDED(hr))
{
auto it = std::find_if(m_vFilterGuid.begin(), m_vFilterGuid.end(), [&classIdOfFilter](const GUID excluFilter) {return excluFilter == classIdOfFilter; });
if (it == m_vFilterGuid.end())
{
VariantClear(&varName);
pPropBag->Release();
return S_OK;
}
else
{
VariantClear(&varName);
pPropBag->Release();
return E_FAIL;
}
}
else
{
VariantClear(&varName);
pPropBag->Release();
return E_FAIL;
}
}
else
{
VariantClear(&varName);
pPropBag->Release();
return E_FAIL;
}
}
else
{
pPropBag->Release();
return E_FAIL;
}
}
virtual HRESULT STDMETHODCALLTYPE CreatedFilter(
/* [in] */ IBaseFilter *pFil)
{
return S_OK;
}
STDMETHOD(NonDelegatingQueryInterface)(REFIID iid, void** ppv)
{
if (iid == __uuidof(IAMGraphBuilderCallback))
return GetInterface((IAMGraphBuilderCallback*)this, ppv);
return CUnknown::NonDelegatingQueryInterface(iid, ppv);
}
};
int main()
{
HRESULT hr = CoInitialize(NULL);
if (FAILED(hr))
{
std::cout << "Failed to initialise directshow";
}
GraphBuilderCallBackWithExcluList* pGraphBuilderCallBackWithExcluList = new GraphBuilderCallBackWithExcluList;
IGraphBuilder *pGraph;
hr = CoCreateInstance(CLSID_FilterGraph, NULL,
CLSCTX_INPROC_SERVER, IID_IGraphBuilder, (void **)&pGraph);
if (FAILED(hr))
{
std::cout << "Failed to create filter graph instance";
}
IMediaControl *pControl;
IMediaEvent *pEvent;
hr = pGraph->QueryInterface(IID_IMediaControl, (void **)&pControl);
if (FAILED(hr))
{
std::cout << "Failed to query interface media control";
}
hr = pGraph->QueryInterface(IID_IMediaEvent, (void **)&pEvent);
if (FAILED(hr))
{
std::cout << "Failed to query interface media event";
}
insertCallBackHandle(pGraph, pGraphBuilderCallBackWithExcluList);
IBaseFilter * pFilter0 = NULL;
GUID fileSource = { 0xE436EBB5 ,0x524F ,0x11CE, { 0x9F,0x53, 0x00,0x20,0xAF, 0x0B, 0xA7, 0x70} };
hr = CoCreateInstance(fileSource, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pFilter0));
if (FAILED(hr))
{
std::cout << "Failed to create mp4Demux filter";
}
IFileSourceFilter * pFilterSourceFitler;
hr = pFilter0->QueryInterface(&pFilterSourceFitler);
if (FAILED(hr))
{
std::cout << "Failed to query interface IFileSourceFilter";
}
LPCOLESTR FileSourceUri = L"D:\\Test.mp4";
hr = pFilterSourceFitler->Load(FileSourceUri, NULL);
if (FAILED(hr))
{
std::cout << "Failed to load fileSource uri";
}
IBaseFilter * pFilter1 = NULL;
GUID mp4Demux = { 0x025BE2E4 , 0x1787 , 0x4DA4,{ 0xA5, 0x85, 0xC5,0xB2,0xB9,0xEE,0xB5,0x7C } };
hr = CoCreateInstance(mp4Demux, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pFilter1));
if (FAILED(hr))
{
std::cout << "Failed to create mp4Demux filter";
}
IBaseFilter * pFilter2 = NULL;
GUID videoRenderer = { 0xB87BEB7B , 0x8D29 , 0x423F, { 0xAE, 0x4D, 0x65,0x82,0xC1,0x01,0x75,0xAC }};
hr = CoCreateInstance(videoRenderer, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pFilter2));
if (FAILED(hr))
{
std::cout << "Failed to create videoRenderer filter";
}
IBaseFilter * pFilter3 = NULL;
GUID audioRenderer = { 0x79376820 , 0x07D0 ,0x11CF, {0xA2,0x4D,0x00,0x20,0xAF,0xD7,0x97,0x67} };
hr = CoCreateInstance(audioRenderer, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pFilter3));
if (FAILED(hr))
{
std::cout << "Failed to create audioRenderer filter";
}
hr = pGraph->AddFilter(pFilter0, NULL);
if (FAILED(hr))
{
std::cout << "Failed to add mp4Demux filter";
}
hr = pGraph->AddFilter(pFilter1, NULL);
if (FAILED(hr))
{
std::cout << "Failed to add mp4Demux filter";
}
hr = pGraph->AddFilter(pFilter2, NULL);
if (FAILED(hr))
{
std::cout << "Failed to add videoRenderer filter";
}
hr = pGraph->AddFilter(pFilter3, NULL);
if (FAILED(hr))
{
std::cout << "Failed to add audioRenderer filter";
}
// Auto connect
// Connect FileSource to mp4Demux
hr = ConnectFilters(pGraph, pFilter0, pFilter1);
if (FAILED(hr))
{
std::cout << "Failed to connect FilterSource to mp4Demux" << hr;
}
// Connect mp4Demux to Video Renderer
hr = ConnectFilters(pGraph, pFilter1, pFilter2);
if (FAILED(hr))
{
std::cout << "Failed to connect mp4Demux to videoRenderer";
}
// Connect mp4Demux to Audio Renderer
hr = ConnectFilters(pGraph, pFilter1, pFilter3);
if (FAILED(hr))
{
std::cout << "Failed to connect mp4Demux to audioRenderer";
}
hr = pControl->Run();
if (FAILED(hr))
{
std::cout << "Failed to run graph";
}
long evCode = 0;
pEvent->WaitForCompletion(INFINITE, &evCode);
pControl->Release();
pEvent->Release();
pGraph->Release();
CoUninitialize();
return 0;
}
void insertCallBackHandle(IGraphBuilder* pGraph,IAMGraphBuilderCallback* pGraphBuilderCallBackWithExcluList)
{
IObjectWithSite* iObjectWithSite;
HRESULT hr = pGraph->QueryInterface(&iObjectWithSite);
if (FAILED(hr))
{
std::cout << "Failed to query interface iObjectWithSite";
}
hr = iObjectWithSite->SetSite(pGraphBuilderCallBackWithExcluList);
if (FAILED(hr))
{
std::cout << "Failed to set site";
}
if (iObjectWithSite)
{
iObjectWithSite->Release();
}
}
So i missed the crucial point in COM implementation on reference count. The problem with the above implementation is that the reference count of the IAMGraphBuilderCallback Object is always zero, so the callback was called once and possibly destroyed after by directshow because of 0 reference count and never gets called again. With the above implementation, the work around I came up with is to manually increment the reference count when creating the object
GraphBuilderCallBackWithExcluList* pGraphBuilderCallBackWithExcluList = new GraphBuilderCallBackWithExcluList;
pGraphBuilderCallBackWithExcluList->NonDelegatingAddRef()
and calling
pGraphBuilderCallBackWithExcluList->NonDelegatingRelease()
Alternatively I found the code to fake the reference count with the following implementation:
class GraphBuilderCallBackWithExcluList : public IAMGraphBuilderCallback
{
public:
GraphBuilderCallBackWithExcluList()
{
}
virtual HRESULT STDMETHODCALLTYPE SelectedFilter(
/* [in] */ IMoniker *pMon)
{
GUID DTVVideo = { 0x212690FB, 0x83E5, 0x4526,{ 0x8F, 0xD7, 0x74, 0x47, 0x8B, 0x79, 0x39, 0xCD } };
GUID DTVAudio = { 0xE1F1A0B8, 0xBEEE, 0x490D,{ 0xBA, 0x7C, 0x06, 0x6C, 0x40, 0xB5, 0xE2, 0xB9 } };
std::vector<GUID> m_vFilterGuid;
m_vFilterGuid.push_back(DTVVideo);
m_vFilterGuid.push_back(DTVAudio);
IPropertyBag *pPropBag;
HRESULT hr = pMon->BindToStorage(0, 0, IID_IPropertyBag,
(void **)&pPropBag);
if (SUCCEEDED(hr))
{
VARIANT varName;
VariantInit(&varName);
hr = pPropBag->Read(L"CLSID", &varName, 0);
if (SUCCEEDED(hr))
{
LPCWSTR name = varName.bstrVal ? varName.bstrVal : L"";
GUID classIdOfFilter;;
HRESULT hr = CLSIDFromString(name, (LPCLSID)&classIdOfFilter);
if (SUCCEEDED(hr))
{
auto it = std::find_if(m_vFilterGuid.begin(), m_vFilterGuid.end(), [&classIdOfFilter](const GUID excluFilter) {return excluFilter == classIdOfFilter; });
if (it == m_vFilterGuid.end())
{
VariantClear(&varName);
pPropBag->Release();
return S_OK;
}
else
{
VariantClear(&varName);
pPropBag->Release();
return E_FAIL;
}
}
else
{
VariantClear(&varName);
pPropBag->Release();
return E_FAIL;
}
}
else
{
VariantClear(&varName);
pPropBag->Release();
return E_FAIL;
}
}
else
{
pPropBag->Release();
return E_FAIL;
}
}
virtual HRESULT STDMETHODCALLTYPE CreatedFilter(
/* [in] */ IBaseFilter *pFil)
{
return S_OK;
}
/**
* #brief Fake out any COM ref counting
*/
STDMETHODIMP_(ULONG) AddRef() { return 2; }
/**
* #brief Fake out any COM ref counting
*/
STDMETHODIMP_(ULONG) Release() { return 1; }
/**
* #brief Fake out any COM ref QI'ing
*/
STDMETHODIMP QueryInterface(REFIID riid, void ** ppv)
{
CheckPointer(ppv, E_POINTER);
if (riid == IID_IAMGraphBuilderCallback || riid == IID_IUnknown)
{
*ppv = (void *) static_cast<IAMGraphBuilderCallback*> (this);
return NOERROR;
}
return E_NOINTERFACE;
}
};