[
    db_command("SELECT ServerData FROM Server WHERE Server = ?")
]
class CGetServerData
{
public:
    [ db_param(1) ] LONG m_nServer;
    [ db_column(1, length = "m_nDataLength") ] ISequentialStream* m_pDataStream; DBLENGTH m_nDataLength;
};

It worked great with Visual Studio .NET 2003 and it failed to work with later releases. There are questions on internet about the problem, but there few answers if any. As I recently had to convert a project from 2003 version of the compiler to Visual Studio 2008, the problem was finally to be resolved.

The first problem, and an easier one was that you have to put attribute values in quotes. ‘Db_column(1, …’ has to be “db_column(”1″, …’ and besides going through code and making changes, it appeared that if earlier implementation managed to distinguish between ordinal column numbers and field names by checking provided argument to be a number or a string, with Visual Studio 2008 one has to provide strings at any time. If the string is a valid integer, the attribute processor will treat it as an ordinal number.

So if you want your code to be both compiled with 2003 and 2008 versions of Visual Studio, you have a puzzle now: you have to use quotes, but version 2003 will no longer treat the argument as ordinal number. Note that version 2003 will keep compiling the code and the problem will only come up on runtime. As eventually in the project of interest support for version 2003 will be dropped, I was not interested in this problem anymore.

The main problem is related to use of ISequentialStream pointer variable as a data field. Again, it worked great with Visual Studio .NET 2003, it no longer did with Visual Studio .NET 2005. First of all, you cannot use this data type anymore, as templates don’t provide an automatic mapper to OLE DB Type.  Instead of ISequentialStream you have to use IUnknown and QueryInterface the provided pointer before use.

This solves compilation problem, but still the code does not work on runtime. An attempt to bind to the column using such accessor results in DB_E_ERRORSOCCURRED (0×80040E21) “Multiple-step OLE DB operation generated errors. Check each OLE DB status value, if available. No work was done.” A more thorough look gave DBBINDSTATUS_BADBINDINFO (3) for binding to the column of interest.

The cause of the problem is missing DBOBJECT object pointer in the corresponding DBBINDING::pObject field. Why? A general rule for troubleshooting this kind of problem is to enable expanding attributed source code to check what exactly is generated.

The problem is that unlike previous versions of Visual Studio, ATL attributed code provider is no longer generates correct OLEDB template map code for BLOB fields. And this results in incorrectly generated DBBINDING structure, inability to bind to column and as a final result in DB_E_ERRORSOCCURRED error code which does not give a sufficient clue on the root of the problem.

While the map needs a BLOB_* macro for the BLOB column (e.g. BLOB_ENTRY or BLOB_ENTRY_LENGTH), the generated code uses _COLUMN_ENTRY_CODE instead. This causes missing (null) DBBINDING::pObject field in the binding structure:

BEGIN_ACCESSOR_MAP(_CGetServerDataAccessor, 1)
    BEGIN_ACCESSOR(0, true)
        //_COLUMN_ENTRY_CODE(1, DBTYPE_IUNKNOWN, _SIZE_TYPE(m_pDataUnknown), 0, 0, offsetbuf(m_pDataUnknown), offsetbuf(m_nDataLength), 0)
        BLOB_ENTRY_LENGTH(1, __uuidof(ISequentialStream), STGM_READ, m_pDataUnknown, m_nDataLength)
    END_ACCESSOR()
END_ACCESSOR_MAP()

So it appears that to fix the problem, an attributed class needs to be replaced with a non-attributed update. To ease the conversion one can expand attributed source and use it as a base for the non-attributed class.

And example of such correction/replacement is provided below for a reference.

#if TRUE
class _CGetServerDataAccessor
{
public:

DEFINE_COMMAND_EX(_CGetServerDataAccessor, L"SELECT Data FROM Server WHERE Server = ?")

BEGIN_PARAM_MAP(_CGetServerDataAccessor)
    SET_PARAM_TYPE(DBPARAMIO_INPUT)
    //_COLUMN_ENTRY_CODE(1, _OLEDB_TYPE(m_nServer), _SIZE_TYPE(m_nServer), 0, 0, offsetbuf(m_nServer), 0, 0)
    COLUMN_ENTRY(1, m_nServer)
END_PARAM_MAP()

BEGIN_ACCESSOR_MAP(_CGetServerDataAccessor, 1)
    BEGIN_ACCESSOR(0, true)
        //_COLUMN_ENTRY_CODE(1, DBTYPE_IUNKNOWN, _SIZE_TYPE(m_pDataUnknown), 0, 0, offsetbuf(m_pDataUnknown), offsetbuf(m_nDataLength), 0)
        BLOB_ENTRY_LENGTH(1, __uuidof(ISequentialStream), STGM_READ, m_pDataUnknown, m_nDataLength)
    END_ACCESSOR()
END_ACCESSOR_MAP()

public:
    LONG m_nServer;
    IUnknown* m_pDataUnknown;
    DBLENGTH m_nDataLength;
};

class CGetServerData :
    public CCommand<CAccessor<_CGetServerDataAccessor> >
{
public:
// CGetServerData
    HRESULT OpenRowset(const CSession& Session, LPCWSTR pszCommand = NULL) throw()
    {
        if(!pszCommand)
            _V(_CGetServerDataAccessor::GetDefaultCommand(&pszCommand));
        return Open(Session, pszCommand, NULL);
    }
};
#else
[
    db_command("SELECT Data FROM Server WHERE Server = ?")
]
class CGetServerData
{
public:
    [ db_param("1") ] LONG m_nServer;
    [ db_column("1", length = "m_nDataLength") ] IUnknown* m_pDataUnknown; DBLENGTH m_nDataLength;
};
#endif

The filters behind that empower the sample are described in another post.

RenderHttpMjpegVideoIntoFiles01 sample takes an URL on the input to generate image/jpeg JPEG or multipart/x-mixed-replace M-JPEG stream. For example, it might be http://demo1.stardotcams.com/nph-mjpeg.cgi feed from a demo StarDot Technologies IP camera.

The application will create a new directory to write files into, and will save each new video frame received into new JPEG file.

Z:\MediaTools\Samples\RenderHttpMjpegVideoIntoFiles01\Release>RenderHttpMjpegVideoIntoFiles01.exe http://demo1.stardotcams.com/nph-mjpeg.cgi
URL: http://demo1.stardotcams.com/nph-mjpeg.cgi
Writing to directory: Z:\MediaTools\Samples\RenderHttpMjpegVideoIntoFiles01\Release\2010-05-12 22-07-37
Event: nCode EC_CLOCK_CHANGED 0xD, nParameter1 0x00000000, nParameter2 0x00000000
Event: nCode EC_PAUSED 0xE, nResult 0x00000000, nParameter2 0x00000000
[...]
^C

The application will generate the files and convert media sample time stamps into file time.

The DirectShow graph that implements the operation is the following:

The other sample RenderJpegFiles01 takes a directory path to look for JPEG files, e.g. generated by previous sample, and pushes them into DirectShow graph as a video feed. File times will be converted [back] to media sample times.

Z:\MediaTools\Samples\RenderJpegFiles01\Release>RenderJpegFiles01 "Z:\MediaTools\Samples\RenderHttpMjpegVideoIntoFiles01\Release\2010-05-12 22-07-37"
Directory: Z:\MediaTools\Samples\RenderHttpMjpegVideoIntoFiles01\Release\2010-05-12 22-07-37
Event: nCode EC_CLOCK_CHANGED 0xD, nParameter1 0x00000000, nParameter2 0x00000000
Event: nCode EC_PAUSED 0xE, nResult 0x00000000, nParameter2 0x00000000
Event: nCode EC_VMR_RECONNECTION_FAILED 0x55, nResult 0x80004005, nParameter2 0x00000000
Event: nCode EC_VMR_RENDERDEVICE_SET 0x53, RendererDeviceType 0x2, nParameter2 0x00000000
Event: nCode EC_VIDEO_SIZE_CHANGED 0xA, Extent 384x240, nParameter2 0x00000000
Event: nCode EC_COMPLETE 0x1, nResult 0x00000000, nParameter2 0x00000000
Event: nCode EC_ERRORABORT 0x3, nResult 0x80004005, nParameter2 0x00000000
Detected resolution change, new resolution is 1024x768, recreating filter graph...
Event: nCode EC_VMR_RECONNECTION_FAILED 0x55, nResult 0x80004005, nParameter2 0x00000000
Event: nCode EC_VMR_RENDERDEVICE_SET 0x53, RendererDeviceType 0x2, nParameter2 0x00000000
Event: nCode EC_VIDEO_SIZE_CHANGED 0xA, Extent 384x240, nParameter2 0x00000000
Event: nCode EC_CLOCK_CHANGED 0xD, nParameter1 0x00000000, nParameter2 0x00000000
Event: nCode EC_PAUSED 0xE, nResult 0x00000000, nParameter2 0x00000000

Download links:

• RenderHttpMjpegVideoIntoFiles01: source code, binary
• RenderJpegFiles01: source code, binary

Filter Graph Spy is offering three new interfaces that provide extensibility of the spy:

• IFilterGraphAddRemoveHook
• IFilterGraphConnectHook
• IFilterGraphStateControlHook

The interfaces are contained in the type library and can be imported using #import directive. An implementation of one or more of these interfaces will receive hook style calls corresponding to respective Filter Graph Manager calls, system wide including in context of other applications.

A COM object may be registered as a hook object with Spy and NoThreadSpy COM classes under predefined registry keys:

Spy will instantiate the registered hook objects and forward them the calls it receive, before passing them to system Filter Graph Manager object. A hook object has an option to override default processing, including, for example, inserting its own filter in between. For example, IFilterGraph::Reconnect call is implemented the following way:

STDMETHOD(Reconnect)(IPin* pPin) throw()
{
    _Z4(atlTraceCOM, 4, _T("...\n"));
    HOOK_PROLOG(CFilterGraphConnectHookHost)
        OnReconnect(pT, pPin, &bDefault);
    HOOK_EPILOG()
    return m_pInnerFilterGraph2->Reconnect(pPin);
}

Before passing the call to original Reconnect method, spy is iterating through associated hooks, passing them IFilterGraphConnectHook::OnReconnect call. Setting bDefault parameter to FALSE will prevent spy from passing the call to original method.

Included BdaHooks project shows a sample implementation of the hooking COM classes (note .rgs registration).

Filter Graph Spy is compatible with all current Windows operating systems, 32-bit and 64-bit (x64), in particular including:

• Windows 7
• Windows Server 2008
• Windows Vista
• Windows Server 2003
• Windows XP
• Windows 2000

NOTE: DirectShow Filter Graph Spy is NOT suitable for production environment, it is NOT licensed to be redistributed to be a part of production state software item.

Partial Visual C++ .NET 2008 source code is available from SVN, release binary included (Win32, x64); installation instructions are in another post.

However, for Video Mixing Renderers, version 7 and 9, the preferred and recommended mode is windowless, where no IVideoWindow interface is available.

Note The IVMRWindowlessControl or IVMRWindowlessControl9 interface is now preferred over IVideoWindow. For more information, see Using Windowless Mode.

So in order to implement full screen mode it takes the application to attach Video Mixing Renderer filter to a private frameless window, to its entire client area and expand the window to entire monitor area.

The sample project FullScreenWindowlessVmrSample01 is illustrating this technique.

Main application dialog owns a special window to host renderer, implemented by CRendererDialog class.

class CRendererDialog :
    public CDialogImpl<CRendererDialog>
{
public:

    enum { IDD = IDD_RENDERER };

BEGIN_MSG_MAP_EX(CRendererDialog)
    MSG_WM_INITDIALOG(OnInitDialog)
    MSG_WM_DESTROY(OnDestroy)
    MSG_WM_ERASEBKGND(OnEraseBkgnd)
    MSG_WM_PAINT(OnPaint)
    MSG_WM_DISPLAYCHANGE(OnDisplayChange)
    MSG_WM_KEYDOWN(OnKeyDown)
    COMMAND_ID_HANDLER_EX(IDCANCEL, OnCancel)
END_MSG_MAP()

private:
    CMainDialog& m_Owner;
//...

The dialog template does not have a caption, it has no frame and has its window rectangle equal to client area. As a result, spanning the Video Mixing Renderer to the entire client area and proper positioning of the dialog window is showing video on the entire monitor.

ATLVERIFY(m_RendererDialog.Create(m_hWnd));
ATLVERIFY(m_RendererDialog.MoveWindow(MonitorData.m_Position));
m_RendererDialog.ShowWindow(SW_SHOWNORMAL);
// ...
ATLENSURE_SUCCEEDED(pVmrWindowlessControl->SetVideoClippingWindow(m_RendererDialog));
ATLENSURE_SUCCEEDED(pVmrWindowlessControl->SetVideoPosition(NULL, m_RendererDialog.GetVideoPosition()));

Visual C++ .NET 2008 source code is available from SVN, release binary included. The project is using ATL and WTL libraries.

http://code.assembla.com/…/VmrMixerBitmapSample01/…

VMR9AlphaBitmap AlphaBitmap;
ZeroMemory(&AlphaBitmap, sizeof AlphaBitmap);
AlphaBitmap.dwFlags = VMR9AlphaBitmap_hDC;
AlphaBitmap.hdc = Dc;
AlphaBitmap.rSrc = CRect(0, 0, 32, 32);
AlphaBitmap.rDest.left = (FLOAT) 0.75;
AlphaBitmap.rDest.top = (FLOAT) 0.75;
AlphaBitmap.rDest.right = (FLOAT) 0.95;
AlphaBitmap.rDest.bottom = (FLOAT) 0.95;
AlphaBitmap.fAlpha = 0.75;
const HRESULT nSetAlphaBitmapResult = pVmrMixerBitmap->SetAlphaBitmap(&AlphaBitmap);
ATLENSURE_SUCCEEDED(nSetAlphaBitmapResult);

With a low FPS clip like clock.avi it is clear that the overlaid image is only updated with the next “main” video frame.

Visual C++ .NET 2008 source code is available from SVN, release binary included.

First of all, there is sample code at The March Hare’s website:

The IAMGraphBuilderCallback class can be used to remove problematic dshow filters when building a graph with intelligent connect.  This sample does not provide the UI to blacklist filters but will give you a better head start than the information in the documentation.  See the header file for an example of how to use it in your code.  Add your own code to the SelectedFilter or CreatedFilter methods to remove any unwanted filters.

The idea behind the method can be easily illustrated with a code snippet. Each time Filter Graph Manager considers trying a filter, before its instantiation it calls (if provided) IAMGraphBuilderCallback::SelectedFilter method, where there is an option to reject it (before it even was instantiated using CoCreateInstance).

The code snippet below checks selected filter and instructs to reject it if it is an FFDshow Audio Decoder filter.

// IAMGraphBuilderCallback
STDMETHOD(SelectedFilter)(IMoniker* pMoniker) throw()
{
    ATLTRACE(atlTraceCOM, 4, _T("...\n"));
    _ATLTRY
    {
        ATLASSERT(pMoniker);
        const CStringW sMonikerDisplayName = _FilterGraphHelper::GetMonikerDisplayName(pMoniker, NULL);
        ATLTRACE(atlTraceGeneral, 4, _T("sMonikerDisplayName %ls\n"), sMonikerDisplayName);
        static const LPCTSTR g_pszFfdshowAudioDecoderClassIdentifier = _T("{0F40E1E5-4F79-4988-B1A9-CC98794E6B55}");
        if(sMonikerDisplayName.Find(CStringW(g_pszFfdshowAudioDecoderClassIdentifier)) >= 0)
            return E_FAIL; // Die!
    }
    _ATLCATCH(Exception)
    {
        return Exception;
    }
    return S_OK;
}

CRegKey Key;
ATLENSURE_SUCCEEDED(HRESULT_FROM_WIN32(Key.Open(HKEY_CLASSES_ROOT, pszKeyName, READ_CONTROL | WRITE_OWNER)));
CSecurityDesc AdministratorsOwnerSecurityDescriptor;
AdministratorsOwnerSecurityDescriptor.SetOwner(Sids::Admins());
ATLENSURE_SUCCEEDED(HRESULT_FROM_WIN32(Key.SetKeySecurity(OWNER_SECURITY_INFORMATION, &AdministratorsOwnerSecurityDescriptor)));

The code compiles fine, but on runtime it gives error 87 (ERROR_INVALID_PARAMETER, E_INVALIDARG) in the last line, returned from RegSetKeySecurity API call. My first guess was that ATL’s CSecurityDesc class for some reason prepared wrong descriptor which resulted in rejecting it as an argument. From the first glance it looks (not sure) that this class deals, to some extent, with structures itself rather than using API functions, so it could be that it results in something looking differently from expected by API calls.

Still the problem is in class itself and its cast from CSecurityDesc& to required SECURITY_DESCRIPTOR* type. The class only implements operator to automatically cast to const SECURITY_DESCRIPTOR* type, so the following line would not be passed by compiler:

Key.SetKeySecurity(OWNER_SECURITY_INFORMATION, AdministratorsOwnerSecurityDescriptor)

However &AdministratorsOwnerSecurityDescriptor is another level of indirection and hence SECURITY_DESCRIPTOR** type, which is passed by compiler, but results in indeed invalid argument.

So in order to correctly convert CSecurityDesc& to SECURITY_DESCRIPTOR* it can be done this way:

CRegKey Key;
ATLENSURE_SUCCEEDED(HRESULT_FROM_WIN32(Key.Open(HKEY_CLASSES_ROOT, pszKeyName, READ_CONTROL | WRITE_OWNER)));
CSecurityDesc AdministratorsOwnerSecurityDescriptor;
AdministratorsOwnerSecurityDescriptor.SetOwner(Sids::Admins());
ATLENSURE_SUCCEEDED(HRESULT_FROM_WIN32(Key.SetKeySecurity(OWNER_SECURITY_INFORMATION, const_cast<SECURITY_DESCRIPTOR*>((const SECURITY_DESCRIPTOR*) AdministratorsOwnerSecurityDescriptor))));

Filter graphs are published with a textual moniker item name of predefined format, which is recognized by GraphEdit or GraphStudio, or similar utilities as an item corresponding to a filter graph. A template for such a string is “FilterGraph %08x pid %08x“, which obviously only contains raw pointer address and process identifier, which only help a bit in looking up for proper graph interactively. However, it is important how exactly applications are recognizing filter graph related names. For example, GraphStudio does it the following way:

rot->EnumRunning(&emon);
emon->Reset();
while (emon->Next(1, &moniker, &f) == NOERROR) {

    // is this a graph object ?
    LPOLESTR    displayname;
    moniker->GetDisplayName(bindctx, NULL, &displayname);

    CString        name(displayname);
    if (name.Find(_T("!FilterGraph")) == 0) {

The items that match are then listed in GUI with an original string, which means that it is possible to provide an informational suffix to be able to locate the graph in a more convenient way, e.g. with a process image name, not only identifier (”; process: …” was appended to the item name):

GraphEdit is using another method and is more strict in selecting among available items. AFAIR earlier versions did not allow custom suffixes in item names, however the latest version still picks the items up from the global list. However, GraphEdit does not show graph’s original item name, so suffixes are merely useless with GraphEdit.

Filter Graph Spy utility was updated to automatically append process name suffix, which should be OK for both GrapEdit and GraphStudio. Still, the feature can be disabled through registry DWORD value named “Enable ROT Moniker Item Name Suffix” under HKEY_LOCAL_MACHINE\SOFTWARE\Alax.Info\Utilities. The value of zero, or missing, is the default behavior to enable suffixes. The value of 1 disables the feature, the value of 2 makes sure it is enabled.

static CConstIntegerRegistryValue g_nEnableRotMonikerItemNameSuffix(_T("Enable ROT Moniker Item Name Suffix")); // 0 Default, 1 Disable, 2 Enable
if(g_nEnableRotMonikerItemNameSuffix != 1)
{
    TCHAR pszPath[MAX_PATH] = { 0 };
    _W(GetModuleFileName(NULL, pszPath, DIM(pszPath)));
    CString sItemName = AtlFormatString(_T("%s; process: %s"), m_RunningFilterGraph.GetDefaultMonikerItemName(GetControllingUnknown()), FindFileName(pszPath));
    m_RunningFilterGraph.SetFilterGraph(GetControllingUnknown(), CStringW(sItemName));
} else
    m_RunningFilterGraph.SetFilterGraph(GetControllingUnknown())

A partial Visual C++ .NET 2008 source code is available from SVN, release binary included.

From past experience, I already knew that some bugs are definitely involved but their effect was yet unexplored. For a testbed application, I took good old FrameRateSample02 application, which generates multiple video feeds and routes it to video renderers:

With new source video choices the application is capable of constructing filter graphs that use a private DMO (that is hosted inside the executable) wrapped with DMO Wrapper Filter, with a graph topology shown below:

The DMO does not do any processing, except support for extended strides while copying original data into buffer streamed to video renderer. Extended strides for a planar YUV format is a bit tricky. Are they supported at all? Yes, they are and video renderer might still request an extended stride and in which case origial MxN video needs to be copied into (M+P)xN buffer. Unlike packed pixel format, unused space is distributed in a bit different way but still very much similarly: output buffer is still a regular (M+P)xN rectangle, where the effective picture of size MxN should be copied into top left corner.

The problem I was aware of from past experience showed up immediately once the filters connected. After a dynamic format change initiated by the VMR, the filters report different connection media types. DMO Wrapper Filter still shows original connection time connection media type, while Video Mixing Renderer Filter shows media type it switched to.

This looks like DMO Wrapper Filter bug, but was yet to check if it still handles the new media type properly and passes the format change to the underlying DMO object. Taking into consideration the extent DMOs are used by Microsoft, it had to, thought I never met this in the MSDN documentation.

Further debugging revealed that DMO Wrapper Filter does handle the media type change and forward it to the DMO through IMediaObject::SetOutputType method. This happens when DMO already received its first input, and immediately before following IMediaObject::ProcessOutput method call:

rodmo.h(293) : CMediaObjectT<class CVideoDmo>::AllocateStreamingResources: ...
rodshow.h(2716) : CBaseFilterT<class CMainDialog::CSourceFilter>::Pause: ...
rodshow.h(2722) : CBaseFilterT<class CMainDialog::CSourceFilter>::Pause: m_State 0
rodshow.h(2730) : CBaseFilterT<class CMainDialog::CSourceFilter>::Pause: m_State 1
rodshow.h(2784) : CBaseFilterT<class CMainDialog::CSourceFilter>::GetState: nTimeout 0
rodmo.h(679) : CSimpleMediaObjectT<class CVideoDmo,1>::GetInputStatus: nInputStreamIndex 0
rodmo.h(702) : CSimpleMediaObjectT<class CVideoDmo,1>::ProcessInput: nInputStreamIndex 0, nFlags 0x1
rodmo.h(527) : CSimpleMediaObjectT<class CVideoDmo,1>::SetOutputType: nOutputStreamIndex 0, nFlags 0x0
rodmo.h(727) : CSimpleMediaObjectT<class CVideoDmo,1>::ProcessOutput: nFlags 0x1, nOutputBufferCount 1

So, the media type change is handled and the problem is only limited to reporting wrong (original) media type off the wrapper filter output pin.

Investigation of filter connection however brought up another interesting fact, memory allocator properties:

As the filters switched to a new media type, with extended strides, the memory allocator should obviously have been updated accordingly, in order to support larger buffer. However current memory allocator properties indicate old buffer size of 460,800 bytes, while new media type assumes 737,280 buffer size at the very least. The samples are however streamed fine, so the issue is also limited to incorrectly reported size.

This memory allocator is managed by the Video Mixing Renderer Filter, so the problem seems to be relating to it.

Good news however was that video was streamed and displayed correctly.

One thing that deserves special attention is making a DMO private. I already wrote another post on private DMOs some time ago, and this time the sample shows even a better way in case one does not need the DMO available for Intelligent Connect (in which case DMORegister call along with administrative privileges will be required),  just for a private instantiation. DMO is typically created by CoCreateInstance from inside the DMO Wrapper Filter, e.g. using IDMOWrapperFilter::Init method, so it is necessary to either register COM class, or… just register its class object for the process using CoRegisterClassObject.

There is no need for direct usage of API since ATL already wrapped the calls and we are to take advantage of what is already available. First of all, the DMO class requires certain CLSID, because we don’t have one typically declared in IDL. A good place for attaching CLSID is class declaration and __declspec keyword:

class __declspec(uuid("88B976BE-EEE6-45b1-A21B-42A941DF8819")) ATL_NO_VTABLE CVideoDmo :
    public CComObjectRootEx<CComMultiThreadModelNoCS>,
    public CComCoClass<CVideoDmo>,
    public CSimpleMediaObjectT<CVideoDmo, 1>
{

Further a COM class is typically referenced into module’s object map byan OBJECT_ENTRY_AUTO macro:

//OBJECT_ENTRY_AUTO(__uuidof(VideoDmo), CVideoDmo)

But we don’t need this this time as we don’t need standard COM registration for the class. We will register its class object manually and temporarily, at the time of DMO initialization:

CComQIPtr<IBaseFilter> pBaseFilter;
CVideoDmo* pVideoDmo;
{
    BEGIN_OBJECT_MAP(g_pObjectMap)
        OBJECT_ENTRY(__uuidof(CVideoDmo), CVideoDmo)
    END_OBJECT_MAP()
    ATLASSERT(DIM(g_pObjectMap) == 2 && !g_pObjectMap[1].pclsid);
    ATLENSURE_SUCCEEDED(g_pObjectMap[0].RegisterClassObject(CLSCTX_INPROC_SERVER, REGCLS_SINGLEUSE));
    _ATLTRY
    {
        CComPtr<IDMOWrapperFilter> pDmoWrapperFilter = ConstructDmoWrappedFilter(__uuidof(CVideoDmo), CVideoDmo::GetCategory());
        pBaseFilter = pDmoWrapperFilter;
        ATLENSURE_THROW(pBaseFilter, E_NOINTERFACE);
        CComQIPtr<IMediaObject> pMediaObject = pDmoWrapperFilter;
        ATLENSURE_THROW(pMediaObject, E_NOINTERFACE);
        pVideoDmo = static_cast<CVideoDmo*>((IMediaObject*) pMediaObject);
    }
    _ATLCATCHALL()
    {
        ATLVERIFY(SUCCEEDED(g_pObjectMap[0].RevokeClassObject()));
        _ATLRETHROW;
    }
    ATLVERIFY(SUCCEEDED(g_pObjectMap[0].RevokeClassObject()));
}
pVideoDmo->Initialize(CDmoMediaType(m_pMediaType), CopyYv12MediaBuffer);
ATLENSURE_SUCCEEDED(pGraphBuilder->AddFilter(pBaseFilter, CStringW(_T("Pass-Through DMO"))));
ATLENSURE_SUCCEEDED(pGraphBuilder->Connect(pOutputPin, _FilterGraphHelper::GetFilterPin(pBaseFilter, PINDIR_INPUT)));
pOutputPin = _FilterGraphHelper::GetFilterPin(pBaseFilter, PINDIR_OUTPUT)

What is being done in the code snippet above is:

• local object map with a single OBJECT_ENTRY item to have ATL manage class object registration/revokation for us
• registration of a private class/CLSID
• instantiation and initialization of a DMO Wrapper Filter which is to pick up our class
• cast back to native C++ pointer for easy further access (a private interface would be more accurate here)
• revokation for CLSID

For information, the interfaces queried from the DMO:

Find all "CVideoDmo::InternalQueryInterface", Hidden, Find Results 1, Current Document
CVideoDmo::InternalQueryInterface: Interface IMediaObject, Result 0x00000000
CVideoDmo::InternalQueryInterface: Interface IDMOQualityControl, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IDMOVideoOutputOptimizations, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IMediaObject, Result 0x00000000
CVideoDmo::InternalQueryInterface: Interface IWMGetSecureChannel, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMOpenProgress, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMDeviceRemoval, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IDirectVobSub, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IDirectVobSub, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IWMCodecAMVideoAccelerator, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IDirectVobSub, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IWMCodecAMVideoAccelerator, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IWMCodecAMVideoAccelerator, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IMediaSeeking, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IMediaPosition, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMFilterMiscFlags, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IVideoWindow, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IBasicAudio, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMFilterMiscFlags, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IKsPropertySet, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IReferenceClock, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IWMCodecAMVideoAccelerator, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMDeviceRemoval, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMOpenProgress, Result 0x80004002
Matching lines: 24

A Visual C++ .NET 2008 source code is available from SVN. Additional files will be required to compile, but binary is also incuded.

• audio input device unrelated to physical device, to avoid conditions when device is already in use by someone else
• non-zero audio signal which is independent of certain speaker or broadcasting service, including one that makes capture, transmission or rendering issues easily perceptible by human
• configurable to provide different audio media types, including through well known DirectShow interfaces, such as IAMStreamConfig
• configurable to present in system as both regular DirectShow Filter, and as an Audio Capture Source which can be enumerated by applications
• to be able to check how exactly other applications are accessing and configuring audio capture source

I added a new filter to the Media Tools library, a Tone Source Filter. The filter generates PCM Audio data, either infinite sine waveform, or interrupted signal  of requested parameters:

The filter accepts connection on PCM media types with flexible sampling rates in range 8 KHz through 200 KHz, 8-bit audio and 1 channel. Media type is also configurable through or, if not configured this way, the first enumerated media type off the Output pin is also configurable through property page and/or persistent setting accessible via private IDispatch derived interface property.

Additionally, the filter may configured as a system-wide available audio input device, such as for example available to VLC Media Player or Media Player Classic:

In order to configure the filter as such device, the library exports function DoToneSourceFilterDevicePropertySheetModal, which can be called using rundll32 utility (“rundll32 Acquisition.dll,DoToneSourceFilterDevicePropertySheetModal” from command line):

A partial Visual C++ .NET 2008 source code is available from SVN, release binary included.

File and Class Summary

Acqusition.dll

Acqusition.dll (download) hosts the following classes:

• DirectShow Filters
  • Tone Source Filter, to generate reference/debug audio data

Class Overview

Tone Source Filter

The filter generates uninterrupted or interrupted reference sine waveform in form of PCM audio data.

• Filter Executable: Acquisition.dll
• Filter CLSID: __uuidof(ToneSourceFilter) {8002935A-B2EC-40ef-968C-E0358E5DED10}
• Filter Property Page CLSID: __uuidof(ToneSourceFilterGeneralPropertyPage), {EBD8ABB2-6DD3-4c54-A7F1-9FE4DA283EDF}, ToneSourceFilterPreferedFormatPropertyPage, {EE224187-4FA3-4c3f-9D5D-492694CCFEB7}
• Filter Merit: MERIT_DO_NOT_USE
• Filter Category: CLSID_LegacyAmFilterCategory (also configurable as CLSID_AudioInputDeviceCategory)
• Filter Interfaces: IPersistStreamInit, IPersistStream, ISpecifyPropertyPages, IPersistPropertyBag, IBaseFilter, IMediaFilter, IPersist, IAMovieSetup, IAMFilterMiscFlags, IToneSourceFilter, IDispatch
• Filter Pins: single ouput pin (Ouput)
• Output Pin Media Types: MEDIATYPE_Audio/MEDIASUBTYPE_PCM
• Output Pin Interfaces: IPin, IMemInputPin, IAMPushSource, IAMLatency, IAMBufferNegotiation, IKsPropertySet, IAMStreamConfig

Remarks

The hosting library (DLL) exposes DoToneSourceFilterDevicePropertySheetModal function which provides GUI to configure the filter as one or more audio capture source device, which can be enumerated by System Device Enumerator.